day 21 归一化设计 + 接口类,抽象类 + 接口隔离原则 + 多态

# 归一化设计
# l = [1,2,2]
# l2 = {1,2,3,4}
# l3 = (1,2)
# a = '1234567'
# print(len(l))
# print(l3.__len__())
# len()  和 __len__()
# 只有一个类中实现了__len__()方法，才能使用len()函数
# def len2(obj):  # 归一化设计
#     return obj.__len__()

# print(len(l))
# print(len(l2))
# print(len(l3))

归一化设计：总结：

　　只有一个类中实现了某个双下划线方法，才可以使用某个方法。例如：__len__(),len()  understand  ?

# 只有一个类中实现了__len__()方法，才能使用len()函数
# def len2(obj):  # 归一化设计
#     return obj.__len__()

这种方法叫做归一化设计

二。接口类，抽象类。
　　Java的编程原则和设计模式：
　　　　设计模式 从Java中 演变出来的具有历史意义的 程序设计
　　　　# 单例模式
        # 一个类只有一个实例

 
## 算法导论  计算的方法 时间和空间的问题 权威通用

　java
    # 面向对象
    # java不能多继承
# 编程原则
    # python
    # 开放封闭原则
        # 开放 对扩展是开放的
        # 封闭 对修改是封闭的
    # 依赖倒置原则
    # 接口隔离原则
# 已经写完的程序代码是不允许修改的

# 支付功能的例子
    # 支付宝支付
    # qq支付
    # apply_pay
    # 微信支付

# 创建一个规范
# from abc import ABCMeta,abstractmethod
# class Payment(metaclass=ABCMeta):    # 抽象类 接口类  规范和约束  metaclass指定的是一个元类
#     @abstractmethod
#     def pay(self):pass  # 抽象方法
#
# class Alipay(Payment):
#     def pay(self,money):
#         print('使用支付宝支付了%s元'%money)
#
# class QQpay(Payment):
#     def pay(self,money):
#         print('使用qq支付了%s元'%money)
#
# class Wechatpay(Payment):
#     def pay(self,money):
#         print('使用微信支付了%s元'%money)
#     def recharge(self):pass
#
# def pay(a,money):
#     a.pay(money)
#
# a = Alipay()
# a.pay(100)
# pay(a,100)    # 归一化设计：不管是哪一个类的对象，都调用同一个函数去完成相似的功能
# q = QQpay()
# # q.pay(100)
# pay(q,100)
# w = Wechatpay()
# pay(w,100)   # 到用的时候才会报错



# 抽象类和接口类做的事情 ：建立规范
# 制定一个类的metaclass是ABCMeta，
# 那么这个类就变成了一个抽象类(接口类)
# 这个类的主要功能就是建立一个规范

# 抽象类中所有被abstractmethod装饰的方法都必须被继承的子类实现
# 如果不实现，那么在实例化阶段将会报错

# 无论是抽象类还是接口类metaclass=ABCMeta 都不可以被实例化
# p = Payment()  # 报错

依赖倒置原则：
高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该应该依赖细节；细节应该依赖抽象。换言之，要针对接口编程，而不是针对实现编程

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


接口类的作用:
　　1.在Java中可以满足接口隔离原则，且可以完成多继承的约束
　　2.在python中满足接口隔离原则，由于python本身存在多继承，所以不存在接口，所以也不存在接口隔离原则.

抽象类和接口类：
　　1.在python中并没有什么不同，都是用来约束子类的方法的
　　2.只要是抽象类和接口类中被abstractmethod装饰的方法，都需要被子类实现
　　3.当多个类中有相同的功能也有不同的功能的时候，要用多个接口来约束字类

在Java中：
　　1.抽象类和接口截然不同
　　2.抽象类的本质还是一个类，是类就必须遵循单继承原则，所以一个子类被抽象类约束，就只能被一个类控制
　　3.当多各类有相同的功能也有不同的功能的时候，Java需要创建多个接口来解决

面试的时候：
　　#抽象类是python中定义类的一种规范

　　　　#接口：

　　　　　　在公司写代码的时候：如果遇到抽象类，记得按照抽象类中的规范一一实现对应的方法

接口，抽象类 ：建立规范

 多态
# java c++ c# —— 强类型语言
# 相同数据类型之间做运算
# def func(int a):pass
# func('a')

# shell语言 —— 弱类型语言
# 1+'1'
# def func(a):pass
# 1 'a' [1,2,3] ()

# 介于 强类型 与 弱类型之间 —— python 动态强类型语言
# 相同数据类型之间做运算
# def func(a):pass
class Payment:
    def pay(self):pass

class QQpay(Payment):
    def pay(self,money):
        print('使用qq支付了%s元'%money)

class Wechatpay(Payment):
    def pay(self,money):
        print('使用微信支付了%s元'%money)
    def recharge(self):pass

# def pay(Payment pay_obj,int money):   #  java 多态 在一个类之下发展出来的多个类的对象都可以作为参数传入这里
#     pay_obj.pay(money)

# 无论是python的2.*还是3.* ： 天生自带多态效果

# qq_obj = QQpay()
# print(type(qq_obj))  # 一个对象的数据类型就是它所在的类
# # # qq_obj.pay(100)
# pay(qq_obj,100)
# we_obj = Wechatpay()
# # # we_obj.pay(200)
# pay(we_obj,200)
# def len(object obj):pass
# class len_class:pass
# class tuple(len_pass):pass
# class list(len_pass):pass
# class str(len_pass):pass
# tuple list str dict set

# 鸭子类型
# class QQpay():
#     def pay(self,money):
#         print('使用qq支付了%s元'%money)
#
# class Wechatpay():
#     def pay(self,money):
#         print('使用微信支付了%s元'%money)
#
# def pay(pay_obj,money):
#     pay_obj.pay(money)

# 索引
class list:
    def index(self):pass
class str:
    def index(self):pass
class tuple:
    def index(self):pass
# [].index()
# ''.index()
# ().index()


# 多态和鸭子类型
# 多态 通过继承实现
    # java 在一个类之下发展出来的多个类的对象都可以作为参数传入一个函数或者方法
    # 在python中不需要刻意实现多态，因为python本身自带多态效果
# 鸭子类型
    # 不是通过具体的继承关系来约束某些类中必须有哪些方法名
    # 是通过一种约定俗成的概念来保证在多个类中相似的功能叫相同的名字


# 复习课上的例子 重点记概念
# 面向对象的思维导图