7.5 KiB
7.5 KiB
封装与多态
python面向对象的三大特性：继承，封装，多态。
-
封装:
- 封装是将数据（属性）与操作数据的方法（行为）绑定在一起，形成独立的类，并通过访问控制隐藏对象的内部实现细节，仅暴露必要的接口供外部使用。其核心目的是保护数据完整性（防止外部直接修改对象状态）和降低代码耦合度（外部无需关心内部实现）。
-
继承:
- 继承是**子类（派生类）继承父类（基类/超类）**的属性和方法的机制，用于实现代码复用和类的层次结构。子类可以扩展父类的功能（添加新属性/方法），或重写父类的方法（修改默认行为）。
-
多态:
- 多态是指同一操作作用于不同对象时，产生不同行为的特性。其核心是“接口统一，实现多样”，允许程序以统一的方式处理不同类型的对象，无需关心对象的具体类型。
封装
第一步：将内容封装到某处
class Foo:
def __init__(self,name,age):
self.name = name
self.age = age
obj1 = Foo('张三',18)
obj2 = Foo('李四',16)
第二步：从某处调用被封装的内容
class Foo:
def __init__(self,name,age):
self.name = name
self.age = age
def detail(self):
print(self.name)
print(self.age)
obj1 = Foo('张三',18)
obj2 = Foo('李四',16)
print(obj1.name)
print(obj2.age)
# 通过对象直接调用被封装的内容
obj1.detail()
obj2.detail()
# 通过self间接调用被封装的内容
多态
通过继承与方法重写实现多态
这是实现多态最直接的方式。子类继承父类并重写其方法，从而提供特定的实现。当调用方法时，实际执行的是子类中重写的方法
class Animal:
def speak(self):
raise NotImplementedError("子类必须实现此方法") # 父类定义方法接口
class Dog(Animal):
def speak(self): # 子类重写方法
return "Woof!"
class Cat(Animal):
def speak(self): # 子类重写方法
return "Meow!"
# 多态的函数
def animal_speak(animal):
print(animal.speak()) # 统一接口调用
dog = Dog()
cat = Cat()
animal_speak(dog) # 输出: Woof!
animal_speak(cat) # 输出: Meow!
通过鸭子类型实现多态
Python 的鸭子类型（Duck Typing）是一种动态类型风格，它不要求对象继承自特定类，只关心对象是否具有所需的方法或属性（“如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子”）
class Duck:
def quack(self):
return "Quack!"
class Person:
def quack(self): # 无需继承特定类，只需有 quack 方法
return "I'm quacking like a duck!"
def make_it_quack(thing): # 函数只关心传入对象是否有 quack 方法
print(thing.quack())
duck = Duck()
person = Person()
make_it_quack(duck) # 输出: Quack!
make_it_quack(person) # 输出: I'm quacking like a duck!
类的约束
写一个支付功能
class QQpay:
def pay(self,money):
print('使用qq支付%s元' % money)
class Alipay:
def pay(self,money):
print('使用阿里支付%s元' % money)
a = Alipay()
a.pay(100)
b = QQpay()
b.pay(200)
统一一下付款方式
class QQpay:
def pay(self,money):
print('使用qq支付%s元' % money)
class Alipay:
def pay(self,money):
print('使用阿里支付%s元' % money)
def pay(obj,money):
obj.pay(money)
a = Alipay()
b = QQpay()
pay(a,100)
pay(b,200)
如果后期添加微信支付，但是没有统一标准，换个程序员就可能写成这样
class QQpay:
def pay(self,money):
print('使用qq支付%s元' % money)
class Alipay:
def pay(self,money):
print('使用阿里支付%s元' % money)
class Wechatpay:
def fuqian(self,money):
print('使用微信支付%s元' % money)
def pay(obj,money):
obj.pay(money)
a = Alipay()
b = QQpay()
pay(a,100)
pay(b,200)
c = Wechatpay()
c.fuqian(300)
所以此时我们要用到对类的约束，对类的约束有两种：
-
提取⽗类. 然后在⽗类中定义好⽅法. 在这个⽅法中什么都不⽤⼲. 就抛⼀个异常就可以了. 这样所有的⼦类都必须重写这个⽅法. 否则. 访问的时候就会报错.
-
使⽤元类来描述⽗类. 在元类中给出⼀个抽象⽅法. 这样⼦类就不得不给出抽象⽅法的具体实现. 也可以起到约束的效果.
- 先用第一种方法解决问题
class Payment:
"""
此类什么都不做，就是制定一个标准，谁继承我，必须定义我里面的方法。
"""
def pay(self,money):
raise Exception("你没有实现pay方法")
class QQpay(Payment):
def pay(self,money):
print('使用qq支付%s元' % money)
class Alipay(Payment):
def pay(self,money):
print('使用阿里支付%s元' % money)
class Wechatpay(Payment):
def fuqian(self,money):
print('使用微信支付%s元' % money)
def pay(obj,money):
obj.pay(money)
a = Alipay()
b = QQpay()
c = Wechatpay()
pay(a,100)
pay(b,200)
pay(c,300)
- 引入抽象类的概念处理
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta): # 抽象类 接口类 规范和约束 metaclass指定的是一个元类
@abstractmethod
def pay(self):pass # 抽象方法
class Alipay(Payment):
def pay(self,money):
print('使用支付宝支付了%s元'%money)
class QQpay(Payment):
def pay(self,money):
print('使用qq支付了%s元'%money)
class Wechatpay(Payment):
# def pay(self,money):
# print('使用微信支付了%s元'%money)
def recharge(self):pass
def pay(a,money):
a.pay(money)
a = Alipay()
a.pay(100)
pay(a,100) # 归一化设计：不管是哪一个类的对象，都调用同一个函数去完成相似的功能
q = QQpay()
q.pay(100)
pay(q,100)
w = Wechatpay()
pay(w,100) # 到用的时候才会报错
# 抽象类和接口类做的事情 ：建立规范
# 制定一个类的metaclass是ABCMeta，
# 那么这个类就变成了一个抽象类(接口类)
# 这个类的主要功能就是建立一个规范
总结: 约束. 其实就是⽗类对⼦类进⾏约束. ⼦类必须要写xxx⽅法. 在python中约束的⽅式和⽅法有两种:
-
使⽤抽象类和抽象⽅法, 由于该⽅案来源是java和c#. 所以使⽤频率还是很少的
-
使⽤⼈为抛出异常的⽅案. 并且尽量抛出的是NotImplementError. 这样比较专业, ⽽且错误比较明确.(推荐)
super()深入了解
super是严格按照类的继承顺序执行！！！
class A:
def f1(self):
print('in A f1')
def f2(self):
print('in A f2')
class Foo(A):
def f1(self):
super().f2()
print('in A Foo')
obj = Foo()
obj.f1()
class A:
def f1(self):
print('in A')
class Foo(A):
def f1(self):
super().f1()
print('in Foo')
class Bar(A):
def f1(self):
print('in Bar')
class Info(Foo,Bar):
def f1(self):
super().f1()
print('in Info f1')
obj = Info()
obj.f1()
print(Info.mro())
class A:
def f1(self):
print('in A')
class Foo(A):
def f1(self):
super().f1()
print('in Foo')
class Bar(A):
def f1(self):
print('in Bar')
class Info(Foo,Bar):
def f1(self):
super(Foo,self).f1()
print('in Info f1')
obj = Info()
obj.f1()