python面向对象进阶

抽象类，接口类

注意：python 没有接口这个概念

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("使用支付宝支付了{}元".format(self.money))


class JdPay(Payment):
    def __init__(self, money):
        self.money = money

    def pay(self):
        print("使用京东支付了{}元".format(self.money))

class WechatPay(Payment):
    def __init__(self, money):
        self.money = money

    def weixinpay(self):
        print("使用微信支付了{}元".format(self.money))

def pay(obj):
    obj.pay()
a1 = AliPay(300)
j1 = JdPay(100)
pay(a1)  #归一化设计
w1 = WechatPay(200)
w1.weixinpay()

改正方法：在Wechatpay类中，将weixinpay方法改成pay.

改正代码如下：

class Wechatpay(Payment):
	def __init__(self,money):
		self.money = money
	def pay(self):
		print("使用微信支付了{}元".format(self.money))
#调用时
w1 = Wechatpay(200)
pay(w1)

总结：

• 抽象类(接口类) 在python中是一个概念
• 使用抽象类接口类是为了代码归一化设计，也就是代码更规范
• 如何使用抽象类(接口类)：
  - 导入模块：
  1、 from abc import ABCMeta,abstractmethod
  - 在父类中使用抽象类

from abc import ABCMeta,abstractmethod
class 父类名(metaclass=ABCMeta): #抽象类
	@abstractmethod
	def pay(self):  #制定规范，其他子类中必须有pay方法，否则报错
		pass

多态，封装：

python没有多态概念，因为python处处是多态
java是强类型语言，python是弱类型语言
python没有多态，那它有什么？ 有鸭子类型
鸭子类型：看着像鸭子，它就是鸭子

封装：

1. 广义的：实例化一个对象，给对象空间封装一些属性

2. 狭义的：私有制

   • 私有成员：私有静态字段，私有方法，私有对象属性

私有静态字段：

class A:
	name = 'alex'
	__age = 1000	
	def func(self):
		print(self.__age)
		print("func....")	
a1 = A()
print(a1.name)
print(A.name)

class A:
	name = 'alex'
	__age = 1000
	def func(self):
		print(self.__age)	
		print("func....")
a1 = A()
print(a1.__age)

同样，print(A.__age) 也是错误的。

• 对于静态私有属性，实例化对象不能调用，实例化对象不能访问。
• 类名不能访问 对于静态私有属性，类的外部不能访问，类都内部可以访问。
• 私有静态字段其实也可以在外部访问，但工作中千万不能用
  print(A._A__age)

私有方法：仅类内部可以访问

class C:
	def __init__(self):
		pass
	def __add(self):
		print("in C")
class D(C):
	def __show(self):
		print("in D")
	def func(self):
		self.__show()
obj = D()
obj.__show()  #不能通过对象访问私有方法
obj.func()    #类内部可以访问
obj.__add()   #派生类中不能访问

属性：

什么是属性？

property是一种特殊的属性，访问它时会执行一般功能(函数)，然后返回值

属性：将一个方法伪装成一个属性，在代码级别上没有本质的提升，但是让其看起来，更合理。

class Person:
	def __init__(self,name,hight,weight):
		self.name = name
		self.__hight = hight
		self.__weight = weight
	@property
	def bmi(self):
		return "{}的bmi值{}".format(self.name,round(self.__weight / self.__hight ** 2,2))
p1 = Person('alex',1.75,70)
print(p1.bmi())

因为我们已经将bmi方法伪装成一个属性，所以在调用时相当于bmi变成了属性，此时bmi后面无需跟()。
print(p1.bmi)

类方法：

通过类名调用的方法，类方法中第一个参数约定俗成cls,python自动将类名(类空间)传给cls

class A:
	def func(self):
		print(self)
	@classmethod  #类方法
	def func1(cls):
		print(cls)
a1 = A()
a1.func() #对象调用类方法，cls得到的是类本身

类方法的应用场景：

1. 类中有些方法是不需要对象参与
2. 对类中的静态变量进行改变，要用到类方法
3. 继承中，父类得到子类的类空间

静态方法：@staticmethod