设计模式需遵守：7 大基本原则

设计模式的 7 大基本原则

设计模式的 7 大基本原则是开发高质量软件的指导方针。这些原则帮助开发者创建更加灵活、可维护和可扩展的代码。

1. 单一职责原则 (Single Responsibility Principle, SRP)

定义

一个类应该只有一个引起它变化的原因。

说明

• 每个类应该只负责一项职责。
• 如果一个类承担的职责过多，就等于把这些职责耦合在一起。
• 一个职责的变化可能会削弱或抑制这个类完成其他职责的能力。

示例

// 不好的设计
class Employee {
    public void calculatePay() { /* ... */ }
    public void save() { /* ... */ }
    public void reportHours() { /* ... */ }
}

// 好的设计
class Employee {
    public void save() { /* ... */ }
}
class PayCalculator {
    public void calculatePay(Employee e) { /* ... */ }
}
class HourReporter {
    public void reportHours(Employee e) { /* ... */ }
}

2. 开放-封闭原则 (Open-Closed Principle, OCP)

定义

软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。

说明

• 当需要改变一个程序的功能或者给这个程序增加新功能的时候，可以使用增加代码的方式，但是不允许改动程序的源代码。

示例

// 开放-封闭原则的应用
interface Shape {
    double area();
}

class Rectangle implements Shape {
    // Rectangle implementation
}

class Circle implements Shape {
    // Circle implementation
}

// 新增形状不需要修改现有代码
class Triangle implements Shape {
    // Triangle implementation
}

3. 里氏替换原则 (Liskov Substitution Principle, LSP)

定义

子类型必须能够替换掉它们的父类型。

说明

• 子类可以扩展父类的功能，但不能改变父类原有的功能。
• 子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。

示例

class Bird {
    public void fly() { /* ... */ }
}

class Ostrich extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Ostriches can't fly");
    }
}
// 这违反了里氏替换原则，因为 Ostrich 不能替换 Bird

4. 接口隔离原则 (Interface Segregation Principle, ISP)

定义

客户端不应该依赖它不需要的接口。

说明

• 一个类对另一个类的依赖应该建立在最小的接口上。
• 使用多个专门的接口比使用单一的总接口要好。

示例

// 不好的设计
interface Worker {
    void work();
    void eat();
}

// 好的设计
interface Workable {
    void work();
}

interface Eatable {
    void eat();
}

class Human implements Workable, Eatable {
    // Implementation
}

class Robot implements Workable {
    // Implementation
}

5. 依赖倒置原则 (Dependency Inversion Principle, DIP)

定义

高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。

说明

• 依赖抽象而不是依赖具体实现。
• 针对接口编程，不要针对实现编程。

示例

// 依赖倒置原则的应用
interface Database {
    void save(String data);
}

class MySQLDatabase implements Database {
    public void save(String data) {
        // Save to MySQL
    }
}

class Application {
    private Database database;

    public Application(Database database) {
        this.database = database;
    }

    public void save(String data) {
        database.save(data);
    }
}

6. 迪米特法则 (Law of Demeter, LoD)

定义

一个对象应该对其他对象保持最少的了解。

说明

• 也称为最少知道原则。
• 一个类应该只与其直接的朋友通信。

示例

// 违反迪米特法则
class A {
    private B b;
    public void method() {
        C c = b.getC();
        c.doSomething();
    }
}

// 符合迪米特法则
class A {
    private B b;
    public void method() {
        b.doSomething();
    }
}

class B {
    private C c;
    public void doSomething() {
        c.doSomething();
    }
}

7. 合成复用原则 (Composite Reuse Principle, CRP)

定义

优先使用对象组合，而不是类继承。

说明

• 通过组合来达到复用的目的，而不是通过继承。
• 组合能够保持每个类的封装性，并且降低了类之间的耦合度。

示例

// 不推荐的方式
class Car extends Engine {
    // Car implementation
}

// 推荐的方式
class Car {
    private Engine engine;
    public Car(Engine engine) {
        this.engine = engine;
    }
    
    // Car implementation
}

结论

遵循这七大原则可以帮助我们设计出更加健壮、灵活和可维护的系统。然而，在实际应用中，这些原则并非绝对，有时可能需要权衡和取舍。重要的是理解每个原则背后的思想，并在适当的情况下应用它们。