面向对象三大特性之继承

1.初识继承

什么是继承

　　继承是面向对象中的一个概念,是描述两个对象的关系,在程序中,继承描述的是类和类之间的关系

　　　　例如:a继承了b,a就可以使用b的属性和方法.a称之为子类,b称之为父类,也叫基类

为什么要使用继承

　　继承的一方可以使用被继承一方已有的东西,这样可以提高代码的重用性

如何使用继承

继承的基本语法

class A:
    # 父类中的方法和属性
    a = 1
    def a1(self):
        print('a1')

class B(A):
    # 子类中的方法和属性
    pass
b = B()  # 实例化子类B的对象b
print(b.a)  # 使用父类A中的属性
b.a1()  # 使用父类A中的方法

2.抽象与继承

抽象即抽取一系列对象或类中相同的部分,从而形成一个新的类

抽象的两个层次:

　　1.将一系列具有相同特征和行为的对象抽取成类

　　2.将一系列具有相同属性和方法的类抽取成父类

继承是基于抽象的结果,通过编程语言实现它,先经历抽象的过程,才能通过继承的方法表达抽象的结果

正确的使用继承:

　　1.先抽象再继承

　　2.继承一个已经存在的类,扩展或是修改原始的功能

 

3.属性的查找顺序

属性的查找顺序:对象---->类---->父类---->父类的父类---->.....直到object

# 属性的查找顺序
class A:  # 父类A定义了一个x
    x = 1

class B(A):  # 子类B也定义了一个x
    x = 2

b = B()
print(b.x)  # 在对象定义之前查找是查找子类B中
b.x = 3  # 对象也定义了一个x
print(b.x)  # 定义x之后,是在对象的属性中查找

先去对象中找,找不到再去类中找,找不到再去父类中找,一直找到object为止,找不到就报错

4.派生与覆盖

什么是派生类

　　当一个子类中出现了与父类中不同的内容时,这个子类就称之为派生类.通常情况下,我们不可能写一个和父类完全一模一样的子类,这样就失去了子类的意义,我们都会加一些代码,所以子类基本都是派生类.

# 派生类
class Person:
    def say_hi(self):  # 父类中有一个方法
        print('hi')

class Student(Person):
    def say_hello(self):  # 子类中也有一个新的方法
        print('hello')  # 此时这个子类就叫做派生类

s1 = Student()  # 实例化一个类的对象
s1.say_hi()  # 子类的对象可以调用父类的方法
s1.say_hello()

覆盖也称重写(overrides),当子类出现了和父类名称完全一致的属性或者方法时就叫做覆盖

# 覆盖
class Person:
    x = 1  # 父类中有一个属性
    def say_hi(self):  # 父类中有一个方法
        print('hi')

class Student(Person):
    x = 2  # 子类中有一个同名的属性
    def say_hi(self):  # 子类中也有一个同名的方法
        print('hello')

s1 = Student()
print(s1.x)  # 打印的是子类中的属性
s1.say_hi()  # 打印的是子类中的方法

5.子类访问父类的内容

访问的语法

语法:
```python
方式1:
super(当前类名称,self).你要调的父类的属性或方法
方式2:
super().你要调的父类的属性或方法
方式3:
类名称.你要调的父类的属性或方法(self)  
#方式3与继承无关 
```

子类访问父类的例子

# 子类访问父类的内容
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eat(self):
        print('%s会吃东西'%self.name)

class Student(Person):
    def __init__(self,name,age,id):
        # 第一种,父类名直接调用,这种方法什么地方都可以调用,与继承无关,并且需要写上对象本身
        Person.__init__(self,name,age)
        # 第二种,super(类名,对象本身),是python2内置的
        super(Student,self).__init__(name,age)
        # 第三种,python3做了优化可以内部不传参,推荐使用
        super().__init__(name,age)
        self.id = id

    def eat(self):
        super().eat()  # 第三种方法在访问父类的方法
        super(Student,self).eat()  # 第二种方法在访问父类的方法
        print('%s吃更好的东西'%self.name)

s1 = Student('sxc',18,188)
s1.eat()

初始化方法必须调用super

当你继承一个现有的类,并且你覆盖了父类的init方法时,必须在初始化方法的第一行调用父类的初始化方法,并传入父类所需的参数

需求:person父类中有name,age两个属性,子类student中我需要增加一个id的属性

# 继承中初始化方法必须调用super
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

class Student(Person):
    def __init__(self,name,age,id):  # 当子类需要增加属性时,需要再初始化一次,这时会覆盖父类的初始化方法
        super().__init__(name,age)  # 子类初始化方法必须加super,这样就能导入父类的初始化方法
        self.id = id  # 增加了id属性,原属性也能访问

    def say(self):
        print('%s说我真帅'%self.name)  # 如果不初始化方法不调用super,self.name就找不到,会报错

s1 = Student('sxc',18,1414)
s1.say()

练习:实现一个可以限制元素类型的容器(字符串,元组,列表,字典,集合)

# 实现一个可以限制元素类型的容器 (字典,列表,元组,集合,字符串)
class Newlist(list):
    def __init__(self,kind):
        super().__init__()  # 调用父类的初始化方法
        self.kind = kind

    def append(self,obj):
        if type(obj) == self.kind:
            super().append(obj)  # 调用父类的append方法
            print('加入成功')
        else:
            print('类型错误')

n = Newlist(int)  # 定义数据类型为int
n.append(123543)
print(n)

6.组合

组合是一种关系,描述两个对象之间有什么关系.将一个对象作为另一个对象的属性

　　组合一般都是在初始化方法时定义另一个对象

组合的目的:为了重用现有代码,提高代码的重用性

组合的例子

# 组合:一个类作为另一个类的属性,两者没有关联
# 定义一个英雄类
class Hero:
    def __init__(self,name,ad,hp,weapon):
        self.name = name
        self.ad = ad
        self.hp = hp
        self.weapon = weapon  # 英雄类和武器类没有关联,想要英雄类使用武器类,必须在初始化时就增加一个武器的属性
    # def attack(self,enemy):
    #     enemy.hp -= self.ad
    #     print('%s攻击了%s,掉了%s血,血量还剩%s'%(self.name,enemy.name,self.ad,enemy.hp))

# 定义一个武器类
class Weapon:
    def __init__(self,name,att):
        self.name = name
        self.att = att

    def weapon(self,hero,enemy):
        enemy.hp -= self.att
        print('%s使用了%s攻击了%s,掉了%s血,血量还剩%s' % (hero.name,self.name,enemy.name, self.att, enemy.hp))

w1 = Weapon('无尽之刃',100)  # 定义一把武器
h1 = Hero('亚索',50,500,w1)  # 定义一个攻击者
h2 = Hero('提莫',20,400,w1)  # 定义一个敌人

h1.weapon.weapon(h1,h2)  # 英雄用武器攻击了另一个英雄

什么时候使用继承:一个类是否包含了另一个类,即什么是什么的关系

什么时候使用组合:两个类的关联不大,即什么有什么的关系

 

7.多继承的问题:菱形继承(了解)

新式类和经典类

新式类:任何直接或者间接的继承于object的类就称之为新式类.(python3中的类的顶部都是object,所以python3中全是新式类)

经典类:不是object的子类,只有python2中有

新式类的继承顺序,先深度遍历,当遇到共同的父类时就广度遍历

新式类的继承顺序还可以通过调用mro方法来查看

# 定义类
class A:
    pass

class B:
    pass

class C(A):
    pass

class D(A):
    pass

class E(B):
    pass

class F(C):
    pass

class G(D):
    pass

class H(E,F,G):
    pass

print(H.mro())

新式类的继承顺序:H---->E---->B---->F---->C---->G---->D---->A

经典类的继承顺序,全部都是深度遍历

 

 经典类的继承顺序:H---->E---->B---->F---->C---->A---->G---->D

 21