1，接口类和抽象类知识背景：一开始在程序界是没有这些概念的，后来就流行了一种语言叫做JAVA，JAVA是一种典型的纯面向对象的语言，JAVA写的程序都是非常适用于更庞大的项目，很多程序员就总结出了一些设计程序的方式，比如说，这一个程序要实现的是哪一类的问题，给这些问题归类，实现A问题用一种思路，实现B问题用另外一种思路，于是就出现了设计模式，所以设计模式一开始最早的时候是源自于JAVA，后来过了一段时间，这个设计模式在整个程序界火了起来，他很经典，总结了很多经典的问题，后来出了一本书，小黑皮的，最早的时候，也没有接口的概念，这个接口的概念，来源于设计模式里，在Python里，其实Python是一门很特殊的语言，后面多态的时候会具体讲特殊在哪儿，因为Python很简单，有他的简便性和便捷性，所以大家对于Python要不要设计模式持两种态度，一种认为，设计模式是一种经典的设计思想，另一种认为，既然源自于JAVA，那么他可能更适合于JAVA，不那么适合于Python，所以贬的人贬，推崇的人就很推崇。
2，抽象类和接口类很多人是分不清楚的，Python原生是不支持接口类的，根本没有这个概念，但是由于设计模式里面有，所以我们就介绍这个概念。Python原生支持抽象类。他俩在Python里本身很接近，其他语言还是有区别的
3，支付功能
class Wechat: def pay(self,money): print('已经用微信支付了%s元'%money) class Alipay: def pay(self,money): print('已经用支付宝支付了%s元'%money) weChat = Wechat() weChat.pay(100) ali = Alipay() ali.pay(200) # 统一支付入口，类似于len函数对比 def pay(pay_obj,money): pay_obj.pay(money) pay(weChat,100) pay(ali,200)
4，添加一个Applepay
# 这样添加的支付方式没有办法统一了 class Applepay: def fuqian(self,money): print('已经用Applepay支付了%s'%money)
5，这个地方调用的时候会报错
class Payment: def pay(self,money): raise NotImplemented 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('已经用Applepay支付了%s'%money) weChat = Wechat() weChat.pay(100) ali = Alipay() ali.pay(200) apple = Applepay() apple.pay(300) # TypeError: exceptions must derive from BaseException
6，如何不调用就可以知道这个错误呢?
from abc import abstractmethod,ABCMeta class Payment(metaclass=ABCMeta): # 元类，所有类都有个机制，默认是type，这个机制，支持创造一个类， # 加上这句话，表示我即将要写一个类的规范了。 # 这一句要求我要实现一个接口类了。 @abstractmethod def pay(self,money):pass # 规范，既可以说是抽象类，也可以说是接口类，本身就是一种规范。 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('已经用Applepay支付了%s'%money) apple = Applepay()
7，接口类，默认多继承，接口类中的所有的方法都必须不能实现，这个规定是来自于JAVA的，但是如果说在Python里面硬要实现，也是可以的，只不过一般情况下我们不建议写
8，抽象类，不支持多继承，尽量只用单继承，抽象类中可以实现一些方法，里面可以有一些代码的实现。两者共同点，就是要规范子类，Python里面区别不大。一个单继承，一个多继承
9，类是从一堆对象中抽取相同的内容，抽象类是从一堆类中抽取相同的内容，包括数据属性和函数属性。抽象类中有抽象方法，该类不能被实例化，只能被继承，且子类必须实现抽象方法。
10，接口类的多继承和接口隔离原则，想象之前的开放封闭原则，这个例子更类似于接口类，面向对象的方法。
from abc import abstractmethod,ABCMeta 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 Eagle(Fly_Animal,Walk_Animal):pass class Swan(Swim_Animal,Walk_Animal,Fly_Animal):pass # 接口类， # 接口隔离原则，编程时的一个原则，使用多个专门的接口，而不是单一的总接口，即客户端不应该依赖于哪些不需要的接口
11，接口的思想就是，我要实现不同的功能，我就去继承不同的接口来规范我当前的类里面需要有哪些函数。接口类其实没有的话，也能实现功能，只不过不规范。
12，抽象类的单继承
13，
# Python里面一切都是对象，操作系统里面一切都是文件 import abc 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() #报错，子类没有定义抽象方法 # TypeError: Can't instantiate abstract class Txt with abstract methods read, write class Txt(All_file): # 子类继承抽象类，但是必须定义read和write方法 def read(self):print('txt read') def write(self):print('txt write') class Sata(All_file): def read(self):print('sata read') def write(self):print('sata write') class Process(All_file): def read(self):print('process read') def write(self):print('process write') wenjianjia = Txt() yingpan = Sata() jincheng = Process() # 这样大家都被归一化了，也就是一切皆文件的思想 wenjianjia.read() yingpan.write() jincheng.read() # 一般情况下 单继承 能实现的功能都是一样的，所以在父类中可以有一些简单的基础实现 # 多继承的情况，由于功能比较复杂，所以不容易抽象出相同的功能的具体实现写在父类中 # 接口类还是抽象类，面向对象的开发规范 # Python中没有接口类，Java里有接口interface这个概念 # Python自带多继承，所以我们直接用class来实现接口类
# Python中支持抽象类：一般情况下 单继承 不能实例化 且可以实现python代码
14，JAVA里的所有类的继承都是单继承，所以抽象类玩么的解决了单继承需求中的规范问题，但是对于多继承的需求，由于JAVA本身语法的不支持，所以创建了接口Interface这个概念来解决多继承的问题。
15，Python天生支持多态，多态，一类事务的多种形态（广义的多态）向不同的对象发送同一个消息，会有不同的响应。相同的方法，不同对象做的事不同，就叫做多态，JAVA里面想要实现多态，必须有一个共同的父类，才可实现不同的对象调用同样的方法，传的对象类型，Python里面是不需要的，所以这个共同的父类是不需要的，天生支持多态。
16，Python是一门动态强类型的语言，不能直接说强类型，也不能说是弱类型的，弱类型支持 2+‘str'
17，Python里面不崇尚多态，不需要借助父类来实现多态。Python崇尚鸭子类型，鸭子类型，补充上根据继承得来的相似，我只是自己实现我自己的代码就可以了，如果两个类刚好相似，并不产生父类的子类的兄弟关系，而是鸭子类型。这种相似是自己写代码约束的，而不是通过父类约束的，优点：松耦合，每个相似的类之间都没有影响，缺点：太随意了，没有硬性的规范，去必须实现这个功能。只能靠自觉。
18，强类型语言，只能用多态，Python不用实现共同的父类，崇尚鸭子类型。
19，封装
# 广义上面向对象的封装：代码的保护，面向对象思想的本身就是一种 # 只让自己的对象能调用自己类中的方法 # 狭义上的封装 ---面向对象的三大特征之一 # 属性和方法都隐藏起来 不让你看见 class Person: def __init__(self,name,passwd,id): self.name = name self.passwd = passwd self.__id = id alex = Person('alex','alex3714',12) print(alex.passwd) # alex3714 print(alex.__id) # AttributeError: 'Person' object has no attribute '__id'
20，前面加上双下划线，就变成私有属性了，
class Person: def __init__(self,name,passwd,id): self.name = name self.passwd = passwd self.__id = id def get_id(self): return self.__id alex = Person('alex','alex3714',12) print(alex.passwd) # alex3714 # print(alex.__id) # AttributeError: 'Person' object has no attribute '__id' print(alex.__dict__) # {'name': 'alex', 'passwd': 'alex3714', '_Person__id': 12} print(Person.__dict__) print(alex._Person__id) # 12 _类名_属性名，实际中不可以这样用，这是一种投机倒把的方式
21，
alex.__id = 10 # 这样写只是给对象新添加了一个属性 print(alex.passwd) print(alex.__dict__) # {'name': 'alex', 'passwd': 'alex3714', '_Person__id': 12, '__id': 10} print(Person.__dict__)
22，总结：所有的私有 都是在变量的左边加上双下划线：对象的私有属性，类中的私有方法，类中的静态私有属性。所有的私有的都不能在类的外部使用。
23，其他语言中有public,protected,private,Python中没有protected，只有public和private，python 里的私有都是假的，只不过是包了一层而已。只要在类的内部使用私有属性，就会自动的带上类名
24，
class Person:
__key = 123 # 类的私有属性 def __init__(self,name,passwd,id): self.name = name self.passwd = passwd self.__id = id # 私有属性 def __get_id(self): # 私有方法 return self.__id def login(self): # 只可以在类的内部使用私有变量 self.__get_id()