面向对象，继承

今日类容

1.什么是继承

2.继承的基本语法

3.继承与抽象

4.属性的查找顺序

5.派生与覆盖

6.如何实现一个可以限制元素的类型的列表

7.子类访问父类的内容

8.组合

9.菱形继承

一 什么是继承

1.什么是继承：

　　　　继承是一种关系，描述俩个对象之间，什么是什么的关系，

　　　　列如麦兜，佩奇，都是猪， 在程序中，继承描述的是类和类之间的关系

　　　　列如a继承了b，a就能直接使用b已经存在的方法和属性，a称之为子类，b称之为父类，也称之为基类

2.什么时候用继承：
　　　　假如已经有几个类，而类与类之间有共同的变量属性和函数属性，那就可以把这几个变量属性和函数属性提取出来作为基类的属性。而特殊的变量属性和函数属性，则在本类中定义，这样只需要继承这个基类，就可以访问基类的变量属性和函数属性。可以提高代码的可扩展性。

二 继承的基本语法

class Base:
    desc = "这是一个基类"

    def show_info(self):
        print(self.desc)

    def make_money(self):
        print("一天赚一个亿...")

#指定父类位Base
class SubClass(Base):
    pass

obj = SubClass()
#即使类中什么都没有也可以使用父类中已有的内容
obj.make_money()
print(obj.desc)

三 继承与抽象

1.什么是抽象：

　　　不具体，不清晰，看不懂，不是确切存在的，

　　　将多个子类中相同的部分，进行抽取，形成一个新的类，这个过程也称之为抽象的过程

 

2.如何正确的使用继承：
　　1.先抽象在继承

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

案例 ：

继承的错误示范：

class Teacher:
    school = 'oldboy'
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def say_hi(self):
        print('hello i am %s'%self.name)

    def teach(self):
        print('正在教书')

class Student(Teacher):
    pass

print(Student.school)
print(Student.say_hi)
print(Teacher.say_hi)

stu = Student('zy',19)
stu.say_hi()
stu.teach()
'''
上述案例中打招呼的技能老师和学生都有，但是老师教书的技能，学生不应该继承过来，这是不合理的
'''

继承的正确示范：

# 继承的改良版： 需要先抽象在继承

class OldBoyPerson:
    school = 'oldboy'
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def say_hi(self):
        print('hello i am %s '% self.name)

class Teacher(OldBoyPerson):
    def teach(self):
        print('正在教书')

class Student(OldBoyPerson):
    pass

# t = Teacher('zy',19)
# t.say_hi()
# t.teach()

s = Student('sm',19)
s.say_hi()
'''
总结：先抽象 定义一个把老师类和学生类都放在定义的一个人类之中，在人类中设置一个人类都会的打招呼技能
然后老师和学生在继承那个他们都会的一个技能就可以了

四 属性的查找顺序

查找顺序：对象自己的 - > 所在类中 -> 找父类 - >父类的父类 ->Object

案例：

class A:
    name = 'scot'


class B(A):
    name = 'rose'
    pass
b = B()
b.name = 'jack'

print(b.name)
print(b.__str__())

# 查找顺序
# 对象自己 - > 所在的类 -> 所在类的父类 -> 父类的父类  -> object

五 派生与覆盖

1.什么是派生：　　

　　　当一个子类中出现了与父类中不同的内容时,这个子类就称之为派生类

　　　通常子类都会写一些新的代码,不可能和父类完全一样 , 既通常都是派生类,

　　　所以派生类指的就是子类

　　

2.什么是覆盖：
　　　也称之为重写 overrides

　　　当子类出现了与父类名称完全一致的属性或是方法

 

案例：派生

派生：
当一个类继承自另一个类，并且这个子类，并且这个子类拥有与父类不同的类容
'''

class A:
    def show_info(self):
        print('hello world')

class B(A):
    pass

案例：覆盖

覆盖（重写）
子类中出现了与父类相同的属性或者方法，就会覆盖掉父类的方法和属性
'''
class A:
    text = '123'
    def sjow_info(self):
        print('hello world')


class B(A):
    text = '321'
    def show_info(self):
        print('hello nishishabi')

    pass

b = B()
b.show_info()
print(b.text)

六 如何实现一个可以限制元素的类型的列表

'''
继承已有的类来扩展新功能：

实现一个存储类，在提供基本的存取功能之外，还要可以限制存储元素的类型
'''

class MyList(list):
    def __init__(self,element_cls):
        # 当你覆盖init方法时，不要忘记调用super().init 函数让父类完成原有的初始化操作
        super().__init__()
        self.element_cls = element_cls


    def append(self, object):
        if object.__class__ == self.element_cls:
            super().append(object)
        else:
            print('你只能存储%s类型'%self.element_cls.__name__)#


# 可以指定存储的类型
li = MyList(str)
li.append(20)
li.append('123')
print(li)

七 子类访问父类的内容

1.语法　　

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

　　

注意：

　　当你继承一个现有的类,并且你覆盖了父类的init方法时,必须在初始化方法的

　　第一行调用父类的初始化方法,并传入父类所需的参数

案例：

class Person:
    text = '321'
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

    def sleep(self):
        print('人类已经睡着了，午睡，躺着睡')


    def say_hi(self):
        print(f'my name is {self.name} my age is {self.age}  my gender is {self.gender}',end=" ")

class Student(Person):
    text = '123'
    def __init__(self,name,age,gender,number):
# 因为父类已经存在了一个方法可以完成这三个参数的初始化，
# 所以就可以吧还缺的一个参数 补上就好了，其他的直接调用父类的进行初始化
#         Person.__init__(self,name,age,gender)# 指名道姓的调用

        # 方法二，py2 不支持
        super().__init__(name,age,gender)
        self.number = number

        # py 中的写法
        # super(Student, self).__init__(name,age,gender)
        # self.number = number

    # 访问父类的属性
    def show_text(self):
        print(self.text)
        print(super().text)

    def say_hi(self):
        super().say_hi()
        print(f'my num is {self.number}')

stu = Student('zy',19,'man','0001')

stu.say_hi()

stu.show_text()

八 什么是组合

1. 什么是组合：

　　指的是 一个类把另一个类的对象作为自己的属性 就称之为组合
　　无处不在
　　当你定义一个类 并且这个类拥有某种类型的属性时 就称之为组合
　　都是用用来重用代码的方式:
　　组合描述的是 什么拥有什么的关系   学生 有 书  学生有手机
　　基础描述的是 什么是什么的关系      麦兜是猪    猪猪侠也是猪

2.组合的目的：

　　也是为了重用现有代码

　　什么时候使用继承:分析两个类的关系,到底是不是:什么是什么的关系

　　什么时候使用组合:如果两个类之间 没有太大的关系,完全不属于同类

　　另外组合相比继承,耦合度更低了

案例：

class Phone:
    def __init__(self,price,kind,color):
        self.price = price
        self.kind = kind
        self.color = color

    def call(self):
        print("正在呼叫XXXX;")

    def send_message(self):
        print("正在发送短信....")


class Student:
    def __init__(self,name,gender,phone):
        self.name = name
        self.gender = gender
        self.phone = phone

    def show_info(self):
        print("name:%s gender:%s" % (self.name,self.gender))

phone = Phone(1000,"apple","red")

stu1 = Student("rose","male",phone)
stu1.phone.call()

九 菱形继承

补充：多继承的时候，如果多个父类出现了同名的属性和函数，
需要用mro列表啦查看真正的继承关系，
总结：super在访问父类属性时，是按照mro列表一层层网上找

什么是菱形继承：

补充:新式类与经典类

python3中任何类都是直接或间接继承了Object

新式类,任何显式或隐式地继承自object的类就称之为新式类, python3中全都是新式类

经典类,既不是Object的子类 ,仅在python2中出现

 

当出现了菱形继承时,新式类,先深度,当遇到了共同父类时就广度

新式类,就是深度优先

案例：

class A:
    def test(self):
        print('from A')
        super().test()


class B:
    def test(self):
        print('from B')
    pass


class C(A,B):
    pass

c = C()
c.test()
print(C.mro())


class A:
    a = 1
    pass

class B(A):
    a = 2
    pass

class C(A):
    a =3
    pass

class D(A):
    a = 4
    pass

class E(B,C,D):
    a = 5
    pass

e = E()
print(e.a)
print( E.mro())