python 面向对象学习笔记之 继承，组合, 抽象类，接口

目录

类的继承
类的组合
抽象类
接口
归一化好处

类的继承

神魔是继承？

继承就是一种创建新类的方式，新建的类可以继承一个或者多个父类（python支持多继承）。
父类也被称为基类，超类。
新类被称为子类，派生类。
子类会“”遗传”父类的属性，从而解决代码重用的问题。
注意：
object类是所有python类的基类
下面是类继承的方式。

class ParentClass1: #定义父类
    pass


class ParentClass2: #定义父类
    pass


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


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


print(SubClass1.__bases__)
print(SubClass2.__bases__)

在子类中，新建和父类方法重名的方法，会把父类的方法给覆盖掉（对于子类的实例化对象）

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

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

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


b=Bar()
b.f2()

继承的两种用途：
1.继承基类的方法，并做出自己的改变或者扩展
2.声明某个子类兼容于某个基类，定义一个接口类，接口类定义一些接口名（就是函数名），但并未实现其功能。子类继承接口类，实现其中的功能。

类的组合

在一个类中以另一个类的实例化对象作为数据属性，叫做类的组合。

# 组合就是在一个类中以另一个类的对象作为数据属性
# 当类之间显著不同，并且较小的类是较大的类的所需组件，使用组和的方式


class School:
    def __init__(self, name, addr):
        self.name = name
        self.addr = addr

    def zhao_sheng(self):
        print("%s正在招生" % self.name)


class Couser:
    def __init__(self, name, price, period, school):
        self.name = name
        self.price = price
        self.period = period
        # self.school = s1 相当于 self.school = School('oldboy', '北京)
        self.school = school


s1 = School('oldboy', '北京')
s2 = School('oldboy', '南京')
c1 = Couser('python', 1000, '6day', s1)
print(c1.school)
print(s1)    # c1.school和s1 两者一样
print(c1.school.name)
c1.school.zhao_sheng()

抽象类

抽象类：一种特殊的类，它的特殊之处在于，只能被继承，不能被实例化。子类必须实现抽象方法，才能被实例化。

抽象类是介于接口和类的一个概念。
注意：只要有一个抽象方法即为抽象类。
ps:类是从一堆对象中抽取相同的内容而来的。抽象类则是从一堆类中抽取相同的内容（数据属性，函数属性）而来的。

# 创建抽象类 要导入abc模块
import abc


# 参数必须有
class All_file(metaclass=abc.ABCMeta):
    all_type = 'file'
    # 定义抽象方法，无需实现功能
    @abc.abstractmethod
    def read(self):
        pass


# 子类继承抽象类必须实现其抽象方法(重写其抽象方法)，不然不能被实例化。
class Sata(All_file):
    pass


class Satax(All_file):
    def read(self):
        print('读书破万卷。')


# 报错：TypeError: Can't instantiate abstract class Sata with abstract methods read
# s1 = Sata()

s2 = Satax()
s2.read()

抽象类可以实现归一化设计。

接口

python中并没有接口。
接口（接口的含义）：

1. 一组功能的集合。
2. 用于交互，功能都是公共的，即别的对象可操作。
3. 只定义函数。但不涉及函数的实现，
4. 功能是相关的。
   接口具有抽象类的特性（只定义函数，不涉及函数实现）

为何使用接口？

把接口当作一个函数的集合，提取了一群类的共同函数，然后让子类去实现（必须）接口的函数。

这样做的意义？

在于归一化。只要是基于同一接口实现的类，那么这些类产生的对象使用时，用法上都一样。

使用继承和抽象类实现接口。

### 使用抽象类和继承实现一个接口

import abc


# 一组功能的集合
class All_file(metaclass=abc.ABCMeta):
    all_type = 'file'

    @abc.abstractmethod
    def read(self):
        pass

    @abc.abstractmethod
    def write(self):
        pass


# 子类实现父类的方法
class Text(All_file):
    def read(self):
        print('文本数据的读取方法！')

    def write(self):
        print('文本数据的写入方法！')


class Sata(All_file):
    def read(self):
        print('硬盘的读取方法！')

    def write(self):
        print('硬盘的写入方法！')



t1 = Text()
s1 = Sata()


# 用法上都差不多。
t1.read()
s1.read()

t1.write()
s1.write()

归一化好处

归一化好处：

1. 使用者不用关心对象的类是啥？只要知道这些对象有啥功能即可。
2. 归一化使得高层外部使用者，可以不加区分的处理所有接口兼容的对象集合。