正文

揭秘编程新手必记：面向对象七大原则实用口诀，轻松掌握编程奥秘

/0 浏览量
1026

编程是一门艺术，而面向对象编程（OOP）是艺术的核心。作为编程新手，掌握面向对象七大原则，不仅能使你的代码更加整洁、易维护，还能让你在编程的道路上少走弯路。以下，我为你整理了这七大原则的实用口诀，让你轻松驾驭编程奥秘。

一、开闭原则（Closed for Modification, Open for Extension）

口诀：修修补补不改变，扩展功能很方便。

解析：开闭原则要求软件实体（类、模块等）对扩展开放，对修改封闭。也就是说，你可以随时为你的代码添加新的功能，而无需修改已有的代码。如何实现呢？通过抽象和接口来实现代码的模块化和解耦。

示例：

class Animal:
    def eat(self):
        pass

class Dog(Animal):
    def eat(self):
        print("狗狗吃东西")

class Cat(Animal):
    def eat(self):
        print("猫猫吃东西")

# 动物们都可以吃东西，但是具体怎么吃是由它们自己决定的。

二、里氏替换原则（Liskov Substitution Principle）

口诀：子类可代父类用，不变行为都一样。

解析：里氏替换原则要求任何基类可以出现的地方，其子类也可以出现。这确保了类的扩展不会破坏原有的行为。简单来说，就是子类应该能够继承并扩展父类，而不是改变它的行为。

示例：

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

    def get_area(self):
        return self.width * self.height

class Square(Rectangle):
    def __init__(self, side):
        super().__init__(side, side)

    def get_area(self):
        return self.width ** 2

# 一个Square对象可以被当作一个Rectangle对象来使用
square = Square(4)
print(square.get_area())  # 输出：16

三、依赖倒置原则（Dependence Inversion Principle）

口诀：高层不依赖低层，低层依赖高层层。

解析：依赖倒置原则要求在软件设计中，高层模块不应该依赖低层模块，两者都应该依赖抽象。具体来说，就是要多使用接口和抽象类，而不是具体类。

示例：

class Logger:
    def log(self, message):
        print(message)

class User:
    def __init__(self, logger):
        self.logger = logger

    def login(self, username, password):
        self.logger.log(f"用户{username}尝试登录")
        # ...登录逻辑...

logger = Logger()
user = User(logger)
user.login("admin", "123456")

四、接口隔离原则（Interface Segregation Principle）

口诀：接口要专一，不要一大堆。

解析：接口隔离原则要求接口要尽可能保持专一，不要把多个功能集中在同一个接口中。这样可以减少模块之间的依赖，提高模块的复用性。

示例：

class IOperationAdd:
    def add(self):
        pass

class IOperationMultiply:
    def multiply(self):
        pass

class Calculator:
    def __init__(self):
        self.add = IOperationAdd()
        self.multiply = IOperationMultiply()

    def calculate(self, x, y):
        self.add.add(x, y)
        self.multiply.multiply(x, y)

五、组合优于继承（Composition over Inheritance）

口诀：拼凑胜继承，结构更清晰。

解析：组合优于继承原则要求在设计中，优先考虑使用组合关系，而不是继承关系。组合可以创建更灵活、可扩展的系统。

示例：

class Engine:
    def run(self):
        print("引擎启动")

class Car:
    def __init__(self):
        self.engine = Engine()

    def drive(self):
        self.engine.run()
        print("车辆行驶")

car = Car()
car.drive()

六、单一职责原则（Single Responsibility Principle）

口诀：一个类一个责，不杂不乱好维护。

解析：单一职责原则要求一个类只负责一项功能，这样做的好处是易于测试和复用，同时也方便模块间的解耦。

示例：

class Logger:
    def log(self, message):
        print(message)

class UserService:
    def __init__(self, logger):
        self.logger = logger

    def register_user(self, user):
        self.logger.log(f"用户{user}注册成功")
        # ...注册逻辑...

logger = Logger()
user_service = UserService(logger)
user_service.register_user("admin")

七、迪米特法则（Law of Demeter）

口诀：相互协作要有限，尽量别太复杂乱。

解析：迪米特法则要求在软件实体之间建立松散的耦合关系。简单来说，就是减少实体之间的直接依赖，让它们通过接口进行通信。

示例：

class Customer:
    def __init__(self, order_service):
        self.order_service = order_service

    def order(self, product_id, quantity):
        self.order_service.place_order(product_id, quantity)

class OrderService:
    def place_order(self, product_id, quantity):
        print(f"为顾客下单，商品ID：{product_id}，数量：{quantity}")

order_service = OrderService()
customer = Customer(order_service)
customer.order("001", 1)

掌握了这七大面向对象原则，相信你的编程能力将得到质的提升。在未来的编程旅程中，祝你一路顺风，成为编程大师！

-- 展开阅读全文 --