面向对象三大特征(python)

 

目录

1. 封装

为什么使用封装？

如何实现封装？

一个简单的封装示例

 二.继承

为什么使用继承？

如何实现继承？

一个简单的继承示例

使用继承的好处

三.多态

为什么使用多态？

如何实现多态？

一个简单的多态示例

使用多态的好处

---

1. 封装：封装是指将数据和操作数据的方法捆绑在一起，通过这种方式可以控制数据的访问权限，使得对象的内部细节对外部不可见，从而提高了代码的安全性和可靠性。

2. 继承：继承是指一个类可以基于另一个类来创建新类的机制。子类可以继承父类的属性和方法，并且可以在不改变父类的情况下扩展或修改功能，从而实现代码的重用和扩展。

3. 多态：多态是指同一种操作作用于不同的对象时，可以产生不同的行为。通过多态，可以编写通用的代码，让程序在运行时根据对象的实际类型来决定调用哪个方法，提高了代码的灵活性和可扩展性。

1. 封装

封装：面向对象编程的核心原则

在面向对象编程中，封装是一种核心原则，它允许我们将数据和操作封装在一个单独的单元中，从而隐藏了数据的具体实现细节，只暴露出必要的接口供外部使用。这种方式提高了代码的可维护性、可重用性和安全性。

为什么使用封装？

封装的主要目的是将数据和操作打包在一起，形成一个独立的单元，外部只能通过指定的接口来访问数据和操作，而不能直接访问内部实现细节。这样做的好处有：

1. 隐藏实现细节：封装可以隐藏数据的具体实现细节，使得外部无法直接访问和修改数据，从而提高了代码的安全性和可维护性。

2. 简化接口：封装可以将复杂的实现细节封装在内部，只暴露出简单的接口供外部使用，使得代码更易于理解和使用。

3. 提高重用性：封装可以将通用的功能封装在一个单元中，使得这些功能可以在不同的地方重复使用，提高了代码的重用性。

如何实现封装？

在面向对象编程中，封装通常通过类和对象来实现。类将数据和操作封装在一起，而对象则是类的实例，可以通过对象来访问封装在类中的数据和操作。

在Python中，我们可以使用访问控制符（如私有成员变量和方法）来实现封装。通过将属性或方法命名以双下划线开头，我们可以将它们设置为私有的，外部无法直接访问，只能通过类提供的接口来访问。

一个简单的封装示例

让我们通过一个简单的例子来说明封装的概念。假设我们有一个 Person 类，表示一个人，其中包含姓名和年龄两个属性，我们希望将年龄设置为私有的，只能通过提供的接口来访问。

class BankAccount:
    def __init__(self, account_number, balance=0):
        self.account_number = account_number
        self.__balance = balance  # 封装的私有属性
 
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"Deposit of {amount} successful.")
        else:
            print("Invalid deposit amount.")
 
    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            print(f"Withdrawal of {amount} successful.")
        else:
            print("Invalid withdrawal amount.")
 
    def get_balance(self):
        return self.__balance
 
 
# 创建银行账户对象
acc1 = BankAccount("12345678", 1000)
 
# 尝试直接访问私有属性
# print(acc1.__balance)  # 无法直接访问私有属性
 
# 通过公有方法访问私有属性
print("Current balance:", acc1.get_balance())
 
# 进行存款和取款操作
acc1.deposit(500)
print("Current balance after deposit:", acc1.get_balance())
 
acc1.withdraw(200)
print("Current balance after withdrawal:", acc1.get_balance())

这个示例中，BankAccount 类封装了账户号码和账户余额，其中 __balance 是私有属性，通过 deposit() 和 withdraw() 方法实现对账户余额的操作，同时通过 get_balance() 方法来获取账户余额。

 二.继承

为什么使用继承？

继承允许我们建立一个层次结构，通过在父类中定义通用的属性和方法，然后在子类中添加特定的功能或行为，从而实现代码的重用和扩展。这种方法使得代码更加模块化，易于理解和维护。

如何实现继承？

在Python中，实现继承非常简单。我们可以通过在子类的定义中将父类作为参数传递给子类来实现继承。子类继承了父类的所有属性和方法，并可以添加新的属性和方法或覆盖父类的方法。

一个简单的继承示例

# 父类
class Animal:
    def __init__(self, name):
        self.name = name
 
    def speak(self):
        return f"{self.name} 叫!"
 
 
# 子类继承父类
class Dog(Animal):
    def Dog_speak(self):
        return super().speak()
 
 
class Cat(Animal):
    def Dog_speak(self):
        return super().speak()
 
 
# 创建对象并调用方法
dog = Dog("狗")
print(dog.speak())
 
cat = Cat("猫")
print(cat.speak())

使用继承的好处

通过继承，我们可以避免重复编写相似的代码，提高了代码的复用性。当我们需要添加新的功能或行为时，只需要在子类中进行修改，而不需要修改父类，这样可以减少代码的维护成本。

继承还使得代码更具灵活性和可扩展性，我们可以轻松地添加新的子类来扩展现有的功能，而不会影响到其他部分的代码。

三.多态

多态：面向对象编程的灵活性之道

在面向对象编程中，多态是一种重要的概念，它允许我们使用统一的接口来操作不同类型的对象，从而实现灵活性和可扩展性。多态使得代码更加通用、易于理解和维护。

为什么使用多态？

多态的主要目的是提高代码的灵活性和可扩展性。通过多态，我们可以编写与具体类型无关的代码，从而使得代码更加通用和可重用。当我们需要添加新的类型时，只需要编写新的类并实现相同的接口，而不需要修改现有的代码，这样大大提高了代码的可维护性和可扩展性。

如何实现多态？

在面向对象编程中，多态通常通过继承和方法重写来实现。当子类继承自父类，并重写了父类的方法时，我们可以使用父类的引用来引用子类的对象，并调用相同的方法，实现了多态。

另一种实现多态的方式是通过接口。在一些编程语言中，如Java，我们可以定义一个接口，并要求所有实现该接口的类都实现相同的方法。然后我们可以使用接口的引用来引用实现了该接口的不同类的对象，并调用相同的方法，实现了多态。

一个简单的多态示例

让我们通过一个简单的例子来说明多态的概念。假设我们有一个 Shape 类，表示形状，其中包含一个 draw() 方法用来绘制形状。然后我们创建了两个子类 Circle 和 Rectangle，分别表示圆和矩形，并重写了 draw() 方法。

class Shape:
    def draw(self):
        pass
 
class Circle(Shape):
    def draw(self):
        print("绘制圆形")
 
class Rectangle(Shape):
    def draw(self):
        print("绘制矩形")

现在，我们可以使用多态来调用不同子类的 draw() 方法，而不需要知道具体是哪个子类。

def draw_shape(shape):
    shape.draw()
 
circle = Circle()
rectangle = Rectangle()
 
draw_shape(circle)     # 输出：绘制圆形
draw_shape(rectangle)  # 输出：绘制矩形

在这个例子中，draw_shape() 函数接受一个 Shape 类型的参数，然后调用该参数的 draw() 方法。由于 Circle 和 Rectangle 类都继承自 Shape 类，并重写了 draw() 方法，因此我们可以传递 Circle 和 Rectangle 类的对象作为参数，实现了多态。

使用多态的好处

多态使得代码更加灵活、通用和易于扩展。通过统一的接口操作不同类型的对象，我们可以编写与具体类型无关的代码，提高了代码的可重用性和可维护性。当我们需要添加新的类型时，只需要实现相同的接口，而不需要修改现有的代码，这样大大降低了代码的维护成本。