Python：面向对象的三大特性

面向对象的三大特性

封装，继承，多态

继承：可以有效的节省代码

python中类分为两种：

　　　　新式类，经典类。

　　　　python3x 中所有的类都默认继承object类,继承object类的类称为新式类。

　　　　Python2 中默认是经典类，如果改成新式类，就让类(object) 继承object类

　　　　新式类 ：遵循的广度优先。
　　　　经典类 ：遵循的深度优先。

                通过mro（类名）方法可以查看到类的继承循序

继承的问题：

class Animal:
    soup = '灵魂'
    def __init__(self,varieties, sex, color):
        self.varieties = varieties
        self.sex = sex
        self.color = color

    def eat(self):
        print('吃')

class Cat(Animal):
    a = Animal.eat
    def eat(self):
        print('猫吃饭')

class Bird(Animal):

    def __init__(self,varieties, sex, color,fly):
        # Animal.__init__(self,varieties, sex, color,)  　　　　 # 执行父类的方法第一种方式
        # super(Animal,self).__init__(varieties, sex, color,)   # 执行父类的方法第二种方式
        super().__init__(varieties, sex, color,)  　　　　　　　　# 执行父类的方法第二种方式 省略写法  super方法可以不用去关心父类具体名字。
        self.fly = fly  # 个性化的封装
    def eat(self):
        super().eat()
        print('鸟该吃饭了....')

cat1 = Cat('波斯猫', '公', '橘黄')
cat1.eat()

# 问题一：
# 执行顺序，所以执行 猫吃饭.

# 问题二：
# 猫，鸟，都有自己独立属性，如何使用共同的属性并且使用独立的属性。
b1 = Bird('鹦鹉','公', '绿色',800)
# print(b1.__dict__)
b1.eat()

在多继承当中，新式类中采用的是mro算法

我们可以使用print(类名.__mro__)方法查看到该类的继承顺序。

接口类、抽象类

定义一个基类,把基类中的方法定义成接口函数,可以限制继承他的子类必须实现这个方法，即所有的子类都必须兼容父类的方法。

import abc
class All_file(metaclass=abc.ABCMeta):  
    @abc.abstractmethod            #实现接口函数的装饰器
    def read(self):                #接口函数本身不用具体的实现,而是有继承他的子类自己去实现
        pass

    @abc.abstractmethod
    def write(self):
        pass

class Disk(All_file):
    def read(self):
        print('disk read')

    def write(self):
        print('disk write')

class Cdrom(All_file):
    def read(self):
        print('cdrom read')

    def write(self):
        print('cdrom write')


class Mem(All_file):
    def read(self):
        print('mem read')

    def write(self):
        print('mem write')
m1=Mem()
m1.read()
m1.write()

封装：

　　广义封装：封装到对象中的属性是一种封装。 类本身就算是一种封装

class Person:
    country = 'China'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def func(self):
        print(self.name)

p1 = Person('alex',1000)
p2 = Person('wusir',10000)
p1.func()

　　狭义分装：私有性封装，在类内部,通过 _ _ 开头定义的方法或静态变量，都称之为私有的

　　　　　　　私有：私有静态字段（私有静态变量），私有普通字段（私有对象属性），私有方法。

私有静态字段（私有静态变量）　　   
class Person:
    country = 'China' # 公有静态字段（公有静态变量）
    __name = 'oldboy' # 私有静态字段（私有静态变量）
    __age = 1000 # 私有静态字段（私有静态变量）
    def func1(self):
        return self.__name
print(Person.country)

#在类的外部不能调用
print(Person.__name)
p1 = Person()

print(p1.__name)
print(Person.__dict__['_Person__name'])
print(Person._Person__name)  #只要类执行,将类的内容加载到内存时，发现有 __变量名这样的静态变量或方法,Python解释器自动将__变量名
　　　　　　　　　　　　　　　　　#私有化后的静态变量或方法,类内部可以访问，父类以及类的外部不能访问。