面向对象基础（二）

# 例：#  写三个类: 狗,猫,鸡, 每个类中都有 吃 喝  自己的方法  最后定义一个Animal类,

class Animal:
    def __init__(self,name,sex,age):
        self.name = name
        self.sex = sex
        self.age = age

    def eat(self,option):
        print('%s 在吃 %s' %(self.name,option))

    def drink(self,option):
        print('%s 在喝 %s' %(self.name,option))

# 以下两个类继承了Animal

class Cat(Animal):
    def miaow(self):
        print('MM')

class Person(Animal):
    def work(self):
        print('Working')



c1 = Cat('MM','Wom','Tom')

c1.eat('鱼')
# result:MM 在吃 鱼

# 可以根据查找链获取到继承来的字段和方法包括构造函数
# 只执行父类的方法:子类中不要定义与父类同名的方法
# 只执行子类的方法:在子类创建这个方法.
# 那么如果我们既要执行子类又要继承父类呢?比如Cat类的实例需要一个特殊的属性hair
class Cat(Animal):
    def __init__(self,name,sex,age,hair):
        # hair属性是子类独有的第一种方式
        Animal.__init__(self,name,sex,age)
        self.hair = hair

    def miaow(self):
        print('MM')


c1 =  Cat('MM','Wom','Tom','blue')
print(c1.hair)
# result:blue，这种方法非常少见通常都是使用python中的super方法

class Cat(Animal):
    def __init__(self,name,sex,age,hair):
        # hair属性是子类独有的第一种方式
        super().__init__(name,sex,age)
        #等同于 super(Cat, self).__init__(name, sex, age)
        # super当中两个参数第一个参数传入子类，第二个参数是实例对象，当他调用父类中方法时会自动将self传入
        self.hair = hair


    def miaow(self):
        print('MM')


c1 =  Cat('MM','Wom','Tom','blue')
print(c1.hair)

#类分为新式类与经典类，在python3中都是新式类
# 在python中继承Objct的类都叫做新式类,python2默认是经典类,我们手动继承Objct则转换为新式类
# 新式类和经典类的区别在于多继承
# 新式类广度优先又称钻石查找,经典类遵循深度优先
# 例:
class A:
    def func(self):
        print('A')

class B(A):
    pass
    # def func(self):
    #     print('B')

class C(A):
    pass
    # def func(self):
    #     print('C')

class D(B):
    pass
    # def func(self):
    #     print('D')

class E(C):
    pass
    # def func(self):
    #     print('E')


class F(E,D,C):
    pass
    # def func(self):
    #     print('F')

o1 = F()

print(F.mro())
# result:[<class '__main__.F'>, <class '__main__.E'>, <class '__main__.D'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
# 我们从查找顺序上能够得出广度优先的算法
# 在新式类中python在进行查找时，每查一个类节点它都会与后面的类链进行比较，发现有重合的类节点时，它会放弃当前类链，向后查找，它的计算方式不详细介绍
# 经典类深度优先不太多介绍，一条类链走到底然后查下一条类链