抽象基类的实现

抽象基类

1⃣️ 抽象基类一般作为后续协同开发的基础
2⃣️ 该类一般不做实例化，方法名可统一定义，继承之后根据需要对该方法重载（如：_advance）

1、以接口的方式实现抽象类

## 定义基类
class Progression:
    def __init__(self, start=0, num=10):
        self._current = start
        self._num = num

    def _advance(self):
        '''根据数列的通项，生成下一项'''
        self._current += 1

    def __next__(self):
        if self._num > 0:
            ans = self._current
            self._advance()
            self._num -= 1
            return ans
        else:
            raise StopIteration

    def __iter__(self):
        '''迭代器协议方法，返回数据自身'''
        return self

    def __str__(self):
        '''将输出转换为列表'''
        return str(list(self))

## 定义等差数列
class ArithmeticProgression(Progression):
    def __init__(self, start=0, num=10, increment=3):
        super().__init__( start=start, num=num)
        self._increment = increment
       
    def _advance(self):
        self._current += self._increment

## 定义等比数列
class GeometricProgress(Progression):
    def __init__(self, start=0, num=10, base=2):
        super().__init__(start=start, num=num)
        self._base = base

    def _advance(self):
        self._current *= self._base

## 定义斐波那契数列
class FibonacciProgress(Progression):
    def __init__(self, start=0, second=1, num=10):
        super().__init__(start=start, num=num)
        self._prev = second - start  # 生成第一项

    def _advance(self):
        self._prev, self._current = self._current, self._current + self._prev


## 测试
if __name__ == "__main__":
    print("默认基类：Progression：")
    print(Progression(num=5), end="\n" * 2)

    print("等差数列：")
    print(ArithmeticProgression(start=5, num=5, increment=3), end="\n" * 2)

    print("等比数列：")
    print(GeometricProgress(start=2, num=5, base=4), end="\n" * 2)

    print("斐波那契数列：")
    print(FibonacciProgress(start=2, num=5))
    
    
    
## 测试结果
默认基类：Progression：
[0, 1, 2, 3, 4]

等差数列：
[5, 8, 11, 14, 17]

等比数列：
[2, 8, 32, 128, 512]

2、通过加载abc模块实现抽象类

注释：继承了抽象类必须实现抽象基类中的全部方法,否则程序在执行过程中报错
错误示例如下：

from abc import ABC, abstractmethod


class Payment(ABC):
    @abstractmethod
    def payWay(self, money):
        pass

class ApplePayWay(Payment):
    def payWay(self, money):
        print("苹果支付了{}元".format(money))

class AliPayWay(Payment):
    def payWay(self, money):
        print("支付宝支付了{}元".format(money))

class WechatPayWay(Payment):
    def zhifu(self, money):
        print("微信支付了{}元".format(money))

we = WechatPayWay()  # 此处实例化时会报错，因为没有实现payWay这个方法
we.zhifu(300)

将上述Wechart中的zhifu方法改写为PayWay之后，便可正确运行。

class WechatPayWay(Payment):
    def payWay(self, money):
        print("微信支付了{}元".format(money))

we = WechatPayWay()  # 此处实例化时会报错，因为没有实现payWay这个方法
we.zhifu(300)        # 微信支付了300元

总结

1、抽象类的使用事实上是定义了一种规范，使得后续开发时都以此为基础
2、抽象类中的方法是一个接口，具体的功能由子类实现。协同开发时必不可少