主要内容:
1. 抽象类(接口类):
制定一个规范 :
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):
@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 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__)
原文:https://www.cnblogs.com/gyh412724/p/9371352.html