Python面向对象的三大特征

面向对象的三大特征

• 封装：提高程序的安全性
• 继承：提高代码复用性
• 多态：提高程序的可扩展性和可维护性

1、封装

• 将数据（属性）和行为（方法）包装到休想中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。
• 在Python中没有专门修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前面可使用两个“_”。

外部调用内部私有变量格式：_类名__属性名

class Student:
    def __init__(self,name,age):
        self.name = name
        self.__age = age #属性不想被外部访问则加__
    def show(self):
        #内部可以使用age
        print(self.name,self.__age)

#调用
stu = Student(“Roc”,20)
stu.show()
print(stu.name)
#尽管私有化但是还是可以调用完全看程序猿自觉
print(stu._Student__age)

2、继承

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

#单继承
class 子类名(父类1,父类2...):
    pass
#多继承

#代码示例
class Person(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_nu)
        super().__init__(name,age)
        self.stu_nu = stu_nu

#调用
stu = Student(“Roc”,20,1708090)
#调用父类方法
stu.info()

3、方法重写

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

#重写方法
class Person(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_nu)
        super().__init__(name,age)
        self.stu_nu = stu_nu
    #重写方法
    def info():
        super().info()
        print(stu_nu)

4、object类

• object类是所有类的父类，因此所有类都有object类的属性和方法。
• 内置函数dir()可以查看指定对象所有属性
• Object有一个str()方法，用于返回一个对于“对象的描述，对应于内置函数str()经常用于print()方法，帮我们查看对象的信息，所以我们经常会对str()进行重写”

5、多态

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

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(Animal())
fun(Dog())
fun(Cat())
fun(Person)

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

• 静态语言(java)实现多态的三个必要条件
  • 继承
  • 方法重写
  • 父类引用指向子类对象
• 动态语言(python)的多态崇尚“鸭子类型”当看到一只鸟走起路来像鸭子、游起泳来像鸭子、收起来也像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为（方法）。

6、特殊方法和特殊属性

特殊属性

class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age)
        self.name = name
        self.age = age

#调用
x = C()
print(x.__dict__)

class Student:
    def __init__(self.name):
        self.name = name
    def __add__(self,other):
        return self.name+other.name
stu1 = Student(“Jack”)
stu2 = Student(“李四”)
s = stu1+stu2 #需要重写__add__()才能实现
s = stu1.__add__(stu2)
print(len(stu1))# 需要重写__len__()才能运行

7、类的浅拷贝与深拷贝

变量的赋值操作

• 只是形成两个变量，实际还是指向同一个对象

浅拷贝

• Python拷贝一般都是浅拷贝，拷贝时对象包含的子对象内容不拷贝，因此源对象与拷贝对象会引用同一个对象

深拷贝

• 使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象的所有子对象也不同

class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu = cpu
        self.disk = disk
# 变量的赋值
cpu1 = CPU()
cpu2 = cpu1
# 浅拷贝
import copy
disk = Disk()
computer = Computer(cpu1,disk)
#浅拷贝
computer2 = copy.copy(computer)
#深拷贝
computer3 = copy.deepcopy(computer)

8、总结