一.上节内容回顾。
继承：
新式类：继承object类的类就是新式类。（python3x中都是新式类。）
经典类;不继承object类就是经典类。
python2x:默认所有类都不继承object，所以默认所有类都是经典类。
可以手动加上（object),这样就是新式类。
单继承，多继承。
单继承：
1.查询顺序
class A:
name = 'alex'
def func(self):
print(666)
class B(A):
age = 12
b1 = B()
b1.age
b1.name
2.只执行子类的方法
class A：
name = 'alex'
def func(self):
print('IN A')
class B(A):
age = 12
def func(self):
print('IN B')
b1 = B()
b1.func()
3.既要执行父类的又执行子类的方法
class A:
name = 'alex'
def func(self):
print('IN A')
class B(A):
age = 12
def func(self):
super().func() #第一种 super(B,self).func()
A.func(self) #第二种
print('IN B')
b1 = B()
b1.func()
4.多继承：
新式类：广度优先。python3x:类名。mro()
经典类。一直找，找到底。
二.今日内容：
接口类，抽象类。
只是你在工作中，书写的一种规范。
# 第一版,不好,没有统一化设计,第二版解决.
# class QQ:
# def pay(self,money):
# print('您用qq支付了%s元' % money)
#
# class Ali:
# def pay(self,money):
# print('您用支付宝支付了%s元' % money)
#
# q1 = QQ()
# q1.pay(100)
# a1 = Ali()
# a1.pay(200)
# 第二版 ,相安无事,此时来了一个野生程序员.完成了一个微信功能
class QQ:
def pay(self,money):
print('您用qq支付了%s元' % money)
class Ali:
def pay(self,money):
print('您用支付宝支付了%s元' % money)
class Wechat:
def wechatpay(self,money):
print('您用微信支付了%s元' % money)
def pay(obj,money):
obj.pay(money) # q1.pay(100)
# q1 = QQ()
# a1 = Ali()
# pay(q1,100) # 统一化设计
# pay(a1,200)
# w1 = Wechat()
# w1.wechatpay(500)
# 第三版,重新改版微信支付功能
# class QQ:
# def pay(self,money):
# print('您用qq支付了%s元' % money)
#
# class Ali:
# def pay(self,money):
# print('您用支付宝支付了%s元' % money)
#
# class Wechat:
# def pay(self,money):
# print('您用微信支付了%s元' % money)
#
# def pay(obj,money):
# obj.pay(money) # q1.pay(100)
#
# q1 = QQ()
# a1 = Ali()
# pay(q1,100) # 统一化设计
# pay(a1,200)
# w1 = Wechat()
# pay(w1,500)
# 第四版,为了避免上述野生程序员可能发生的问题,我要制定一个规范.
class Payment: # 抽象类,或者接口类:制定一个规范.
def pay(self):pass
class QQ(Payment):
def pay(self,money):
print('您用qq支付了%s元' % money)
class Ali(Payment):
def pay(self,money):
print('您用支付宝支付了%s元' % money)
class Wechat(Payment):
def pay(self,money):
print('您用微信支付了%s元' % money)
def pay(obj,money):
obj.pay(money) # a1.pay(200)
# q1 = QQ()
# a1 = Ali()
# pay(q1,100) # 统一化设计
# pay(a1,200)
# w1 = Wechat()
# pay(w1,500)
# 第五版 强制制定规范,如果未按照规范执行,就会报错.
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta): # 抽象类 接口类 规范和约束 metaclass指定的是一个元类
@abstractmethod
def pay(self):pass # 抽象方法
class QQ(Payment):
def pay(self,money):
print('您用qq支付了%s元' % money)
def ret(self):
print('支付失败....')
class Ali(Payment):
def pay(self,money):
print('您用支付宝支付了%s元' % money)
class Wechat(Payment):
def pay(self,money):
print('您用微信支付了%s元' % money)
def pay(obj,money):
obj.pay(money) # a1.pay(200)
q1 = QQ()
a1 = Ali()
w1 = Wechat()
# q1 = QQ()
# a1 = Ali()
# pay(q1,100) # 统一化设计
# pay(a1,200)
# w1 = Wechat()
# pay(w1,500)
# 用处: 在工作中,如果你要是规定几个类必须有一样的方法,
# 你要抽象类,制定一个规范,强制其有此方法.
# python没有多态的概念,但是python崇尚鸭子类型.
# 定义变量的方法:
#1,java c# 需要定义 类型. int i= 3
#2,java c# 没有多继承的概念.
# i = 1
# i = 'alex'
python三大特性：
python多态（鸭子类型）。
# 鸭子类型: 它看着像鸭子,那么他就是鸭子.
# str list tuple
str.index()
s1 = 'alex'
class Str:
def index(self):
pass
class List:
def index(self):
pass
class tuple:
def index(self):
pass
#python中好多不同类但同名的方法不是强制规定,而是约定俗成,像上面这三种类,都同样据有index方法,而且功能相似,
# 则 他们三个互称为鸭子.
python封装。
封装就是将一些属性或者方法（有用的信息）放置在一个空间中。
1.封装 对象的封装。
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
p1 = Person('oldboy',1000)
p2 = Person('alex',10000)
print(p1.name)
print(p2.name)
2.封装（私有成员。）
类的结构分析：
class Person:
mind = '有思想...' #第一部分：所有的共有静态变量，共有静态字段
__level = '高等动物' #第一部分：私有静态变量，私有静态字段
def __init__(self,name,age,sex): # 构造方法 # 第二部分 动态方法，方法（函数）
self.name = name = name # 公有对象属性
self.age = age
self.__sex = sex # 私有对象属性
def func(self): # 第二部分：普通方法
print（666）
def func1(self): # 第二部分：私有方法
print(777)
@staticmethod # 静态方法
def f2():pass
@classmethod # 类方法
def f2(self):pass
@property # 属性
def hex(self):pass
类整体分类：
第一部分：共有静态 mind = '有思想...',私有静态字段。__level = '高等动物'
第二部分：特殊方法（__init__(共有属性，私有属性），__str__...）
普通方法 def func(self):
私有方法 def __func1(self):
类方法：
@classmethod
def f2(self): pass
静态方法：
@staticmethod # 静态方法
def f2():pass
属性：
@property # 属性
def hex(self): pass
# 私有成员: 私有静态字段,私有属性,私有方法 在变量前+ __双下划线.
# 私有静态字段
# class Animal:
# __cloth = '皮毛' # _Animal__cloth
# class Person(Animal):
# mind = '有思想...' # 第一部分:所有的公有静态变量,公有静态字段
# __level = '高等动物' # 第一部分:私有静态变量,私有静态字段 # _Person__level
#
# def __init__(self,name,age): # 构造方法 # 第二部分 动态方法,方法(函数)
# self.name = name # 公有对象属性
# self.age = age
# def func(self):
# print(self.__level)
# print(self._Animal__cloth)
# print(self.__cloth)
# 在类的外面访问: 私有静态字段是访问不到的.
# p1 = Person('alex',1000)
# print(p1.mind)
# print(p1.__level)
# print(Person.__level)
# print(Person.__dict__)
# print(Person._Person__level)
# 可以通过对象._类名__变量名 类名._类名__变量名 可以访问到,但是绝对不要这么访问.
# 在类的内部: 私有静态字段是可以访问
# p1 = Person('alex',1000)
# p1.func()
# 父类的私有静态字段,派生类可否访问? 不可访问.
# p1 = Person('alex',10)
# print(p1.__cloth)
# p1.func()
# 私有方法
# class Animal:
# def __f1(self):print(1111) # _Animal__f1
#
# class Person(Animal):
# mind = '有思想...' # 第一部分:所有的公有静态变量,公有静态字段
# def __init__(self,name,age): # 构造方法 # 第二部分 动态方法,方法(函数)
# self.name = name # 公有对象属性
# self.age = age
# self.__sex = sex
# def __func(self): # _Person__func()
# print(666)
# def func1(self):
# self.__func() # self._Person__func()
# def func2(self):
# self.__f1() # self._Person__f1()
# 类外面访问不到.
# p1 = Person('OLDBOY',1000)
# p1.__func() #
# 类内部可以方法.
# p1 = Person('OLDBOY',1000)
# p1.func1()
# 派生类中也是不能访问的.
# p1.func2()
# 私有属性 也是类外部不能访问,派生类不能访问,只能在类内部访问.
class Animal:
def __f1(self):print(1111) # _Animal__f1
class Person(Animal):
mind = '有思想...' # 第一部分:所有的公有静态变量,公有静态字段
def __init__(self,name,age,sex): # 构造方法 # 第二部分 动态方法,方法(函数)
self.name = name # 公有对象属性
self.age = age
self.__sex = sex
def __func(self): # _Person__func()
print(666)
# 总结: 对于私有成员来说,他加载到内存时,都会加上_类名__变量名,所以你在类的外部,或者派生类中都不可访问.
#为什么设置私有成员?
# 有些变量,方法,属性,只在类内部进行使用即可,不便于(不允许)类外部或者派生类去调用.
# class Person:
# def __init__(self,username,password): # 构造方法 # 第二部分 动态方法,方法(函数)
# self.usn = username # 公有对象属性
# self.__pwd = self.__makepassword()
# def __makepassword(self):
# '''复杂的加密过程'''
# new_pwd = self.__pwd + '666'
# return new_pwd
# p1 = Person('alex','123')
# print(p1.__pwd)
# class A:
# def __init__(self):
# self.__func()
# def __func(self):
# print('IN A')
# class B(A):
# def __func(self):
# print('IN B')
# b1 = B()
class A:
def __init__(self):
self.func()
def func(self):
print('IN A')
class B(A):
def func(self):
print('IN B')
b1 = B()
# print(b1.name)
# print(b1.func)
print(b1.func)
print(b1.func())