day25_python

参考Eva_J的博客，原文连接：https://www.cnblogs.com/Eva-J/p/7277026.html

前戏

'''
继承表达什么是什么的关系
先抽线再继承，几个类之间的相同代码抽象出来，成为父类
子类自己没有的名字，就可以使用父类的方法和属性
如果子类自己有，一定是先用自己的
在类中使用self的时候，一定要看清楚self指向谁
多继承
新式类和经典类体现，新式类广度优先，经典类深度优先
新式类，类名.mro方法，查看广度优先的继承顺序
python3中super方法，根据广度优先的继承顺序查找上一个类

选课系统作业完成
接口类和抽象类，接口类来源于设计模式
python原生支持抽象类
'''

抽象类举例

import abc  # 利用abc模块实现抽象类
from abc import ABCMeta, abstractmethod


class Payment(metaclass=ABCMeta):   # 元类，默认元类是type, 建立规范，实现一个接口类
    @abstractmethod
    def pay(self, money):
        pass
        # raise NotImplementedError  # 没有实现这个方法


# 接口类，默认多继承，接口类中所有的方法都必须不能实现--java
# 抽象类 不支持多继承，抽象类中方法可以有一些代码的实现


class Wechat(Payment):
    def pay(self, money):
        print('微信支付了%s' % money)


class Alipay(Payment):
    def pay(self, money):
        print('支付宝支付了%s' % money)


class Applepay(Payment):
    def fuqian(self, money):  # 会报错
        print('Apple支付了%s' % money)


def pay(obj, money):
    obj.pay(money)


wechat = Wechat()
ali = Alipay()
app = Applepay()
pay(wechat, 100)
pay(ali, 200)
pay(app, 300)

接口类的多继承

# 接口类的多继承
# tiger 走路，游泳
# swan 走路 游泳 飞
# ring 走路 飞


class Swim_Animal(metaclass=ABCMeta):
    @abstractmethod
    def swim(self):
        pass


class Walk_Animal(metaclass=ABCMeta):
    @abstractmethod  # 写好的装饰器，语法糖
    def walk(self):
        pass


class Fly_Animal(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):
        pass


class Tiger(Walk_Animal, Swim_Animal):
    pass


class Ring(Walk_Animal, Fly_Animal):
    pass


class Swan(Walk_Animal, Swim_Animal, Fly_Animal):
    pass

接口隔离原则

使用多个专门的接口，而不使用单一的总接口，即客户端不应该依赖那些不需要的接口

开放封闭原则

软件实体应该是可扩展，而不可修改的。也就是说，对扩展是开放的，而对修改是封闭的。
对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。
对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对类进行任何修改。

例子

class All_file(metaclass=abc.ABCMeta):
    all_type = 'file'

    @abc.abstractmethod  # 定义抽象方法，无需实现功能
    def read(self):
        '子类必须定义读功能'
        pass

    @abc.abstractmethod  # 定义抽象方法，无需实现功能
    def write(self):
        '子类必须定义写功能'
        pass

# class Txt(All_file):
#     pass
#
# t1=Txt() #报错,子类没有定义抽象方法


class Txt(All_file):  # 子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('文本数据的读取方法')

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


class Sata(All_file):  # 子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('硬盘数据的读取方法')

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


class Process(All_file):  # 子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('进程数据的读取方法')

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


wenbenwenjian = Txt()

yingpanwenjian = Sata()

jinchengwenjian = Process()

# 这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()

print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

杂谈

'''
抽象类 规范
一般情况下 单继承 能实现的功能都是一样的
多继承的情况由于功能比较复杂，不容易抽象出相同的功能的具体实现
python中没有接口类，java不支持多继承，有interface，帮助实现多继承
python自带多继承，直接用class实现接口类
接口类和抽象类不能实例化
多态 多种形态 python天生支持多态，其他语言使用父类实现多态
鸭子类型
list tuple 不崇尚根据继承所得来的相似，只是实现自己的代码
如果两个类刚好相似，并不产生父类的子类的兄弟关系，而是鸭子类型
优点 松耦合
缺点 随意，只能靠自觉
'''

封装

广义

广义上面向对象的封装：代码的保护，面向对象的思想本身就是一种封装,只让自己的对象能调用自己类中的方法

狭义

把属性和方法隐藏起来

例子

class Person:
    def __init__(self, name, passwd):
        self.name = name
        self.__passwd = passwd  # 私有属性

    def __get_pwd(self):  # 私有方法
        return self.__passwd

    def login(self):      # 正常的方法调用私有方法
        self.__get_pwd()


alex = Person('alex', 'alex3714')
print(alex.__passwd)
print(alex._Person__passwd)  # _类名__属性名可以调到,只要在类的内部使用私有属性，就会自动带上_类名
print(alex.get_pwd())
alex.__high = 1  # 外部私有不行
# 所有的私有属性，私有函数不能在类的外部使用，类中的静态属性也可以定义为私有的