继承

（一）什么是继承

继承是一种创建新类的方式，新建的类可以继承一个或多个父类（python支持多继承），父类又可称为基类或超类，新建的类称为派生类或子类。
子类会“”遗传”父类的属性，从而解决代码重用问题（去掉冗余的代码）
python中类的继承分为：单继承和多继承

（二）单继承和多继承

"""单继承和多继承"""
# 定义一个父类
class A():
    pass
# 再定义一个父类
class B():
    pass

# 单继承，基类是A
class C(A):
    pass

# 多继承，python支持多继承,用逗号分隔可以继承多个类
class D(A,B):
    pass

（三）查看继承

__base__查看从左到右继承的第一个父类
__bases__查看继承的所有的父类

"""查看继承"""
# 定义一个父类
class A():
    pass
# 再定义一个父类
class B():
    pass

# 单继承，基类是A
class C(A):
    pass

# 多继承，python支持多继承,用逗号分隔可以继承多个类
class D(A,B):
    pass
# __base__只查看从左到右继承的第一个子类
print(C.__base__)# <class '__main__.A'>
# __base__只查看从左到右继承的第一个子类
print(D.__base__)# <class '__main__.A'>
# __bases__查看所有继承的父类
print(D.__bases__)# (<class '__main__.A'>, <class '__main__.B'>)

（四）经典类和新式类

只有在python2中才分新式类和经典类，python3中统一都是新式类
在python2中，没有显式的继承object类的类，以及该类的子类，都是经典类
在python2中，显式地声明继承object的类，以及该类的子类，都是新式类
在python3中，无论是否继承object，都默认继承object，即python3中所有类均为新式类

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

"""经典类与新式类"""
# Python2区分经典类和新式类
# 在python2中，没有显式的继承object类的类，以及该类的子类，都是经典类
# 在python2中，显式地声明继承object的类，以及该类的子类，都是新式类

# Python3都是新式类
# 在python3中，无论是否继承object，都默认继承object，即python3中所有类均为新式类

class Student():
    def read(self):
        ...

class Student(object):
    def read(self):
        ...

（五）抽象和继承

继承描述的是子类与父类之间的关系，是一种什么是什么的关系。
要找出这种关系，必须先抽象再继承
抽象即抽取类似或者说比较像的部分

（1）抽象

抽象就是抽取类似或者比较像的部分

抽象分成两个层次
- 将奥巴马和梅西这俩对象比较像的部分抽取成类；
- 将人，猪，狗这三个类比较像的部分抽取成父类。
抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）

（2）继承

继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。
抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类

（六）继承与重用性

（1）单独成类

猫可以：喵喵叫、吃、喝、拉、撒
狗可以：汪汪叫、吃、喝、拉、撒
如果我们要分别为猫和狗创建一个类，那么就需要为猫和狗实现他们所有的功能

#猫和狗有大量相同的内容
class 猫：

    def 喵喵叫(self):
        print '喵喵叫'

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

class 狗：

    def 汪汪叫(self):
        print '喵喵叫'

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

（2）继承总类

上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。
如果使用继承的思想，如下实现：
- 动物：吃、喝、拉、撒
- 猫：喵喵叫（猫继承动物的功能）
- 狗：汪汪叫（狗继承动物的功能）

class 动物:

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 猫(动物)：

    def 喵喵叫(self):
        print '喵喵叫'
        
# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 狗(动物)：

    def 汪汪叫(self):
        print '喵喵叫'

（3）代码实现

继承的代码实现

class Animal():
    def eat(self):
        print(f"{self.name}吃饭！")
    def drink(self):
        print(f"{self.name}喝水！")
    def shit(self):
        print(f"{self.name}拉屎！")
    def pee(self):
        print(f"{self.name}撒尿！")
class Cat(Animal):
    def __init__(self,name):
        self.name=name
    def cry(self):
        print(f"{self.name}喵喵叫")
class Dog(Animal):
    def __init__(self,name):
        self.name=name
    def cry(self):
        print(f"{self.name}汪汪叫")
# 实例化类得到对象
cat=Cat(name='小花')
cat.cry()# 小花喵喵叫
cat.eat()# 小花吃饭！

dog=Dog(name='大黄')
dog.cry()# 大黄汪汪叫
dog.eat()# 大黄吃饭！

（4）代码重用

在开发程序的过程中，如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时
我们不可能从头开始写一个类B，这就用到了类的继承的概念。
通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用

继承的代码实现

class Animal():
    def __init__(self,name):
        self.name=name
    def eat(self):
        print(f"{self.name}吃饭！")
    def drink(self):
        print(f"{self.name}喝水！")
    def shit(self):
        print(f"{self.name}拉屎！")
    def pee(self):
        print(f"{self.name}撒尿！")
class Cat(Animal):
    def cry(self):
        print(f"{self.name}喵喵叫")
class Dog(Animal):
    def cry(self):
        print(f"{self.name}汪汪叫")
cat=Cat(name='小花')
cat.cry()
cat.eat()
# 小花喵喵叫
# 小花吃饭！
dog=Dog(name='大黄')
dog.cry()
dog.eat()
# 大黄汪汪叫
# 大黄吃饭！

（5）小结

提示：用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分设置大部分，大大生了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，也可以继承别人的，比如标准库，来定制新的数据类型，这样就是大大缩短了软件开发周期，对大型软件开发来说，意义重大。

注意：像cat.eat之类的属性引用，会先从实例中找eat然后去类中找，然后再去父类中找...直到最顶级的父类。

(七)属性查找顺序

（1）不隐藏属性

有了继承关系，对象在查找属性时
- 先从对象自己的__dict__中找
- 如果没有则去子类中找
- 然后再去父类中找……

class Foo:
    def f1(self):
        print('Foo.f1')

    # 【3】发现父类中找到了 f2 方法
    def f2(self):
        print('Foo.f2')
        # 【4】
        # 但是这里犯了难，这个 self 到底是 Foo 还是 Bar ？
        # 我们要时刻记得，源头是谁，这个self就是谁
        # 我们是从 对象 b 来的，而对象 b 又是 Bar 的对象
        # 我们从 Bar 找到了 Foo 类里面，所以我们的源头就是 Bar
        # 那这个 self 就是 Bar ， 而 Bar 类里面有 f1 方法
        # 所以我们就会回到 Bar 类里面
        self.f1()


class Bar(Foo):
    # 【2】来到 Bar 类里面寻找 f2 方法，但是发现自己没有
    # 于是向上查找，去父类 Foo 中查找
    def f1(self):
        # 【5】 找到了 Bar 中的方法
        print('Bar.f1')


# 实例化类得到对象
b = Bar()
# 【1】对象调用方法
b.f2()
# 【6】所以打印的顺序是 Foo 类中的 f2 ， Bar 类中的 f1
# Foo.f2
# Bar.f1

b.f2()会在父类Foo中找到f2
- 先打印Foo.f2
- 然后执行到self.f1(),即b.f1()
仍会按照：对象本身->类Bar->父类Foo的顺序依次找下去
- 在类Bar中找到f1
- 因而打印结果为Foo.f1

（2）隐藏属性

父类如果不想让子类覆盖自己的方法，可以采用双下划线开头的方式将方法设置为私有的

class Foo:
    # 变形为_Foo__fa
    def __f1(self):
        print('Foo.f1')

    def f2(self):
        print('Foo.f2')
        # 变形为self._Foo__fa,因而只会调用自己所在的类中的方法
        self.__f1()


class Bar(Foo):
    # 变形为_Bar__f1
    def __f1(self):
        print('Bar.f1')


b = Bar()
# 在父类中找到f2方法，进而调用b._Foo__f1()方法，同样是在父类中找到该方法
b.f2()
# Foo.f2
# Foo.f1

# 隐藏属性 ： 隐藏给当前类，除了当前类，其他继承的子类均不能找到我隐藏的属性

（八）继承实现的原理

(1)非菱形结构继承顺序

在Java和C#中子类只能继承一个父类，而Python中子类可以同时继承多个父类，如A(B,C,D)
如果继承关系为非菱形结构，则会按照先找B这一条分支，然后再找C这一条分支，最后找D这一条分支的顺序直到找到我们想要的属性

(2)菱形结构继承顺序

如果继承关系为菱形结构，那么属性的查找方式有两种，分别是：深度优先和广度优先

（1）深度优先

当类是经典类时，多继承情况下，在查找属性不存在时，会按照深度优先的方式查找下去

（2）广度优先

当类是新式类时，多继承情况下，在查找属性不存在时，会按照广度优先的方式查找下去

先找非公共的类，找完之后再去找公共的类

（3）广度优先代码

class A():
    def test(self):
        print("from A")
class B(A):
    def test(self):
        print("from B")
class C(B):
    def test(self):
        print("from C")
class D(C):
    def test(self):
        print("from D")
class E(C):
    def test(self):
        print("from E")
class F(D,E):
    def test(self):
        print("from F")
f=F()
f.test()# from F
# # 只有新式才有这个属性可以查看线性列表，经典类没有这个属性
print(F.mro())
# [<class '__main__.F'>,
# <class '__main__.D'>,
# <class '__main__.E'>,
# <class '__main__.C'>,
# <class '__main__.B'>,
# <class '__main__.A'>,
# <class 'object'>]


# 新式类：F D E C B A
# 经典类：F D C B A 
# python3中都是新式类
# python2中才分新式类与经典类

(3)继承原理（Python如何实现的继承）

python到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表

先找非公共的类，找完之后再去找公共的类

class A(object):
    def test(self):
        print('from A')


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


class C(A):
    def test(self):
        print('from C')


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


class E(C):
    def test(self):
        print('from E')


class F(D, E):
    # def test(self):
    #     print('from F')
    pass


f1 = F()
f1.test()

print(F.mro())
#先找非公共的类，找完之后再去找公共的类
# [<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
而这个MRO列表的构造是通过一个C3线性化算法来实现的。
我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
- 子类会先于父类被检查
- 多个父类会根据它们在列表中的顺序被检查
- 如果对下一个类存在两个合法的选择,选择第一个父类

派生

继承的延伸：派生

（一）什么是派生

派生是指子类继承父类，派生初自己的属性与方法，并且重用父类的属性与方法

（二）派生的方法

子类可以派生出自己新的属性，在进行属性查找时，子类中的属性名会优先于父类被查找
例如每个老师还有职称这一属性
我们就需要在Teacher类中定义该类自己的__init__覆盖父类的
当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。

"""派生"""
class Person():
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
class Teacher(Person):
    def teach(self):
        print(f"{self.name}在教课")

teacher1=Teacher(name='syh',age=23,sex="female")
teacher1.teach()# syh在教课

"""派生"""
class Person():
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
class Teacher(Person):
    # 派生出自己的属性,查找时，先查找的是字类的属性，之后才是父类
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def teach(self):
        print(f"{self.name}在教课")
teacher1=Teacher(name="su",age=23,sex="female")
teacher1.teach()# su在教课

很明显子类Teacher中__init__内的前三行又是在写重复代码
若想在子类派生出的方法内重用父类的功能，有两种实现方式

（1）指名道姓的调用某一个类的函数

class Person():
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
class Teacher(Person):
    # 派生出自己的属性,查找时，先查找的是字类的属性，之后才是父类
    def __init__(self,name,age,sex):
        #直接调用父类中的__init__方法
        # 调用的是函数，因而需要传入self
        Person.__init__(self,name,age,sex)
    def teach(self):
        print(f"{self.name}在教课")
teacher1=Teacher(name="su",age=23,sex="female")
teacher1.teach()# su在教课

（2）超类super

super会基于C.mro()继续往后找

调用super()会得到一个特殊的对象
该对象专门用来引用父类的属性
且严格按照MRO规定的顺序向后查找

class Person():
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
class Teacher(Person):
    # 派生出自己的属性,查找时，先查找的是字类的属性，之后才是父类
    def __init__(self,name,age,sex):
        #直接调用父类中的__init__方法
        # 调用的是绑定的方法，因此会自动传入self，但是仍需传入需要的参数
        super().__init__(name=name,age=age,sex=sex)
    def teach(self):
        print(f"{self.name}在教课")
teacher1=Teacher(name="su",age=23,sex="female")
teacher1.teach()# su在教课

提示：在Python2中super的使用需要完整地写成super(自己的类名,self) ,而在python3中可以简写为super()。
当你使用super()函数时,Python会在MRO列表上继续搜索下一个类。
只要每个重定义的方法统一使用super()并只调用它一次,那么控制流最终会遍历完整个MRO列表,每个方法也只会被调用一次
（注意注意注意：使用super调用的所有属性，都是从MRO列表当前的位置往后找，千万不要通过看代码去找继承关系，一定要看MRO列表）

（3）小结

这两种方式的区别是：
- 方式一是跟继承没有关系的，而方式二的super()是依赖于继承的
- 并且即使没有直接继承关系，super()仍然会按照MRO继续往后查找

# A没有继承B
class A:
    def test(self):
        super().test()


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


class C(A, B):
    pass


# 在代码层面A并不是B的子类
# 但从MRO列表来看，属性查找时，就是按照顺序C->A->B->object，B就相当于A的“父类”
print(C.mro())
# [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]

obj = C()

# 属性查找的发起者是类C的对象obj
# 所以中途发生的属性查找都是参照C.mro()
obj.test()
# from B

obj.test()首先找到A下的test方法
- 执行super().test()会基于MRO列表(以C.mro()为准)当前所处的位置继续往后查找()
- 然后在B中找到了test方法并执行。
关于在子类中重用父类功能的这两种方式
- 使用任何一种都可以
- 但是在最新的代码中还是推荐使用super()

#指名道姓
class A:
    def __init__(self):
        print('A的构造方法')
class B(A):
    def __init__(self):
        print('B的构造方法')
        A.__init__(self)


class C(A):
    def __init__(self):
        print('C的构造方法')
        A.__init__(self)


class D(B,C):
    def __init__(self):
        print('D的构造方法')
        B.__init__(self)
        C.__init__(self)

    pass
f1=D() #A.__init__被重复调用
'''
D的构造方法
B的构造方法
A的构造方法
C的构造方法
A的构造方法
'''
#使用super()
class A:
    def __init__(self):
        print('A的构造方法')
class B(A):
    def __init__(self):
        print('B的构造方法')
        super(B,self).__init__()


class C(A):
    def __init__(self):
        print('C的构造方法')
        super(C,self).__init__()


class D(B,C):
    def __init__(self):
        print('D的构造方法')
        super(D,self).__init__()

f1=D() #super()会基于mro列表,往后找
'''
D的构造方法
B的构造方法
C的构造方法
A的构造方法
'''

（4）小练习

# A没有继承B,但是A内super会基于C.mro()继续往后找
class A:
    def test(self):
        print('A---->test')
        super().aaa()


class B:
    def test(self):
        print('B---->test')

    def aaa(self):
        print('B---->aaa')


class C(A, B):
    def aaa(self):
        print('C----->aaa')


c = C()
c.test()  
# 打印结果:
'''
A---->test
B---->aaa
'''

# C作为方法调用（即c.test()）的发起者，方法调用过程中涉及的属性查找都参考C.mro()。
# 父子关系按照mro列表为准，千万不要从代码层面看父子。例如
print(C.mro())
# c.test()，发起者C.mro()列表如下
# 从列表中可以看出，B类就是A类他爹，而代码层面二者并无继承关系
# [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]

组合

（一）什么是组合

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

（二）组合的使用

组合与继承都是用来解决代码的重用性问题。
不同的是：
- 继承是一种“是”的关系，比如老师是人、学生是人，当类之间有很多相同的之处，应该使用继承；
- 而组合则是一种“有”的关系，比如老师有生日，老师有多门课程，当类之间有显著不同，并且较小的类是较大的类所需要的组件时，应该使用组合

class Person():
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
class Date():
    def __init__(self,year,month,day):
        self.year=year
        self.mouth=month
        self.day=day
    def birth(self):
        print(f"在{self.year}年{self.mouth}月{self.day}日生日")
class Teacher(Person):
    def __init__(self,name,age,sex,year,month,day):
        super().__init__(name,age,sex)
        self.birth=Date(year,month,day)
    def teach(self):
        print(f"{self.name}正在教课")

teacher1=Teacher(name='syh',age=23,sex="female",year=2000,month=9,day=15)
teacher1.teach()#syh正在教课
# 重用Date类功能
teacher1.birth.birth()class Course():
    def __init__(self,name,price):
        self.name=name
        self.price=price
    def info(self):
        print(f"课程{self.name},价格{self.price}")
class Person():
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
class Date():
    def __init__(self,year,month,day):
        self.year=year
        self.mouth=month
        self.day=day
    def birth(self):
        print(f"在{self.year}年{self.mouth}月{self.day}日生日")
class Teacher(Person):
    def __init__(self,name,age,sex,year,month,day):
        super().__init__(name,age,sex)
        self.birth=Date(year,month,day)
        self.course=[]
    def teach(self):
        print(f"{self.name}正在教课")

python=Course(name="python",price=20000)
python.info()#课程python,价格20000
teacher1=Teacher(name='syh',age=23,sex="female",year=2000,month=9,day=15)
teacher1.teach()#syh正在教课
# 重用Date类功能
teacher1.birth.birth()
#在2000年9月15日生日
#重用Course的功能
teacher1.course.append(python)
print(teacher1.course)#[<__main__.Course object at 0x0000011305B5BEB0>]
for obj in teacher1.course:
    print(f"{obj}")#<__main__.Course object at 0x00000167DCC2BEB0>
    obj.info()# 课程python,价格20000
#在2000年9月15日生日

此时对象teacher1集对象独有的属性、Teacher类中的内容、Course类中的内容于一身（都可以访问到），是一个高度整合的产物
当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好

（三）组合和继承的区别

组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同，

（1）继承的方式
通过继承建立了派生类与基类之间的关系，它是一种'是'的关系，比如白马是马，人是动物。
当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如老师是人，学生是人
（2）组合的方式
用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python和linux课程，教授有学生s1、s2、s3...

# 组合和继承的区别
# 组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同，

# 【1】继承主要是用来提取所有子类共有的功能的，总结成一个父类
# 通过继承建立了派生类与基类之间的关系，它是一种'是'的关系，比如白马是马，人是动物。
# 当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如老师是人，学生是人

# 【2】组合就相当于将不同的数据类型，包括八大基本数据类型，包括我们的对象，包括我们的类总结到一起，可以在一个类的对象里面调用其他类的对象和方法
# 用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系
# 比如教授有生日，教授教python和linux课程，教授有学生s1、s2、s3...

抽象类

（一）什么是接口

（1）IAnimal.java

Java 语言中的接口很好的展现了接口的含义: IAnimal.java
Java的Interface接口的特征
- 是一组功能的集合,而不是一个功能
- 接口的功能用于交互,所有的功能都是public,即别的对象可操作
- 接口只定义函数,但不涉及函数实现
- 这些功能是相关的,都是动物相关的功能,但光合作用就不适宜放到IAnimal里面了

package com.oo.demo;
public interface IAnimal {
    public void eat();
    public void run(); 
    public void sleep(); 
    public void speak();
}

（2）Pig.java

Pig.java：猪的类设计,实现了IAnnimal接口

package com.oo.demo;
public class Pig implements IAnimal{ //如下每个函数都需要详细实现
    public void eat(){
        System.out.println("Pig like to eat grass");
    }

    public void run(){
        System.out.println("Pig run: front legs, back legs");
    }

    public void sleep(){
        System.out.println("Pig sleep 16 hours every day");
    }

    public void speak(){
        System.out.println("Pig can not speak"); }
}

（3）Person2.java

实现了IAnimal的“人”,有几点说明一下
- 同样都实现了IAnimal的接口,但“人”和“猪”的实现不一样,为了避免太多代码导致影响阅读,这里的代码简化成一行,但输出的内容不一样,实际项目中同一接口的同一功能点,不同的类实现完全不一样
- 这里同样是“人”这个类,但和前面介绍类时给的类“Person”完全不一样,这是因为同样的逻辑概念,在不同的应用场景下,具备的属性和功能是完全不一样的

package com.oo.demo;
public class Person2 implements IAnimal { 
    public void eat(){
        System.out.println("Person like to eat meat");
    }

    public void run(){
        System.out.println("Person run: left leg, right leg");
    }

    public void sleep(){
        System.out.println("Person sleep 8 hours every dat"); 
    }

    public void speak(){
        System.out.println("Hellow world, I am a person");
    } 
}

（4）Tester03.java

package com.oo.demo;

public class Tester03 {
    public static void main(String[] args) {
        System.out.println("===This is a person==="); 
        IAnimal person = new Person2();
        person.eat();
        person.run();
        person.sleep();
        person.speak();
        
        System.out.println("\n===This is a pig===");
        IAnimal pig = new Pig();
        pig.eat();
        pig.run();
        pig.sleep();
        pig.speak();
    } 
}

（5）小结

PS:hi boy，给我开个查询接口。。。此时的接口指的是：自己提供给使用者来调用自己功能的方式\方法\入口

（二）为何要用接口

接口提取了一群类共同的函数，可以把接口当做一个函数的集合。
然后让子类去实现接口中的函数。
这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。
归一化的好处
- 归一化让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度
- 归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合
  - 就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。
  - 再比如：我们有一个汽车接口，里面定义了汽车所有的功能，然后由本田汽车的类，奥迪汽车的类，大众汽车的类，他们都实现了汽车接口，这样就好办了，大家只需要学会了怎么开汽车，那么无论是本田，还是奥迪，还是大众我们都会开了，开的时候根本无需关心我开的是哪一类车，操作手法（函数调用）都一样

（三）模仿interface

（1）继承的两种用途

继承基类的方法，并且做出自己的改变或者扩展（代码重用）：实践中，继承的这种用途意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。
声明某个子类兼容于某基类，定义一个接口类（模仿java的Interface），接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能

（2）代码演示

# 定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。
class Interface:
    # 定接口函数read
    def read(self):
        pass

    # 定义接口函数write
    def write(self):
        pass


# 文本，具体实现read和write
class Txt(Interface):
    def read(self):
        print('文本数据的读取方法')

    def write(self):
        print('文本数据的读取方法')


# 磁盘，具体实现read和write
class Sata(Interface):
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')


class Process(Interface):
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')

上面的代码只是看起来像接口，其实并没有起到接口的作用，子类完全可以不用去实现接口，这就用到了抽象类

（四）什么是抽象类

与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化

（五）为什么要有抽象类

如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。
比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。
从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。
从实现角度来看，抽象类与普通类的不同之处在于：抽象类中只能有抽象方法（没有实现功能），该类不能被实例化，只能被继承，且子类必须实现抽象方法。这一点与接口有点类似，但其实是不同的，即将揭晓答案

（六）在python中实现抽象类

定义父类后，要在父类名后的括号里加入（metaclass=abc.ABCMeta）
class Animal(metaclass=abc.ABCMeta):
定义抽象方法时，必须家上装饰@abc.abstractmethod

（1）导入模块

import abc

（2）不重写抽象类方法

补充些抽象类方法会报错

"""不重写抽象类的方法"""
class Animal(metaclass=abc.ABCMeta):

    #定义抽象方法，无需实现方法
    @abc.abstractmethod
    def eat(self):
        "@abc.abstractmethod:字类必须定义吃功能"
        pass
    @abc.abstractmethod
    def drink(self):
        "@abc.abstractmethod:字类必须定义喝功能"
        pass
class Person(Animal):
    pass
p1=Person()
"""
Traceback (most recent call last):
  File "D:\old boy\python\python28基础\day31\03抽象类.py", line 18, in <module>
    p1=Person()
TypeError: Can't instantiate abstract class Person with abstract methods drink, eat
"""

（3）重写抽象类方法

重写抽象类的方法不会报错

"""重写抽象类的方法"""
class Animal(metaclass=abc.ABCMeta):

    #定义抽象方法，无需实现方法
    @abc.abstractmethod
    def eat(self):
        "@abc.abstractmethod:字类必须定义吃功能"
        pass
    @abc.abstractmethod
    def drink(self):
        "@abc.abstractmethod:字类必须定义喝功能"
        pass
    def sleep(self):
        pass
    
#字类继续抽象类，必须定义eat喝drink方法 
class Person(Animal):

    def eat(self):
        pass
    def drink(self):
        pass
p1=Person()

总结：

# 总结 ： 抽象类的书写步骤
# 【1】创建一个父类
# 【2】必须导入 import abc
# 【3】父类必须继承一个属性 class Parent(metaclass=abc.ABCMeta):
# 【4】在想要子类中必须实现的方法上面加一个 装饰器 ： @abc.abstractmethod
# 【5】子类继承父类，子类必须重写父类中被添加 了 @abc.abstractmethod 的方法

（七）抽象类与接口

抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如all_type）和函数属性（如read、write），而接口只强调函数属性的相似性。
抽象类是一个介于类和接口直接的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计

526互联

继承

继承

（一）什么是继承

（二）单继承和多继承

（三）查看继承

（四）经典类和新式类

（五）抽象和继承

（1）抽象

（2）继承

（六）继承与重用性

（1）单独成类

（2）继承总类

（3）代码实现

（4）代码重用

（5）小结

(七)属性查找顺序

（1）不隐藏属性

（2）隐藏属性

（八）继承实现的原理

(1)非菱形结构继承顺序

(2)菱形结构继承顺序

（1）深度优先

（2）广度优先

先找非公共的类，找完之后再去找公共的类

（3）广度优先代码

(3)继承原理（Python如何实现的继承）

先找非公共的类，找完之后再去找公共的类

派生

继承的延伸：派生

（一）什么是派生

（二）派生的方法

（1）指名道姓的调用某一个类的函数

（2）超类super

（3）小结

（4）小练习

组合

（一）什么是组合

（二）组合的使用

（三）组合和继承的区别

抽象类

（一）什么是接口

（1）IAnimal.java

（2）Pig.java

（3）Person2.java

（4）Tester03.java

（5）小结

（二）为何要用接口

（三）模仿interface

（1）继承的两种用途

（2）代码演示

（四）什么是抽象类

（五）为什么要有抽象类

（六）在python中实现抽象类

（1）导入模块

（2）不重写抽象类方法

（3）重写抽象类方法

总结：

（七）抽象类与接口