面向对象的特征

#                                                 ============     面向对象的三大特性
# 　　继承
# 　　多态
# 　　封装

# 继承
# class ParentClass1: pass
# class ParentClass2: pass
# # 在python3中 所有的类都继承自object
# print(ParentClass1.__bases__)
# class ChildClass1(ParentClass1):  # 单继承
#     pass
# # class ChildClass2(ParentClass2):  # 多继承
# #     pass
# print(ChildClass1.__bases__)  # 会显示该类的一个父类
# print(ChildClass2.__base__)  # 会显示该类的一个父类
# print(ChildClass2.__bases__)  # 会显示该类的所有父类


#继承细节
# 猫类 : 吃eat 喝drink 睡sleep 爬树climb
# 狗类 : 吃eat 喝drink 睡sleep 看家watch
# class Pet:
#     def __init__(self,name,kind,food):
#         self.name = name
#         self.kind = kind
#         self.food = food
#
#     def eat(self):
#         print('%s吃%s'%(self.name,self.food))
#
#     def drink(self):
#         print('%s在喝水'%self.name)
#
#     def sleep(self):
#         print('%s在睡觉' % self.name)
#
# class Cat(Pet):
#     def climb(self):      # 派生方法
#         print('%s在爬树' % self.name)
#
# class Dog(Pet):
#     def watch(self):     # 派生方法
#         print('%s在看家' % self.name)
#
# tom = Cat('Tom','暹罗猫','猫粮')  # 子类使用名字(方法和静态变量),如果在子类中没有,就使用父类的
# # Cat('Tom','暹罗猫','猫粮') 实例化
# # 实例化这个类
#     # 创建一个空对象
#     # 执行__init__方法:子类没有用父类的
# hei = Dog('小黑','2哈','狗粮')
# tom.eat()
# hei.eat()
# tom.climb()
# hei.watch()

# 人狗大战 继承
# class Animal: # 动物
#     def __init__(self,name,aggr,hp):  #方法 动态属性  内置的双下方法
#         self.name = name    # 对象属性 实例属性
#         self.aggr = aggr
#         self.hp = hp
#
# class Person(Animal):    # 类名 Person
#     def __init__(self,name,sex,aggr,hp):
#         self.sex = sex   # 派生属性
#         Animal.__init__(self,name,aggr,hp)
#         super().__init__(name,aggr,hp)
#
#     def attack(self,dog):  # 自定义方法
#         print('%s打了%s'%(self.name,dog.name))
#         dog.hp -= self.aggr
#
# class Dog(Animal):
#     def __init__(self,name,kind,aggr,hp):
#         self.kind = kind   # 派生属性
#         Animal.__init__(self,name,aggr,hp)
#     def bite(self,person):
#         print('%s咬了%s'%(self.name,person.name))
#         person.hp -= self.aggr

# alex = Person('alex','不详',1,250)
# 首先创建一个Person的对象,
# 初始化:找init方法,自己有调用自己的

# 父类和子类拥有同名的方法时,子类的对象只会调用子类的
# 如果想要调用父类的方法,需要 父类名.方法名(self,其他参数)
# hei = Dog('小黑','teddy',260,10000)
# alex.attack(hei)
# hei.bite(alex)


# 练习
# class Foo:
#     def __init__(self):
#         self.func()
#
#     def func(self):
#         print('in Foo')
#
# class Son(Foo):
#     def func(self):
#         print('in son')

# f = Foo()
# Son()


# super 关键子
# super
# class Animal: # 动物
#     def __init__(self,name,aggr,hp):  #方法 动态属性  内置的双下方法
#         self.name = name    # 对象属性 实例属性
#         self.aggr = aggr
#         self.hp = hp
#     def eat(self):
#         print('in Animal eat')
#
# class Person(Animal):    # 类名 Person
#     def __init__(self,name,sex,aggr,hp):
#         self.sex = sex   # 派生属性
#         # Animal.__init__(self,name,aggr,hp)
#         super().__init__(name,aggr,hp)
#         # 单继承中 super会寻找父类
#         # 且在使用super调用父类方法的时候不需要再传self参数
#     def eat(self):
#         print('in Person eat')
#         # Animal.eat(self)
#         # super().eat()
# alex = Person('alex','不详',1,250)
# print(alex.__dict__)
# Animal.eat(alex)
# super(Person,alex).eat()

#继承顺序
# class A:
#     def wahaha(self):print('in A')
#
# class B(A):
#     def wahaha(self):print('in B')
#
# class C(B):
#     def wahaha(self):print('in C')
#
# class D(C):pass
#     # def wahaha(self):print('in D')
#
# d = D()
# d.wahaha()

# 不要发生循环继承
# 依赖倒置原则 :
# 高层模块不应该依赖低层模块


# 钻石继承顺序
# coding:utf-8
# class A:
#     def wangwang(self):
#         print('in A')
# class B(A):
#     def wangwang(self):
#         super().wangwang()    # 'in C '
#         print('in B')
# class C(A):
#     def wangwang(self):
#         print('in C')
# class D(B,C):pass
#
# d = D()
# d.wangwang()

# 在py3里 所有的多继承问题 都符合 广度优先算法


# class A:
#     def wangwang(self):
#         print('in A')

# class B(A):pass
#     # def wangwang(self):
#     #     print('in B')
#
# class C(A):pass
#     # def wangwang(self):
#     #     print('in C')

# class D(B):pass
#     # def wangwang(self):
#     #     print('in D')
#
# class E(C):pass
#     # def wangwang(self):
#     #     print('in E')
#
# class F(D,E):pass
#     # def wangwang(self):
#     #     print('in F')
#
# f = F()
# f.wangwang()
# print(F.mro())
# python3中的所有类 都默认继承object

# 如果一个类 继承了object 这个类就被称为新式类
# 没有继承object类 就被称为经典类

# 深度优先 广度优先 都是一种遍历算法,把这个图中所有的项都走一遍,且不会重复

#经典类 遵循 深度优先算法 且没有mro方法  python2
#新式类 遵循 广度优先算法 有mro方法  py2 py3
# py3 super
# 单继承中  super就是找父类
# 多继承    super寻找的轨迹是根据mro(广度优先)顺序的