当前位置：首页 > news >正文

Python面向对象编程(六)--多态

news 2026/6/8 10:29:39

https://py.qizhen.xyz/iterator
1.python构造函数和析构函数
2.python抽象类和接口
3.python类多态

一、关于多态
1.继承和多态
2.使用父类引用调用子类的方法
3.内置多态
4.运算符多态
5.参数多态
6.抽象基类实现多态

二、多态案例
案例一：多态的基本使用
class Animal:
def speak(self):
pass

class Dog(Animal):
def speak(self):
return "汪汪汪"

class Cat(Animal):
def speak(self):
return "喵喵喵"

def mak_sound(animal:Animal):#animal:Animal其中animal为对象，Animal为类；并且:Animal可以省略
print(animal.speak())

dog = Dog()
#mak_sound(Dog())
mak_sound(dog)###mak_sound的参数是要传输对象，而不是类，所以这里要使用Dog()，等价于mak_sound(Dog())
mak_sound(Cat())

或者
class Dog(Animal):
def speak(self):
return "汪汪汪"

class Cat(Animal):
def speak(self):
return "喵喵喵"

def mak_sound(animal):#animal:Animal
print(animal.speak())

dog = Dog()
#mak_sound(Dog())
mak_sound(dog)###mak_sound的参数是要传输对象，而不是类，所以这里要使用Dog()，等价于mak_sound(Dog())
mak_sound(Cat())

案例二：
class Bird:
def fly(self):
return "我是鸟类，我在天空中飞翔..."

class Penguin(Bird):
def fly(self):
return "我是企鹅，我不会飞翔，但是我会游泳..."

class Sparrow(Bird):
def fly(self):
return "我是一只小麻雀，我可以在天空中飞翔..."

def bird_action(bird:Bird):
print(bird.fly())

bird_action(Penguin())
bird_action(Sparrow())

案例三：不依赖继承的多态
class Duck:
def quack(self):
return "鸭子，嘎嘎嘎..."

class Person:
def quack(self):
return "人类，模仿鸭子,嘎嘎嘎..."

def make_quack(obj):
print(obj.quack())

make_quack(Duck())
make_quack(Person())

案例四：内置函数len()多态
#print(len([1, 2, 3])) # 3
#print(len("hello")) # 5
#print(len({"a": 1, "b": 2})) # 2

class BookCollection:
def __init__(self,books):
self.books = books

def __len__(self):
return len(self.books)

BookCollection1 = BookCollection(["python","java","c++"])
print(len(BookCollection1))

BookCollection2 = BookCollection("hello")
print(len(BookCollection2))

BookCollection3 = BookCollection({"a": 1, "b": 2})
print(len(BookCollection3))

案例五：运算符+的多态
print(10 + 5) # 15
print("Hello" + " " + "World") # Hello World
print([1, 2] + [3, 4]) # [1, 2, 3, 4]

class Vector:
def __init__(self,x,y):
self.x = x
self.y = y

def __add__(self,other):
return Vector(self.x + other.x,self.y + other.y)

def __repr__(self):
return f"Vector({self.x},{self.y})"

v1 = Vector(1,2)
v2 = Vector(3,4)
print(v1 + v2)

案例六：
class Circle:
def __init__(self,radius):
self.radius = radius

def area(self):
return 3.14*self.radius**2

class Square:
def __init__(self,side):
self.side = side

def area(self):
return self.side**2

def print_area(shape):
print(f"面积为:{shape.area()}")

print_area(Circle(5))
print_area(Square(4))

案例七：使用抽象基类ABC强制多态契约
说明：Abstract Base Class,ABC
抽象类Abstract Base Class,ABC;
通过abc模块来是实现。

from abc import ABC,abstractmethod

#定义一个抽象类
class Payment(ABC):
#抽象类的抽象方法
@abstractmethod
def pay(self,amount):
pass #抽象类的抽象方法，在子类中必须要进行实现

#信用卡支付
class CreditCardPayment(Payment):
def pay(self,amount):
return f"使用信用卡支付{amount}元"

class AlipayPayment(Payment):
def pay(self,amount):
return f"使用阿里支付宝{amount}"

def checkout(payment_method:Payment,amount):
print(payment_method.pay(amount))

checkout(CreditCardPayment(),100)
checkout(AlipayPayment(),200)

案例八：定义一个迭代类
class Countdown:
def __init__(self,start):
self.start = start

def __iter__(self):
n = self.start
while n > 0:
yield n ###yield n表示产生n的意思
n -= 1

for num in Countdown(10):
print(num)

案例九：上下文管理器多态（with 语句）
#任何实现了__enter__和__exit__的对象都能用于with
#文件打开类
class FileOpener:
def __init__(self,filename,mode):
self.filename = filename
self.mode = mode

def __enter__(self):
self.file = open(self.filename,self.mode)
return self.file

def __exit__(self,exc_type,exc_val,exc_tb):
self.file.close()

#连接数据库类
class DatabaseConnection:
def __enter__(self):
print("建立数据库的连接")
return self

def __exit__(self,*args):
print("关闭数据库的连接")

def query(self,sql):
print(f"数据库的查询：{sql}")

with FileOpener("test.txt","w") as f:
f.write("hello")

with DatabaseConnection() as db:
db.query("SELECT * FROM users")

案例十：@property 的多态（不同类实现相同属性接口）
@property 装饰器可以将方法“伪装”成属性，并且支持继承与重写，从而实现多态。
class TemperatureCelsius:
def __init__(self, celsius):
self._celsius = celsius
@property
def temp(self):
return self._celsius
@temp.setter
def temp(self, value):
self._celsius = value

class TemperatureFahrenheit:
def __init__(self, fahrenheit):
self._fahrenheit = fahrenheit
@property
def temp(self):
return (self._fahrenheit - 32) * 5/9
@temp.setter
def temp(self, celsius_value):
self._fahrenheit = celsius_value * 9/5 + 32

def show_temp(temp_obj):
# 不管对象是摄氏度类还是华氏度类，都通过 .temp 属性获取值
print(f"当前温度: {temp_obj.temp:.1f}°C")

c = TemperatureCelsius(25)
f = TemperatureFahrenheit(77)
show_temp(c) # TemperatureCelsius当前温度: 25.0°C
show_temp(f) # TemperatureFahrenheit当前温度: 25.0°C

查看全文

http://www.jsqmd.com/news/606200/