主要内容:
1. 抽象类(接口类) : python没有接口这个概念.只是制定一个规范.
制定一个规范 :凡是继承我的类,必须有我规定的方法.
第一版:
class Alipay:
def __init__(self,money):
self.money = money
def pay(self):
print('用支付宝花了%s钱' % self.money)
class Jdpay:
def __init__(self,money):
self.money = money
def pay(self):
print('在京东花了%s钱' % self.money)
a1 = Alipay(100)
j1 = Jdpay(200)
a1.pay()
j1.pay()
第二版:支付方式一样
class Alipay:
def __init__(self,money):
self.money = money
def pay(self):
print('用支付宝花了%s钱' % self.money)
class Jdpay:
def __init__(self,money):
self.money = money
def pay(self):
print('在京东花了%s钱' % self.money)
def pay(obj):
obj.pay()
a1 = Alipay(100)
j1 = Jdpay(200)
pay(a1) #归一化设计.
pay(j1)
第三版:野生程序员来了... 添加一个微信支付的功能
# 野生程序员来了,....增加一个微信支付的功能
class Alipay:
def __init__(self,money):
self.money = money
def pay(self):
print('用支付宝花了%s钱' % self.money)
class Jdpay:
def __init__(self,money):
self.money = money
def pay(self):
print('在京东花了%s钱' % self.money)
class Wechatpay:
def __init__(self,money):
self.money = money
def weixinpay(self): #对于具有相同功能的方法,尽量使用同一个名字.
print('使用微信支付了%s' % self.money)
def pay(obj):
obj.pay()
a1 = Alipay(100)
j1 = Jdpay(200)
w1 = Wechatpay(300)
a1.pay()
j1.pay()
w1.weixinpay()
第四版:重新修改,制定规则,抽象类,接口类.
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta): #定义一个模块,强制使用pay,派生类中不适用会报错.
@abstractmethod
def pay(self):pass
class Alipay(Payment):
def __init__(self,money):
self.money = money
def pay(self):
print('使用支付宝支付了%s' % self.money)
class Jdpay(Payment):
def __init__(self,money):
self.money = money
def pay(self):
print('使用京东支付了%s' % self.money)
class Wechatpay(Payment):
def __init__(self,money):
self.money = money
def pay(self):
print('使用微信支付%s' % self.money)
def pay(obj): #归一化设计.
obj.pay()
a = Alipay(200)
j = Jdpay(500)
w = Wechatpay(300)
pay(a)
pay(j)
pay(w)
2. 多态:python处处是多态,没有多态的事例. python:弱类型语言.
java:强类型语言.
python不管是什么类型,传入函数,封装到对象都可以.
Pyhon不支持Java和C#这一类强类型语言中多态的写法，但是原生多态，其Python崇尚“鸭子类型”
鸭子类型: 看着像鸭子,其实就是鸭子.
这些类:都互称为鸭子类型.
class Str:
def index(self):
pass
class List:
def index(self):
pass
class Tuple:
def index(self):
pass
3. 封装
广义的封装 : 实例化一个对象,给对象空间封装一些属性.给类中封装静态字段.
狭义的封装 : 私有制
私有成员: 私有静态字段 , 私有方法, 私有对象属性.
a: 私有静态字段:类的内部可以访问,类的外部不可以访问.
对于私有静态字段来说,只有在本类中内部访问,类的外部,派生类均不可访问.
class B:
__money = 1000
class A(B):
name = 'lily'
__age = 20
def func(self):
print(self.__age) #在类的内部实例化对象可以访问私有静态字段.
print(A.__age) #在类的内部类名可以访问私有静态字段.
def func1(self):
# print(self.__money) #对于私有静态字段,只有本类中内部可以访问,类的外部派生类都不可以.
# print(A.__money)
pass
a1 = A()
a1.func()
# print(a1.__age) #在类的外部,实例化对象不能访问类中的私有静态字段
# print(A.__age) #在类的外部,类名不能访问私有静态字段
a1.func1()
b: 私有方法:类的内部可以访问,类的外部和派生类都不可以访问.
class B:
__money = 1000
def __fn(self):
print('B')
class A:
name = 'lily'
__age = 20
def __func(self):
print('func,,,,')
def func1(self):
self.__func() #在类的内部可以访问私有方法.
# self.__fn() #在类的外部.派生类均不可以访问静态方法.
a1 = A()
# a1.__func() #类的外部不可以访问私有方法
a1.func1()
# print(B._B__money) #尽量不要用.
# print(a1._A__age)
# print(A._A__age)
a1._A__func()
A._A__func(1) #类名去访问类中的方法.一定要传参数.
c : 私有对象属性:在类的内部可以访问.在类的外部派生类都不可以访问.
class Foo:
def __init__(self,name,age,sex):
self.__name = name
self.__age = age
self.sex = sex
def fn(self):
print(f1.__name) #在类的内部可以实现
f1 = Foo('alex',23,'nan')
print(f1.__dict__)
print(f1.sex)
f1.fn()
print(f1.__age) #在类的外部不可以实现.
d : 面试题:
class Parent:
def __func(self): #_Parent__func
print('in Parent func')
def __init__(self):
self.__func()
class Son(Parent):
def __func(self):
print('in Son func')
son1 = Son() #实例化一个对象son1,自动执行_init_方法, 执行self.__func(),内部实际self._Parent__func
#子类中没有,然后执行 'in parent func'
print(Parent.__dict__)