程序员之路：编程语言面向对象的特征

这段时间一直忙着谈对象，都忘了面向对象的概念了，今天回忆回忆一下基础的知识。
面向对象编程（Object - Oriented Programming，OOP）有以下四个主要特征：

封装（Encapsulation）

概念

封装是指将对象的状态（数据成员）和行为（方法）包装在一个单元（类）中，并且对外部隐藏对象的内部细节，只通过定义好的接口来访问对象。这样可以防止外部代码随意访问和修改对象的内部数据，从而提高数据的安全性和程序的可维护性。

示例

以一个简单的 “银行账户” 类为例。

class BankAccount:
    def __init__(self, account_number, balance):
        self.__account_number = account_number
        self.__balance = balance

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"成功存入{amount}元，当前余额为{self.__balance}元。")
        else:
            print("存入金额必须大于0。")

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            print(f"成功取出{amount}元，当前余额为{self.__balance}元。")
        else:
            print("余额不足或取款金额不合法。")

    def get_balance(self):
        return self.__balance

在这个例子中，__account_number 和 __balance 是私有属性（在 Python 中，属性名前有双下划线表示私有属性），外部代码不能直接访问和修改它们。只能通过 deposit、withdraw 和 get_balance 这些公有方法来操作账户余额，这就是封装的体现。

继承（Inheritance）

概念

继承是一种创建新类（子类或派生类）的方式，新类从现有的类（父类或基类）继承属性和方法。子类可以继承父类的所有非私有成员，并且可以根据需要添加新的属性和方法，或者重写父类的方法，以实现特定的功能。这有助于代码的复用，减少重复代码的编写。

示例

假设已经有一个 “动物” 类（Animal），现在要创建一个 “狗” 类（Dog）。

class Animal:
    def __init__(self, name):
        self.name = name

    def eat(self):
        print(f"{self.name}正在吃东西。")


class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

    def bark(self):
        print(f"{self.name}（{self.breed}）正在汪汪叫。")

在这个例子中，Dog 类继承自 Animal 类。Dog 类继承了 Animal 类的 name 属性和 eat 方法，并且添加了自己的 breed 属性和 bark 方法。通过继承，可以在 Dog 类中复用 Animal 类的代码。

多态（Polymorphism）

概念

多态是指同一个操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。在面向对象编程中，多态通常通过方法重写（在子类中重新定义父类的方法）和方法重载（在同一个类中定义多个同名方法，但参数列表不同）来实现。这使得程序能够根据对象的实际类型来动态地决定调用哪个方法，增强了程序的灵活性和可扩展性。

示例

1.方法重写实现多态

继续以 “动物” 和 “狗” 为例。

class Animal:
    def sound(self):
        print("动物发出声音。")


class Dog(Animal):
    def sound(self):
        print("汪汪！")


class Cat(Animal):
    def sound(self):
        print("喵喵！")


def make_sound(animal):
    animal.sound()


animal1 = Animal()
animal2 = Dog("小黑")
animal3 = Cat("小花")

make_sound(animal1)
make_sound(animal2)
make_sound(animal3)

在这个例子中，Animal 类有一个 sound 方法，Dog 类和 Cat 类重写了这个方法。make_sound 函数接受一个 Animal 类型的对象，但根据传入对象的实际类型（是 Animal、Dog 还是 Cat），会调用相应的 sound 方法，这就是多态的体现。

2.方法重载实现多态（以 Java 为例）

class Calculator {
    int add(int num1, int num2) {
        return num1 + num2;
    }

    double add(double num1, double num2) {
        return num1 + num2;
    }
}

在这个 Java 例子中，Calculator 类中有两个 add 方法，一个用于计算两个整数相加，另一个用于计算两个双精度浮点数相加。这是通过方法重载实现的多态，根据传入参数的类型不同，会调用不同的 add 方法。

抽象（Abstraction）

概念

抽象是指将具有共同特征的事物提取出来，只关注对象的本质特征和行为，而忽略非本质的细节。在面向对象编程中，抽象可以通过抽象类和接口来实现。抽象类是一种不能被实例化的类，它可以包含抽象方法（只有方法声明，没有方法体）和具体方法。接口是一种特殊的抽象类，它只包含抽象方法，用于定义一组规范，实现接口的类必须实现接口中的所有方法。抽象有助于将复杂的系统分解为更简单、更易于理解和管理的部分。

示例

1.抽象类实现抽象

from abc import ABC, abstractmethod


class Shape(ABC):
    @abstractmethod
    def area(self):
        pass


class Rectangle(Shape):
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width


class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        import math
        return math.pi * (self.radius ** 2)

在这个 Python 例子中，Shape 是一个抽象类，它包含一个抽象方法 area。Rectangle 类和 Circle 类继承自 Shape 类，并实现了 area 方法。通过这种方式，抽象类 Shape 定义了一个计算形状面积的抽象概念，具体的形状类（如 Rectangle 和 Circle）实现了这个抽象概念。

2.接口实现抽象（以 Java 为例）

interface Printable {
    void print();
}

class Document implements Printable {
    @Override
    public void print() {
        System.out.println("打印文档。");
    }
}

class Photo implements Printable {
    @Override
    public void print() {
        System.out.println("打印照片。");
    }
}

在这个 Java 例子中，Printable 是一个接口，它定义了一个 print 方法。Document 类和 Photo 类实现了 Printable 接口，并且必须实现 print 方法。接口 Printable 抽象出了一个可打印的概念，实现这个接口的类具体定义了如何打印不同类型的对象。

小白路漫漫，让我们一起加油！！！