这两天所学的都是面向对象，后面还有几天也是它，面向对象主要有三个大的模块，封装，继承，多态，（组合），昨天主要讲了面向对象的命名空间，还有组合的用法，今天是讲的继承还有继承里面所包括的钻石继承，以及多态的知识点。
创建一个类，关键字是class，然后后面加上类的名字，首字母大写即可，创建完了之后就得到了一个类的命名空间，
然后下面就是类的属性，分为静态属性（定义在类中的变量）和动态属性（定义在类中的方法），
然后就是属性，属性是类实例化得出的结果，创建一个属性就是创建了一个属性的命名空间，对象可以通过类对象指针找到类，然后调用类中的方法，而类找不到对象，无法调用对象中的方法。
再就是组合，在一个类中以另外一个类的对象作为属性，称为类的组合。
然后就是今天学的继承（子类对象调用父类方法指名道姓，super），以及继承里面的钻石继承，
继承就是有几个类，这几个类里面有一些相同的属性，那么就把这些个属性提取出来，作为一个基类（父类，超类），然后其余的各自不尽相同的属性就各自保留，那么其余的类就是子类也叫做派生类。这时我们得到的结果就叫做继承。
有一句话“ 高桌子低板凳都是木头 ”，这句话高度概括了继承的关系，木头是父类（超类，基类），高桌子和低板凳则都为子类（派生类）
那么之前学过的组合跟继承最大的区别就是一个字，“是”，“有”。组合中：A有B，那么A与B就为组合。继承中：A是B，那么A与B就为继承，且‘是’后面的名词叫做父类（超类，基类），即B是父类；‘是‘前面的名词叫做子类（派生类）。
还有一个概念，object，带有object关键字作为默认参数的类就是经典类，经典类在python2.7中有。不带有object关键字作为默认参数的类是新式类，在python3中，所有类都是新式类。这里补充一个super方法，当子类里面有一个派生类方法和父类里面的一个方法同名时，如果要调用派生类的就直接使用方法名调用，如果要调用父类里面的，就需要使用指名道姓方法调用，格式为：父类名.方法名（对象名）
这个格式可以放在类外面，也可以放在类里面，写法不变，放在类里面的时候，就放在子类的与父类方法同名的方法下面。
钻石继承（查找父类）：在python2中分为经典类和新式类，经典类的写法是class F：经典类中是深度优先原则；而新式类的写法是class F（object):,新式类中是广度优先原则。
：在python3中经典类和新式类统一并称为新式类，而且还提供了一种简单的查询方法，就是使用mro直接可以得到父类的查询踪迹。
还有就是多态。python本身自带多态。
对于昨天所学的面向对象的命名空间的回顾：
# 命名空间 ：
# 静态属性 ： 属于类内部的命名空间
# 动态属性 ： 属于类内部的命名空间
# 对象属性 ： 属于对象的,在类内和self发生联系，在类外和对象名发生联系
# 可以查看静态属性的都有哪些：类名 对象名
# 可以调用类中的方法的有哪些：类名.方法名(对象),对象.方法名()
# 类到对象之间没有联系，而对象到类之间有联系。
# 对象在查找名的时候，会现在我自己的空间里找，再到类的空间里找
# 组合 ：
#将一个对象作为另一个类的对象的属性
# 老师有生日
# 圆环
# 人有武器
面向对象的继承：
#继承 ： 模糊到具体
#抽象 ： 具体到模糊
#先抽象后继承
#继承有几种： 单继承，多继承
# 猫类 抓老鼠
# 狗类 看门
# 动物 吃 喝 睡
# class Animal:
# def eat(self):
# print('eating')
#
# def drink(self):
# print('drinking')
#
# def sleep(self):
# print('sleeping')
#
# class Cat(Animal):
# def catch_mouse(self):
# print('yeah')
#
# class Dog(Animal):
# def watch_door(self):
# print('wangwangwang') # kitty = Cat()
# kitty.eat()
# snoopy = Dog()
# snoopy.eat() # 人类 狗类 相同的属性 提取了一个__init__方法，在这个方法里放一些共有的属性
# 猫类和狗类 相同的方法 直接把相同的方法提取出来，放在基类里 # 他大舅他二舅都是他舅 —— 实例化
# 高桌子低板凳都是木头 —— 继承 # 人 狗 相同属性的同时 还有一些不同的属性
# class Animal:
# def __init__(self,aggressivity, life_value,name):
# self.name = name # 每一个角色都有自己的昵称;
# self.aggressivity = aggressivity # 每一个角色都有自己的攻击力;
# self.life_value = life_value # 每一个角色都有自己的生命值;
# def eat(self):
# self.life_value += 10
#
# class Person(Animal):
# def __init__(self, name, aggressivity, life_value, money):
# Animal.__init__(self, name, aggressivity, life_value)
# self.money = money #派生属性：父类没有的属性
#
# def attack(self,dog):
# dog.life_value -= self.aggressivity
#
# def get_weapon(self,weapon_obj):
# if self.money > weapon_obj.price:
# self.money -= weapon_obj.price # 金老板花钱买武器
# self.weapon = weapon_obj # 金老板装备打狗棒
# self.aggressivity += weapon_obj.aggr # 金老板的攻击力增加了
# class Dog(Animal):
# def __init__(self, name, breed, aggressivity, life_value):
# Animal.__init__(self,aggressivity,life_value,name)
# self.breed = breed # 每一只狗都有自己的品种; #派生属性：父类没有的属性
#
# def bite(self,people): # 派生方法 ：父类没有的方法
# people.life_value -= self.aggressivity
#
# def eat(self):
# Animal.eat(self)
# print('dog is eating') # snoopy = Dog('太白','京巴',250,500)
# print(snoopy.breed)
# print(snoopy.name)
# # Animal.eat(snoopy)
# snoopy.eat()
# print(snoopy.life_value)
# snoopy.eat()
# print(snoopy.life_value)
#派生属性 ： 在自己的init方法里 使用父类的init方法 —— 指名道姓调用方法
#派生方法 ： 在子类中增加父类没有的
#只要子类有，就有子类的
#只要想用父类，Animal.eat(snoopy) 父类名.父类的方法(子类对象) 2.7经典类中 # 在新式类
# class Animal:
# def __init__(self,aggressivity, life_value,name):
# self.name = name # 每一个角色都有自己的昵称;
# self.aggressivity = aggressivity # 每一个角色都有自己的攻击力;
# self.life_value = life_value # 每一个角色都有自己的生命值;
# def eat(self):
# self.life_value += 10
#
# class Person(Animal):
# def __init__(self, name, aggressivity, life_value, money):
# # Animal.__init__(self, name, aggressivity, life_value)
# super().__init__(name, aggressivity, life_value) #新式类
# self.money = money #派生属性：父类没有的属性
#
# def attack(self,dog):
# dog.life_value -= self.aggressivity
#
# def get_weapon(self,weapon_obj):
# if self.money > weapon_obj.price:
# self.money -= weapon_obj.price # 金老板花钱买武器
# self.weapon = weapon_obj # 金老板装备打狗棒
# self.aggressivity += weapon_obj.aggr # 金老板的攻击力增加了
# class Dog(Animal):
# def __init__(self, name, breed, aggressivity, life_value):
# # Animal.__init__(self,aggressivity,life_value,name)
# # super(Dog,self).__init__(aggressivity,life_value,name)
# super().__init__(aggressivity,life_value,name)
# self.breed = breed # 每一只狗都有自己的品种; #派生属性：父类没有的属性
#
# def bite(self,people): # 派生方法 ：父类没有的方法
# people.life_value -= self.aggressivity
#
# def eat(self):
# # Animal.eat(self)
# super().eat()
# print('dog is eating')
# snoopy = Dog('太白','京巴',250,500)
# print(snoopy.breed)
# print(snoopy.name)
# snoopy.eat()
# print(snoopy.life_value)
# super(Dog,snoopy).eat() #Animal.eat(snoopy)
# print(snoopy.life_value) #用子类的对象，调用父类的方法：
#如果子类中没有这个方法，直接就使用父类的
#如果子类中有同名方法：
# 经典类 指名道姓 类名.方法名(子类对象) 类内外一致
# 新式类 super方法 super(子类名，子类对象).方法名() 类内可以省略super的参数 class Foo:
def __init__(self):
self.func() def func(self):
print('Foo.func') class Son(Foo):
def func(self):
print('Son.func') s = Son() #钻石继承问题
钻石继承：
#coding:utf-8
#经典类和新式类的多继承问题，继承顺序问题
#经典类 : 博大精深 所以经典类就是深度优先
#新式类 ：广度优先
class F(object):
pass
def f(self):
print('F')
class E(F):
pass
def f(self):
print('E')
class D(F):
pass
# def f(self):
# print('D')
class B(D):
pass
# def f(self):
# print('B')
class C(E):
pass
def f(self):
print('C')
class A(B,C):
pass
# def f(self):
# print('A') a = A()
a.f()
print(A.mro()) #新式类：查看继承顺序
# class A(object):pass #新式类 # 在好多个有继承关系的类里面，找一个方法，找的顺序问题
# 继承三层
# py3 —— 广度优先
# py2 —— 新式类
#面试 —— 能对应 新式类 是广度优先 经典类是深度优先 # 继承 —— 抽象类和接口类 —— 是一种设计模式 # 多态
多态：
这下面的图片就是我们理解多态的核心
==================================================================================================================================================
#python不支持多态的
class Animal:pass class Person(Animal):
def attack(self):
pass class Dog(Animal):
def attack(self):
pass def attack(obj): #多态
obj.attack() d = Dog()
p = Person()
attack(d) #d.attack()
attack(p) #p.attack() print(10) #鸭子类型 list tuple是一对鸭子类型
#列表
#元组
# 切片 ： 字符串 列表 元组
# + ：字符串 列表 数字
def len(l):pass # 继承
# 子类对象调用父类方法 ：指名道姓，super
# 钻石继承问题 #多态 - 鸭子类型 #做总结
#写博客
#画思维导图 —— 周五交
#写大作业 —— 把类设计好写好，之间的关系理清楚，做完登录，设计角色的功能
#之前的知识
面向对象需要画思维导图，这个需要后续补上