day25 多态和封装

Posted 2020-11-21 wujunjie-sir

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

# java：面向对象
# 设计模式——接口
# 接口类：python原生不支持
# 抽象类：python原生支持
# from abc import abstractclassmethod, ABCMeta
#
#
# class Payment(metaclass=ABCMeta): #元素 默认的元类 type
#     @abstractclassmethod
#     def pay(self, money): #没有实现这个方法
#         pass
#
#
# class Wechat(Payment):
#     @abstractclassmethod
#     def pay(self, money):
#         print(‘已用微信支付%s元‘ % money)
# #规范：接口或者抽象都可以
# #接口类 支持多继承，接口类中所有的方法必须不能实现
# # 抽象类 不支持多继承，可以实现一些代码
#
#
# class Alipay(Payment):
#     @abstractclassmethod
#     def pay(self, money):
#         print(‘已用支付宝支付%s元‘ % money)
#
#
# class Applypay(Payment):
#     @abstractclassmethod
#     def pay(self, money):
#         print(‘已用applypay支付%s元‘ % money)
#
#
# def pay(pay_obj, money):#统一支付入口
#     pay_obj.pay(money)
#
#
# wechat = Wechat()
# app = Applypay
# wechat.pay(200)
# p = Payment()

from abc import abstractclassmethod, ABCMeta


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


class Walk_Animal(metaclass=ABCMeta):
    @abstractclassmethod
    def walk(self): pass


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


class Tiger(Walk_Animal, Swim_Animal):
    def walk(self): pass

    def swim(self): pass


class Oldying(Fly_Animal, Walk_Animal):
    pass


class Swan(Fly_Animal, Walk_Animal, Walk_Animal):
    pass


# 接口类 刚好满足隔离原则 面对对象开发的思想、规范

import abc  # 利用abc模块实现抽象类


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

    @abstractclassmethod
    def read(self):
        ‘子类必须定义功能‘
        with open(‘filename‘) as f:
            pass

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


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("进程数据的读取方法")


a = Txt()
b = Sata()
c = Process()
# 这样大家就归一化了，也就是一切皆文件的思想
a.write()
b.write()
c.write()
print(a.all_type)
print(b.all_type)
print(c.all_type)


# 抽象类 ： 规范
# 一般情况下 单继承 能实现的功能都是一样的，所以在父类中可以有一些简单的基础实现
# 多继承的情况 由于功能比较复杂，所以不容易抽象出相同的功能的具体实现写在父类中


# 抽象类还是接口类 ： 面向对象的开发规范 所有的接口类和抽象类都不能实例化
# java ：
# java里的所有类的继承都是单继承,所以抽象类完美的解决了单继承需求中的规范问题
# 但对于多继承的需求，由于java本身语法的不支持，所以创建了接口Interface这个概念来解决多继承的规范问题

# python
# python中没有接口类  ：
#  python中自带多继承 所以我们直接用class来实现了接口类
# python中支持抽象类  ： 一般情况下 单继承  不能实例化
#  且可以实现python代码

# 多态 python 天生支持多态
# def func(int num,str name):
#     pass
#
# func(‘alex‘,2)
# class Payment:pass

# class Alipay():
#     def pay(self,money):
#         print(‘已经用支付宝支付了%s元‘ % money)
#
# class Applepay():
#     def pay(self,money):
#         print(‘已经用applepay支付了%s元‘ % money)
#
# def pay(pay_obj,money):  # 统一支付入口  归一化设计
#     pay_obj.pay(money)
#
# pay()

# 什么是多态
# python 动态强类型的语言
# 鸭子类型
# list tuple
# 不崇尚根据继承所得来的相似
# 我只是自己实现我自己的代码就可以了。
# 如果两个类刚好相似，并不产生父类的子类的兄弟关系，而是鸭子类型
# list tuple 这种相似，是自己写代码的时候约束的，而不是通过父类约束的
# 优点 ： 松耦合 每个相似的类之间都没有影响
# 缺点 ： 太随意了,只能靠自觉

# class List():
#     def __len__(self):pass
# class Tuple():
#     def __len__(self):pass
#
# def len(obj):
#     return obj.__len__()
#
# l = Tuple()
# len(l)
#
# # 强类型语言     多态
# # python 语言    鸭子类型


# 接口类和抽象类 在python当中的应用点并不是非常必要

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

# 狭义上的封装 —— 面向对象的三大特性之一
# 属性 和 方法都藏起来 不让你看见
# class Person:
#     __key = 123  # 私有静态属性
#
#     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._Person__passwd)  # _类名__属性名
# print(alex.get_pwd())

# 所有的私有 都是在变量的左边加上双下划綫
# 对象的私有属性
# 类中的私有方法
# 类中的静态私有属性
# 所有的私有的 都不能在类的外部使用

# 昨天的复习和博客
# 今天的作业、复习
# 预习封装的内容