铁乐学python_day20_面向对象编程2

面向对象的组合用法

软件重用的重要方式除了继承之外还有另外一种方式，即：组合

组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合。

例：人狗大战，人类绑定上武器来对狗进行攻击：

# 定义一个武器类
class Weapon:
    # 该武器的技能有劈砍
    def cleave(self, target):
        target.hp -= 50 # 劈砍技能对目标造成50点伤害

# 定义一个人类
class Person:
    def __init__(self, name, sex, hp, atk):
        self.name = name
        self.sex = sex
        self.hp = hp
        self.atk = atk
        self.weapon = Weapon() # 给角色绑定一个武器

# 定义一个狗类
class Dog:
    def __init__(self, name, kind, hp, atk):
        self.name = name
        self.kind = kind
        self.hp = hp
        self.atk = atk

# 实例化一个人类角色
tiele = Person('tiele', '男', 30, 10, )
# 实例化一个狗类角色
xiaobai = Dog('小白', '金毛寻回犬', 60, 15)
# 人类装备上武器使用武器技能cleave进行攻击狗类
tiele.weapon.cleave(xiaobai) # 这种用法就叫做组合
print(xiaobai.hp)  # 显示10，表明目标的确hp-50了。

用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系。比如人物有武器、有武学等。

当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好。

再举一个老师有要教的课程和生日日期的例子如下：

class BirthDate:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

class Course:
    def __init__(self, name, price, period):
        self.name = name
        self.price = price
        self.period = period

class Teacher:
    def __init__(self, name, sex, birth, course):
        self.name = name
        self.sex = sex
        self.birth = birth
        self.course = course

# 实例化一个老师的同时，传参的时候还可以传另一个实例化的对象
tiele = Teacher('铁乐', '男', BirthDate(1999, 4, 1), Course('python', '19800', '5 months'))
# 查看时可以直接用组合的方式查看
print(tiele.course.name, tiele.birth.year)  # python 1999
print(tiele.course.price, tiele.birth.month) # 19800 4

面向对象的三大特性

分别是继承、多态、封装。

什么是继承？

继承是一种创建新类的方式，

在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，

新建的类称为派生类或子类。

python中类的继承分为：单继承和多继承。

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

#单继承，基类是ParentClass1，派生类是SubClass
class SubClass1(ParentClass1):
    pass

#python支持多继承，用逗号分隔开多个继承的类
class SubClass2(ParentClass1,ParentClass2):
    pass

# 查看继承
print(SubClass1.__bases__)
# __base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
# (<class '__main__.ParentClass1'>,)
print(SubClass2.__bases__)
# (<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，
它提供了一些常见方法（如__str__）的实现。

print(ParentClass1.__base__)  # <class 'object'>
print(ParentClass2.__bases__) # (<class 'object'>,)

继承与抽象（先抽象再继承）

抽象即抽取类似或者说比较像的部分。

抽象分成两个层次：

1.将奥巴马和梅西这俩对象比较像的部分抽取成类；

2.将人，猪，狗这三个类比较像的部分抽取成父类。

抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）

继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，

才能通过继承的方式去表达出抽象的结构。

抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类。

继承与重用性

在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，

但是类B的大部分内容与类A的相同时

我们不可能从头开始写一个类B，这就用到了类的继承的概念。

通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，

实现代码重用。

用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分设置大部分，

大大生了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，

也可以继承别人的，比如标准库，来定制新的数据类型，

这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大.

派生

当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），

需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。

在子类中，新建的重名的函数属性，在编辑函数内功能的时候，有可能需要重用父类中重名的那个函数功能，

应该是用调用普通函数的方式，即：类名.func()，此时就与调用普通函数无异了，因此即便是self参数也要为其传值.

在python3中，子类执行父类的方法也可以直接用super方法.

例：

class Animal:

    def __init__(self, name, hp, ad):
        self.name = name  # 对象属性 属性
        self.hp = hp  # 血量
        self.ad = ad  # 攻击力

    def eat(self, target):
        print('吃肉包子回血')
        target.hp += 10

class Person(Animal):  # 继承父类

    def __init__(self, name, hp, ad, sex):
        super().__init__(name, hp, ad)
	   # 使用super().__init__来继承父类属性的同时又可以同时有子类派生的属性
	   # 在单继承中，super负责找到当前类所在的父类，在这个时候不需要再手动传self
        self.sex = sex
        self.money = 0  # 派生属性

class Dog(Animal):

    def __init__(self, name, hp, ad, kind):
        super().__init__(name, hp, ad)
        self.kind = kind

    def bite(self, p):     # 派生方法
        p.hp -= self.ad
        print('%s咬了%s一口,%s掉了%s点血' % (self.name, p.name, p.name, self.ad))
	   super().eat(self)  # 使用super()---子类执行父类方法

super（）

super 只有在子父类拥有同名方法的时候，

想使用子类的对象调用父类的方法时，才使用super

super在类内 ： super().方法名(arg1,..)

指名道姓 ：父类名.方法名(self,arg1,..)

在py2中super必须传参数 super(子类名,self).方法名(arg...)

在单继承中就是单纯的寻找父类；

在多继承中就是根据子节点 所在图 的 mro顺序找寻下一个类。

多继承 钻石继承

经典类： python2中有，不继承object，查找节点时遵循深度优先遍历算法；

新式类： python3中都是新式类，在py2中继承object，查找节点时遵循广度优先遍历算法；

广度优先：当一个节点可以在深度广度上都有机会被访问到的时候，优先从广度（横向）上查找。

类名.mro()方法可以查看广度优先的顺序；

super()的作用：在广度优先中查看当前这个类的上一个节点。

遇到多继承和super
    对象.方法
        找到这个对象对应的类
        将这个类的所有父类都找到画成一个图
        根据图写出广度优先的顺序
        再看代码，看代码的时候要根据广度优先顺序图来找对应的super

经典类 :在python2.*版本才存在,且必须不继承object
    遍历的时候遵循深度优先算法
    没有mro方法
    没有super()方法

新式类 :在python2.X的版本中，需要继承object才是新式类
    遍历的时候遵循广度优先算法
    在新式类中，有mro方法
    有super方法,但是在2.X版本的解释器中，必须传参数(子类名，子类对象)

通过继承建立了派生类与基类之间的关系，它是一种'是'的关系，比如白马是马，人是动物。

当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好。

end

2018-4-16