面向编程（二）继承

一.基础

class Garen:
    camp='Demacia'
    n=0
    hobby=[]        #类的变量一般定义成不可变的
    def __init__(self,nickname,aggressivity=58,life_value=455):
        self.nickname=nickname           #为自己的盖伦起了个别名
        self.aggressivity=aggressivity
        self.life_value=life_value
        Garen.n+=1                #类.n  对象每产生一个名字（统计实例化次数）
        #self.hobby=[]
    def attack(self,enemy):
        enemy.life_value-=self.aggressivity

g1=Garen('草丛伦')
g2=Garen('草丛伦2')
g3=Garen('草丛伦3')
print(g1.hobby,id(g1.hobby))
print(g2.hobby,id(g2.hobby))
print(g3.hobby,id(g3.hobby))
print(g1.n)          #
print(g3.n)





[] 13837768               #指向同一个列表，同一个内存地址
[] 13837768
[] 13837768
3
3

g1.hobby.append('g1 hobby')
g2.hobby.append('g2 hobby')
g3.hobby.append('g3 hobby')
print(g1.hobby)
g1.camp='12123'
print(g1.camp)



['g1 hobby', 'g2 hobby', 'g3 hobby']    #可变类型
12123　　　　　　　　　　　　　　　　　　　  #不可变类型

class Garen:
    camp='Demacia'
    n=0
    #hobby=[]        #类的变量一般定义成不可变的
    def __init__(self,nickname,aggressivity=58,life_value=455):
        self.nickname=nickname           #为自己的盖伦起了个别名
        self.aggressivity=aggressivity
        self.life_value=life_value
        Garen.n+=1                #类.n  对象每产生一个名字（统计实例化次数）
        self.hobby=[]       #定义在自己里面，别的实例进不来
    def attack(self,enemy):
        enemy.life_value-=self.aggressivity
g1=Garen('草丛伦')
g2=Garen('草丛伦2')
g3=Garen('草丛伦3')


g1.hobby.append('g1 hobby')
g2.hobby.append('g2 hobby')
g3.hobby.append('g3 hobby')
print(g1.hobby)





['g1 hobby']

class Garen:
    camp='Demacia'
    n=0
    #hobby=[]        #类的变量一般定义成不可变的
    def __init__(self,nickname,aggressivity=58,life_value=455):
        self.nickname=nickname           #为自己的盖伦起了个别名
        self.aggressivity=aggressivity
        self.life_value=life_value
        Garen.n+=1                #类.n  对象每产生一个名字（统计实例化次数）
        self.hobby=[]       #定义在自己里面，别的实例进不来
    def attack(self,enemy):
        print('=====>')
        enemy.life_value-=self.aggressivity

g1=Garen('草丛伦')
g2=Garen('草丛伦2')
# print(g1.hobby,id(g1.hobby))
# print(g2.hobby,id(g2.hobby))
# print(g3.hobby,id(g3.hobby))
# print(g1.n)          #
# print(g3.n)
print(g1.attack)
print(Garen.attack)
g1.attack(g2)            #绑定方法指向函数的功能，就是绑定到每个对象身上的
                        #对象调绑定方法操作的就是对象自己，Garen.attack(g1,g2) g2为位置参数
#其实就相当于Gaven.attack(g1,g2)
#区别：可以把对象自己当成参数传进去

二.继承

1.什么是继承

　　继承是一种创建新的类的方法，在python中，新建的类可以继承自一个或者多个父类，原始类称为基类或超类，新建的类称为派生类或子类。

　　分为： 单继承和多继承

class ParentClass1:    #定义父类
    pass
class ParentClass2:    #定义父类
    pass
class SubClass1(ParentClass1): #单继承，基类是ParentClass1,派生类是SubClass
    pass
class SubClass2(ParentClass1,ParentClass2):  #多继承，用逗号分隔开多个继承的类
    pass


print(SubClass1.__bases__)
print(SubClass2.__bases__)
print(ParentClass1.__bases__)           #python的类默认继承object类，object是所有python类的基类，它提供一些常见方法如(_str_)实现



(<class '__main__.ParentClass1'>,)
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)
(<class 'object'>,)

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

抽象分成两个层次： 

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

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

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

 

继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。

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

class Hero:
    def __init__(self,nickname,aggressivity,life_value):
        self.nickname=nickname
        self.aggressivity=aggressivity
        self.life_value=life_value

    def move_forward(self):
        print('%s move forward' %self.nickname)

    def move_backward(self):
        print('%s move backward' %self.nickname)

    def move_left(self):
        print('%s move forward' %self.nickname)

    def move_right(self):
        print('%s move forward' %self.nickname)

    def attack(self,enemy):
        enemy.life_value-=self.aggressivity
class Garen(Hero):
    pass

class Riven(Hero):
    pass

g1=Garen('草丛伦',100,300)
r1=Riven('锐雯雯',57,200)

print(g1.life_value)
r1.attack(g1)
print(g1.life_value)

'''
运行结果
300
243
'''

2.派生

如果在子类中定义与父类相同的，走子类中的。也可以定义一个新的。

class Hero:
    def __init__(self,nickname,
                 aggressivity,
                 life_value):
        self.nickname = nickname
        self.aggressivity = aggressivity
        self.life_value = life_value

    def attack(self,enemy):
        enemy.life_value -= self.aggressivity


class Garen(Hero):
    camp='Demacia'
    def attack(self,enemy):
        print('from garen attack')        #如果在子类中定义与父类相同的，走子类中的
    def fire(self):
        print('%s is fireing' %self.nickname)

class Riven(Hero):
    camp='Noxus'

g1=Garen('garen',18,200)
r1=Riven('rivren',18,200)
g1.attack(r1)
print(g1.camp)
print(r1.camp)

　1.重用

class Hero:
    def __init__(self,nickname,
                 aggressivity,
                 life_value):
        self.nickname = nickname
        self.aggressivity = aggressivity
        self.life_value = life_value

    def attack(self,enemy):   5.
        print('Hero attack')
        enemy.life_value -= self.aggressivity
class Garen(Hero):
    camp='Demacia'
    def attack(self,enemy):     # 3.指向类的函数 self=g1,enemy=r1
        Hero.attack(self,enemy)     #重用父类的 4
        print('from garen attack')        #如果在子类中定义与父类相同的，走子类中的
    def fire(self):
        print('%s is fireing' %self.nickname)

class Riven(Hero):
    camp='Noxus'

g1=Garen('garen',18,200)  #  1.g1的名称空间
r1=Riven('rivren',18,200)
g1.attack(r1)　　　　　　# 2.g1的绑定方法  不用传参数，实际传的g1和r1


Hero attack
from garen attack

class Hero:
    def __init__(self,nickname,
                 aggressivity,
                 life_value):
        self.nickname = nickname
        self.aggressivity = aggressivity
        self.life_value = life_value

    def attack(self,enemy):
        print('Hero attack')
        enemy.life_value -= self.aggressivity
class Garen(Hero):
    camp='Demacia'
    def __init__(self,nickname,aggressivity,life_value,script):       ##
        Hero.__init__(self,nickname,aggressivity,life_value)  ##调用父类功能
        self.script = script   #新属性
    def attack(self,enemy):  #self=g1,enemy=r1 #在这里定义新的attack，不再使用父类的attack,且不会影响父类
        Hero.attack(self,enemy)     #重用父类的
        print('from garen attack')        #如果在子类中定义与父类相同的，走子类中的
    def fire(self):
        print('%s is fireing' %self.nickname)

class Riven(Hero):
    camp='Noxus'

g1=Garen('garen',18,200,'人在塔下') #Garen.__init__(g1,'garen',18,200,'人在塔下')

2.组合

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

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

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

python_obj=Course('python',15800,'7m')
t1=Teacher('egon','male',python_obj)
s1=Student('cobila','male',python_obj)

　　print(s1.course.name)
　　print(t1.course.name)

继承: 类与类之间是的关系，完成代码重用   （人和狗都是动物）

组合：类与类之间有的关系，（老师，学生与生日    老师，学生与课程  学生与分数）

3.接口与归一化设计

继承

一:：继承基类的方法，并做出自己的改变或者扩展（代码重用）

二：声明某个子类兼容于某基类，定义一个接口类Interface，接口类定义了一些接口名（就是函数名）

继承的第二种含义非常重要，它又叫接口继承。接口继承实质上是要求做一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理时限了特定接口的所有对象——这在程序设计上，叫做归一化。

1.主动抛出异常

class Animal:
    def run(self):
        raise AttributeError('子类必须实现这个方法')
    def speak(self):
        raise AttributeError('子类必须实现这个方法')

class People(Animal):
    pass
    # def run(self):
    #     print('人正在走')
    # def speak(self):
    #     print('说话')

peo1=People()
peo1.run()





   raise AttributeError('子类必须实现这个方法')
AttributeError: 子类必须实现这个方法

　　

2.抽象类

本质还是类，与普通类额外的特点是：加了装饰器的函数，子类必须实现他们。

普通类除了raise抛出异常没有其他方法限制子类必须实现

import abc
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod          #必须被子类实现run
    def run(self):
        pass
    @abc.abstractmethod          #必须被子类实现speak
    def speak(self):
        pass


class People(Animal):
    def run(self):
        pass

    def speak(self):
        pass
peo1=People()                   #做实例化时会报错