面向对象 | 面向对象设计

什么是面向对象？

面向对象编程（Object Oriented Programming，OOP）是一种编程范式，其中数据和行为封装在对象中，并且对象之间可以相互通信和交互。在面向对象编程中，程序员将现实世界中的问题建模为对象和类，从而简化了编程流程、提高了代码的可维护性和可扩展性。

面向对象的四大特性

面向对象编程有四大特性，也称为四大支柱。

封装 Encapsulation

封装指的是将数据和行为封装在对象中，对外部世界隐藏其实现细节。这一特性提高了代码的安全性、可维护性和可扩展性。

例如：

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__score = None  # 外部无法访问 __score

    def set_score(self, score):
        if 0 <= score <= 100:
            self.__score = score  # 可以在类的内部访问 __score

    def get_score(self):
        return self.__score  # 外部无法访问 __score

s = Student("Tom", 20)
s.set_score(90)
print(s.get_score())  # 90
#print(s.__score)  # AttributeError: 'Student' object has no attribute '__score'

继承 Inheritance

继承允许我们创建一个新类，该新类继承了一个或多个现有类的属性和方法。继承允许程序员重复使用已经存在的代码，并在不破坏原有代码的情况下添加新的功能。

例如：

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

    def speak(self):
        print(f"{self.name} is speaking.")

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

    def speak(self):
        print(f"{self.name} ({self.breed}) is barking.")

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

    def speak(self):
        print(f"{self.name} ({self.color}) is meowing.")

d = Dog("Puppy", "Golden Retriever")
c = Cat("Kitty", "Grey")
d.speak()  # Puppy (Golden Retriever) is barking.
c.speak()  # Kitty (Grey) is meowing.

多态 Polymorphism

多态是指对象能够取多种形态，不同的对象可以对同一消息做出响应，从而实现类似于函数重载的功能。

例如：

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

    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Dog is barking.")

class Cat(Animal):
    def speak(self):
        print("Cat is meowing.")

def make_speak(animal):
    animal.speak()

d = Dog("Puppy")
c = Cat("Kitty")
make_speak(d)  # Dog is barking.
make_speak(c)  # Cat is meowing.

抽象 Abstraction

抽象是指将复杂的现实情况简化为一个或多个实体和其相互关系的模型，强调抓住问题的本质，简化模型，忽略不必要的细节。

例如：

from abc import ABC, abstractmethod

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

    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Dog is barking.")

class Cat(Animal):
    def speak(self):
        print("Cat is meowing.")

# a = Animal("Something")  # TypeError: Can't instantiate abstract class Animal with abstract methods speak.
d = Dog("Puppy")
c = Cat("Kitty")
d.speak()  # Dog is barking.
c.speak()  # Cat is meowing.

面向对象设计的基本原则

面向对象设计有五个基本原则，也称为 SOLID 原则。

单一职责原则 Single Responsibility Principle（SRP）

每个对象都应该只有一个职责，即只有一个引起它的变化的原因，从而实现高内聚和低耦合的目的。

开闭原则 Open-Closed Principle（OCP）

对于扩展是开放的，对于修改是封闭的。即在不修改现有代码的情况下，通过增加新功能来扩展原有代码的功能。

里氏替换原则 Liskov Substitution Principle（LSP）

子类对象能够替换其超类对象被使用。

依赖倒置原则 Dependency Inversion Principle（DIP）

高层模块不应该依赖低层模块，而是应该通过中间层进行联系，从而实现松耦合。

接口隔离原则 Interface Segregation Principle（ISP）

客户端不应该强制依赖于它不使用的方法，一个类对另一个类的依赖性应该建立在最小的接口上。

总结

面向对象编程是一种强大的编程范式，可以提高代码的可维护性和可扩展性。面向对象编程的四大特性分别是封装、继承、多态和抽象，面向对象设计的五个基本原则分别是单一职责原则、开闭原则、里氏替换原则、依赖倒置原则和接口隔离原则。