python面向对象 : 抽象类(接口类),多态,封装(私有制封装)
一. 抽象类(接口类)
与java一样, python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类, 它的特殊之处在于只能被继承, 不能被实例化.
从设计角度去看, 如果类是从现实对象抽象而来的, 那么抽象类就是基于类抽象而来的。
从实现角度来看, 抽象类与普通类的不同之处在于: 抽象类中有抽象方法, 该类不能被实例化, 只能被继承, 且子类必须实现抽象方法. 这一点与接口有点类似, 但其实是不同的.
实现不同的支付方式:
class Alipay: def __init__(self, money): self.money = money def alipay(self): print('使用支付宝支付了%s元' % self.money) class Jdpay: def __init__(self, money): self.money = money def jdpay(self): print('使用京东支付了%s元' % self.money) a = Alipay(500) a.alipay() # 使用支付宝支付了500元 j = Jdpay(200) j.jdpay() # 使用京东支付了200元
虽然都实现了支付,但是两个支付都是相同的功能,但调用方却不一样,可以把调用方设置一样.
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() a = Alipay(500) pay(a) # 调用函数pay,把对象a穿进去,并执行函数语句 j = Jdpay(200) pay(j) # 调用函数pay,把对象j穿进去,并执行函数语句 # 调用方都是函数pay 归一化设计
虽然设置了一个pay函数,但是有可能后面接手你程序的人并不会发现,含是按照第一种的方法实现新的支付方式,所以我们要确保在之后添加的类中要有pay函数.
from abc import ABCMeta, abstractmethod # 从abc模块引进ABCMeta,abstractmethod class Allpay: @abstractmethod # 在需要制定模板的函数上写一句 def pay(self): # 制定规范,子类中必须有pay方法,否则报错 pass class Alipay(Allpay): def __init__(self, money): self.money = money def pay(self): print('使用支付宝支付了%s元' % self.money) class Jdpay(Allpay): def __init__(self, money): self.money = money def pay(self): print('使用京东支付了%s元' % self.money) class Wechatpay(Allpay): def __init__(self, money): self.money = money # def wechatpay(self): #函数名不是pay会报错 # pass def pay(self): print('使用微信支付了%s元' % self.money) def pay(obj): obj.pay() a = Alipay(500) pay(a) # 使用支付宝支付了500元 j = Jdpay(200) pay(j) # 使用京东支付了200元 w = Wechatpay(700) pay(w) # 使用微信支付了700元
二. 多态
python不支持多态, 也不用支持多态,因为python处处是多态, python是一种多态语言, 参数在传入之前是无法确定参数类型的. 崇尚鸭子类型
鸭子类型 : 看着像鸭子,他就是鸭子, 下面的类有相同功能的方法, 都互称为鸭子.
class Str: def index(self): pass class List: def index(self): pass class Tuple: def index(self): pass
三. 封装
封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。所以，在使用面向对象的封装特性时，需要：将内容封装到某处, 然后从某处调用被封装的内容.
封装分为广义的封装和狭义的封装
广义的封装: 实例化一个对象,给对象空间封装一些属性.
class Animal: def __init__(self,name,sex,age): self.name = name #广义的封装 self.age = age self.sex = sex
狭义的封装: 私有制.
私有成员 : 私有静态字段, 私有方法, 私有对象属性
私有静态字段:
在类外部引用私有静态字段
class Pay: __money = 1000 # 定义私有静态变量__money def pay(self): pass p = Pay() p.__money # 报错,在类外部对象无法引用私有静态字段__money Pay.__money # # 报错,在类外部类名无法引用私有静态字段__money
在类内部引用私有静态字段
class Pay: __money = 1000 # 定义私有静态变量__money def pay(self): print(p.__money) # 在类内部对象可以引用私有静态字段__money print(Pay.__money) # 在类内部类名可以引用私有静态字段__money p = Pay() p.pay() # 1000 # 1000
在子类引用私有静态字段
class Money: __money = 1000 # 定义私有静态变量__money class Pay(Money): def pay(self): pass print(p.__money) # 在子类内部对象不能引用父类的私有静态字段__money print(Pay.__money) # 在子类内部类名不能引用父类的私有静态字段__money p = Pay() # p.__money # 子类的对象无法引用父类的私有静态字段__money # Pay.__money # 子类名无法引用父类的私有静态字段__money p.pay()
总结:对于私有静态字段来说,只能在本类中内部访问,类的外部,派生类(子类)均不可访问.
# 可以访问,但是工作中千万不要用 : '__类名私有静态字段' # print(Pay._Pay__money) # print(Pay.__dict__)
私有方法:对于私方法来说,只能在本类中内部访问,类的外部,派生类(子类)均不可访问.
class B: def __f1(self): print('777') class A(B): def __func(self): print('666') def func1(self): self.__func() # 类内部可以访问 self.f1() # 子类无法访问父类的私有方法 a = A() # a.__func() # 类外部对象不能访问 # A.__func() # 类外部类名不能访问 a.func1() # 666 # 666
私有属性
class A: def __init__(self,name,age,weight): self.name = name self.__age = age self.__weight = weight def func(self): print(self.__age) #类内可以引用私有属性 a1 = A('jsck',18,45) print(a1.name) print(a1.__dict__) # {'name': 'jsck', '_A__age': 18, '_A__weight': 45} # print(a1.__age) # 类外无法引用私有属性 a1.func()
面试题
class Parent: def __func(self): print('in Parent func') def __init__(self): # 自动执行__init__方法 self.__func() # self.__func() =>> self.__Parent__func class Son(Parent): def __func(self): print('in Son func') son1 = Son() # in Parent func
