Python面向对象三大特征

面向对象的三大特征

• 封装：提高程序的安全性
  • 将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。
  • 在Python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个“_”。
• 继承：提高代码的复用性。
• 多态：提高程序的可扩展性和可维护性。

class Student:
    def __init__(self, name, age):
        self.name = name
        self.__age = age  # 年龄不希望在类的外部被使用，所以加了两个_

    def show(self):
        print(self.name, self.__age)


stu = Student('张三', 19)
stu.show()  # 张三 19
print(stu.name)  # 张三 正常
# print(stu.__age) # 报错

print(stu._Student__age)  # 在类的外部可以通过_Student__age进行访问
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

继承

• 语法

calss 子类类名( 父类1,父类2... ):
		pass
1
2

如果一个类没有继承任何类，则默认继承object
Python支持多继承
定义子类时，必须在其构造函数中调用父类的构造函数

class Person(object):  # Person默认继承object，也可以不写object
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(self.name, self.age)


# 定义子类
class Student(Person):
    def __init__(self, name, age, stu_no):
        super().__init__(name, age)
        self.stu_no = stu_no


class Teacher(Person):
    def __init__(self, name, age, teacherofyear):
        super().__init__(name, age)
        self.teacherofyear = teacherofyear


stu = Student('张三', 20, '100001')
tea = Teacher('李四', 30, '200001')

stu.info()  # 张三 20
tea.info()  # 李四 30
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

• 多继承

class A():
    pass


class B():
    pass


class C(A, B):
    pass
1
2
3
4
5
6
7
8
9
10

• 方法重写
  • 如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其（方法体）进行重新编写
  • 子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法

class Person(object):  # Person默认继承object，也可以不写object
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(self.name, self.age)


# 定义子类
class Student(Person):
    def __init__(self, name, age, stu_no):
        super().__init__(name, age)
        self.stu_no = stu_no

    def info(self):  # 重写
        super().info()
        print(self.stu_no)


class Teacher(Person):
    def __init__(self, name, age, tea_no):
        super().__init__(name, age)
        self.tea_no = tea_no

    def info(self):  # 重写
        super().info()
        print(self.tea_no)


stu = Student('张三', 20, '100001')
tea = Teacher('李四', 30, '200001')

stu.info()  # 张三 20
            # 100001
tea.info()  # 李四 30
            # 200001

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

多态

简单地说，多肽就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型，乃然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法。

class Animal(object):
    def eat(self):
        print('动物吃东西')

class Dog(Animal):
    def eat(self):
        print('狗吃屎')

class Cat(Animal):
    def eat(self):
        print('猫吃鱼')

class Person(object):
    def eat(self):
        print('人吃饭')

#定义函数
def fun(obj):
    obj.eat()

#调用函数
fun(Dog())
fun(Cat())
fun(Animal())
fun(Person())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

静态语言和动态语言关于多态的区别

• 静态语言实现多态的三个必要条件

  • 继承
  • 方法重写
  • 父类引用指向子类对象

• 动态语言的多态崇尚“鸭子类型” 当看到一只鸟走起来像鸭子、游泳起来像鸭子、收起来也像鸭子，那么这只鸟就可以被成为鸭子。在鸭子类型中。不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为。

类的浅拷贝与深拷贝

• 变量的赋值操作
  只是形成两个变量，实际上还是指向同一个对象
• 浅拷贝
  python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象
• 深拷贝
  使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同

class CPU:
    pass


class DISK:
    pass


class PC:
    def __init__(self,cpu,disk):
        self.cpu=cpu
        self.disk=disk






# 变量的赋值
cpu1 = CPU()
cpu2 = cpu1
print(cpu1, id(cpu1))
print(cpu2, id(cpu2))
print("-----------------")

# (1)类浅拷贝
disk = DISK()
pc1 = PC(cpu1, disk)

# 浅拷贝
import copy

pc2 = copy.copy(pc1)
print(pc1, pc1.cpu, pc1.disk)
print(pc2, pc2.cpu, pc2.disk)
print("-----------------")

# 深拷贝
pc3 = copy.copy(pc1)
print(pc1, pc1.cpu, pc1.disk)
print(pc3, pc3.cpu, pc3.disk)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

以上代码运行的结果

<__main__.CPU object at 0x7f784278ffd0> 140154488029136
<__main__.CPU object at 0x7f784278ffd0> 140154488029136
-----------------
<__main__.PC object at 0x7f784278fe50> <__main__.CPU object at 0x7f784278ffd0> <__main__.DISK object at 0x7f784278fe80>
<__main__.PC object at 0x7f784278fd60> <__main__.CPU object at 0x7f784278ffd0> <__main__.DISK object at 0x7f784278fe80>
-----------------
<__main__.PC object at 0x7f784278fe50> <__main__.CPU object at 0x7f784278ffd0> <__main__.DISK object at 0x7f784278fe80>
<__main__.PC object at 0x7f784278f670> <__main__.CPU object at 0x7f78427b8460> <__main__.DISK object at 0x7f78427b83a0>
1
2
3
4
5
6
7
8