python基础之面向对象
面向对象
面向对象(Object-Oriented Programming,简称OOP)是一种程序设计范式,它以“对象”为核心,将现实世界中的实体抽象为软件系统中的对象,通过对象之间的相互协作来实现复杂的功能。
特性:
对象(Object)与类:
对象(Object):
对象是面向对象编程的基本单元,是对现实世界中实体的抽象。
类(Class):
类是对象的模板或蓝图,它定义了一组共享相同属性和方法的对象的共同特征。通过创建类的实例(即对象),可以生成具有相同结构和行为的多个对象。类还可以通过继承机制实现代码复用。
class Car:
def __init__(self, make, model, color):
self.make = make
self.model = model
self.color = color
self.speed = 0
def accelerate(self, increment):
self.speed += increment
print(f"{self.make} {self.model} is now going at {self.speed} km/h.")
def brake(self, decrement):
self.speed -= decrement
if self.speed < 0:
self.speed = 0
print(f"{self.make} {self.model} slowed down to {self.speed} km/h.")
# 创建一个Car对象实例
my_car = Car("Toyota", "Corolla", "Silver")
# 调用对象的方法
my_car.accelerate(50)
my_car.brake(30)
`Car` 是一个类,它定义了汽车对象共有的属性(`make`、`model`、`color`、`speed`)和方法(`accelerate`、`brake`)。
`__init__` 是一个特殊方法(构造函数),当创建类的实例时自动调用,用于初始化对象的属性。
`my_car` 是 `Car` 类的一个实例(对象),具有指定的制造商、型号、颜色和初始速度为0
封装(Encapsulation):
封装是指将对象的属性和方法封装在类内部,对外提供有限的接口(通常是方法)供其他对象访问。这样可以隐藏对象内部的复杂细节,保护数据安全,同时降低不同部分之间的耦合度。通过访问修饰符(如Python中的public
、private
等)控制属性和方法的可见性。
class Account:
def __init__(self, balance=0):
self.__balance = balance # 使用双下划线(__)标记为私有属性
def deposit(self, amount):
self.__balance += amount
print(f"存入金额: {amount}. 现金额: {self.__balance}")
def withdraw(self, amount):
if amount <= self.__balance:
self.__balance -= amount
print(f"取出金额: {amount}. 现金额: {self.__balance}")
else:
print("Insufficient funds.")
# 创建一个Account对象实例
my_account = Account(1000)
# 公开方法可以访问私有属性
my_account.deposit(int(input("请输入存入金额:")))
my_account.withdraw(int(input("请输入取出金额:")))
# 直接访问私有属性会引发错误
# my_account.__balance = 900 # AttributeError: 'Account' object has no attribute '__balance'
__balance 是一个私有属性,使用双下划线前缀使其在外部无法直接访问,实现了封装。
公开方法 deposit 和 withdraw 提供了对私有属性的受控访问,确保了账户余额操作的安全性。
继承(Inheritance):
继承允许一个类(称为子类或派生类)继承另一个类(称为父类或基类)的属性和方法。子类可以扩展或覆盖父类的行为,从而形成一个类的层次结构。继承有助于代码复用,减少冗余,并能体现类与类之间的“is-a”关系。例如,可以定义一个Vehicle基类,然后让Car、Truck等子类继承自Vehicle。
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
raise NotImplementedError("子类必须实现'speak()'方法。")
class Dog(Animal):
def speak(self):
return f"{self.name} 狗叫."
class Cat(Animal):
def speak(self):
return f"{self.name} 猫叫."
# 创建子类对象并调用继承的方法
my_dog = Dog("Buddy")
print(my_dog.speak()) # Buddy barks.
my_cat = Cat("Whiskers")
print(my_cat.speak()) # Whiskers meows.
Animal 是一个基类,定义了一个通用的 speak 方法,但并未给出具体实现,而是抛出 NotImplementedError 强制子类去实现。
Dog 和 Cat 分别继承自 Animal 类,实现了各自的 speak 方法,体现了动物叫声的差异。
创建 Dog 和 Cat 的实例后,可以直接调用从基类继承来的 speak 方法
多态(Polymorphism):
多态是指同一消息(即方法调用)作用于不同对象时产生不同的行为。有两种常见的多态形式:静态多态(通过函数重载或运算符重载实现)和动态多态(通过虚函数、接口或鸭子类型实现)。动态多态是面向对象的重要特性,它允许程序在运行时根据对象的实际类型确定应执行的方法,增强了代码的灵活性和可扩展性
class Shape:
def area(self):
raise NotImplementedError("子类必须实现'area()'方法。")
class Square(Shape):
def __init__(self, side):
self.side = side
def area(self):
return self.side ** 2
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
import math
return math.pi * (self.radius ** 2)
shapes = [Square(5), Circle(4)]
for shape in shapes:
print(f"{shape.__class__.__name__.lower()}的面积为:{shape.area()}.")
Shape 是一个抽象基类,定义了 area 方法但未给出具体实现,要求子类提供。
Square 和 Circle 分别继承自 Shape,各自实现了 area 方法,计算矩形和圆形的面积。
将 Square 和 Circle 实例放入一个列表中,通过循环调用它们的 area 方法。尽管调用方式相同,但由于多态性,实际执行的是各自类中定义的方法,体现了“一个接口,多种实现”。
- 点赞
- 收藏
- 关注作者
评论(0)