抽象类,接口类
Python没有接口这个概念
抽象类(接口类): 目的是制定一个规范
要学会归一化设计,有重复的东西就要想把它们合并起来
from abc import ABCMeta, abstractclassmethod
class Payment(metaclass=ABCMeta): # 创建一个抽象 (接口) 类 的父类,
@abstractclassmethod
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)
# 都有pay这个方法 就建一个pay的函数
def pay(obj):
obj.pay()
# 实例化一个Alipay的对象
a1 = Alipay(2000)
# 实例化一个Jdpay的对象
j1 = Jdpay(1999)
# 实例化一个Wechatpay的对象
w1 = WeChatpay(1)
pay(a1)
pay(j1)
pay(w1)
多态( python没有多态 有鸭子类型. ): 鸭子类型 : 看着像鸭子,他就是鸭子.
python是 弱类型语言
name = 'alex'
python 不管什么类型,传入函数,封装到对象中都可以.
这些类 都互称为鸭子.都有index方法
class Str:
def index(self):
pass
class List:
def abc(self):
pass
class Tuple:
def rrr(self):
pass
封装
广义的封装: 实例化一个对象,给对象空间封装一些属性.
狭义的封装: 私有制.
私有成员: __私有静态字段(变量), __私有方法, __私有对象属性
self.__ XXX 才可以访问
类的内部可以访问
# 类外部不能访问 # 类的内部可以访问 # 类的派生类也不能访问
私有静态字段(变量)
私有静态字段：仅类内部可以访问；
class B:
__money = 100000
class A(B):
name = 'alex'
__age = 1000
def func(self):
print(self.__age)
print(A.__age) # 对于私有静态字段,类的内部可以访问.
print('func....')
def func1(self):
print(self.__money)
print(A.__money)
a1 = A()
print(a1.name)
print(A.name)
print(a1.__age) # 实例化对象不能访问私有静态字段
print(A.__age) # 类名不能访问私有静态字段
# 对于私有静态字段,类的外部不能访问.
a1.func()
# 对于私有静态字段,类的内部可以访问.
a1.func1()
# 对于私有静态字段来说,只能在本类中内部访问,类的外部,派生类均不可访问.
# 可以访问,但是工作中千万不要用.
print(A._A__age)
print(A.__dict__)
私有方法
私有方法:仅类内部可以访问
class B:
__money = 100000
def __f1(self):
print('B')
class A(B):
name = 'alex'
def __func(self):
print('func....')
def func1(self):
# self.__func() # 类的内部可以访问
self.__f1()
a1 = A()
a1.__func() # 类外部不能访问
a1.func1() # 类的内部可以访问
a1.func1() # 类的派生类也不能访问.
私有对象属性
class Bmi:
def __init__(self,name, weight, heigth):
self.name = name
self.__weight = weight
self.heigth = heigth
def bmi(self):
b = self.__weight / (self.__weight**2)
return self.__weight
p1 = Bmi('张三',89,1.77)
print(p1.bmi())
面试题
class Parent:
def __func(self): # ③
print('in 父类 func')
def __init__(self): # ②
self.__func()
class Son(Parent):
def __func(self):
print('in 子类 func')
son1 = Son() # ①
'''
1.实例化一个son的对象
2.找__init__()方法 子类里面没有,找父类,父类中有__init__()方法
3.类外部不能访问 类的内部可以访问 类的派生类也不能访问
'''
面向对象结构与成员
''''''
'''
class A:
name = '静态字段' # ======> 第一部分 静态字段 部分
def __init__(self):
pass
# ======> 第二部分 方法部分
def func(self):
pass
'''
class A:
company_name = 'old_boy_educaion' # 静态变量
__iphone = '138xxxxxxxxx' # 私有静态变量(私有静态字段)
def __init__(self,name,age): # 普通方法(构造方法)
self.name = name # 对象属性(普通字段)
self.age = age # 私有对象属性(私有普通字段)
def func1(self): # 普通方法
pass
def __func(self): # 私有方法
pass
@classmethod # 类方法
def class_func(cls):
# 定义静态方法,无默认参数
print('静态方法')
@staticmethod # 静态方法
def static_func():
# 定义静态方法,无默认参数
@property # 属性
def prop(self):
pass