设计模式——七大常见设计原则

目录

单一职责原则（SRP）

开闭原则（OCP）

里氏替换原则（LSP）

依赖倒置原则（DIP）

接口隔离原则（ISP）

迪米特法则（LoDge）

合成复用原则（CRP）

    设计原则是一套经过长期实践总结的核心指导思想，旨在帮助开发者构建高内聚、低耦合、可复用、可扩展、易维护的软件系统。这些原则是设计模式的灵魂，多数设计模式都是针对某几个设计原则的具体实现的。

单一职责原则（SRP）

    核心定义：一个类（模块、函数）应该只有一个引起它变化的原因，即只负责一项明确的职责。

    本质：降低类的复杂度，避免“万能类”，减少修改带来的连锁反应。若一个类的职责过多，修改其中一个职责时，可能会破坏其他的功能。

//错误示例
public class Person {
    public void save(){}

    public void sendEmail(){}

    public void sing(){}
}

//正确示例，职责分离
public class PersonSave {
    public void save(){}
}
public class PersonEmail {
    public void sendEmail(){}
}
public class PersonSing {
    public void sing(){}
}

开闭原则（OCP）

    核心定义：软件实体应该对扩展开放，对修改关闭。

    本质：这是设计模式的核心目标，通过扩展避免修改原有的代码，降低引入bug的风险，同时提高系统的可扩展性。

//定义基础接口
public interface Person {
    void happy();
}

//具体实现
public class Cat implements Person {
    @Override
    public void happy() {
        System.out.println("喵喵喵");
    }
}
public class Dog implements Person {
    @Override
    public void happy() {
        System.out.println("汪汪汪");
    }
}

里氏替换原则（LSP）

    核心定义：所有引用基类（父类、抽象类）的地方，必须能透明地替换成子类的对象，且不会影响原来的程序。

    本质：子类不能破坏父类的行为约定。LSP是实现OCP的基础。

public class Bird {
    public void fly() {
        System.out.println("Bird is flying");
    }
}

// 错误示例：企鹅不能飞
public class Penguin extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Penguins can't fly");
    }
}

// 正确示例：重新设计继承关系
public abstract class Bird {
    public abstract void move();
}

public class FlyingBird extends Bird {
    @Override
    public void move() {
        System.out.println("Flying bird is flying");
    }
}

public class SwimmingBird extends Bird {
    @Override
    public void move() {
        System.out.println("Swimming bird is swimming");
    }
}

依赖倒置原则（DIP）

    核心定义：高层模块不能依赖低层模块，都应该依赖抽象。抽象不应该依赖细节，细节应该依赖抽象。

    本质：通过依赖抽象而非具体实现，降低模块间的耦合性。

// 抽象接口
public interface MessageService {
    void sendMessage(String message);
}

// 具体实现
public class EmailService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("Sending email: " + message);
    }
}

public class SMSService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("Sending SMS: " + message);
    }
}

// 高层模块依赖抽象
public class NotificationService {
    private MessageService messageService;
    
    public NotificationService(MessageService messageService) {
        this.messageService = messageService;
    }
    
    public void notify(String message) {
        messageService.sendMessage(message);
    }
}

接口隔离原则（ISP）

    核心定义：使用接口的类不应该被迫依赖不需要的方法，每个接口只包含客户端需要的方法。

    本质：避免接口污染，客户端实现接口时，需被迫实现用不到的方法，这样既增加冗余代码，又破坏单一职责。SRP针对“类的职责”，ISP针对“接口的方法粒度”。

// 错误示例：接口过于庞大
public interface Worker {
    void work();
    void eat();
    void sleep();
}

// 正确示例：接口分离
public interface Workable {
    void work();
}

public interface Eatable {
    void eat();
}

public interface Sleepable {
    void sleep();
}

public class Human implements Workable, Eatable, Sleepable {
    @Override
    public void work() { /* 工作 */ }
    
    @Override
    public void eat() { /* 吃饭 */ }
    
    @Override
    public void sleep() { /* 睡觉 */ }
}

public class Robot implements Workable {
    @Override
    public void work() { /* 工作 */ }
    // 只实现需要的接口
}

迪米特法则（LoDge）

    核心定义：一个对象应该对其他对象保持最少的了解。

    本质：降低对象间的耦合度，减少过度交互，若一个对象依赖过多的陌生对象，会导致关系复杂。

// 错误示例：暴露过多内部细节
public class Student {
    private String name;
    // getters and setters
}

public class Class {
    private List<Student> students;
    
    public List<Student> getStudents() {
        return students;
    }
}

public class School {
    private List<Class> classes;
    
    public void printAllStudents() {
        for (Class cls : classes) {
            for (Student student : cls.getStudents()) { // 违反迪米特法则
                System.out.println(student.getName());
            }
        }
    }
}

// 正确示例：封装内部细节
public class Class {
    private List<Student> students;
    
    public void printStudents() {
        for (Student student : students) {
            System.out.println(student.getName());
        }
    }
}

public class School {
    private List<Class> classes;
    
    public void printAllStudents() {
        for (Class cls : classes) {
            cls.printStudents(); // 只与直接朋友通信
        }
    }
}

合成复用原则（CRP）

    核心定义：优先使用合成或聚合实现代码复用，而不是优先使用继承。

    本质：避免继承的耦合问题，继承会让子类和父类绑定，而合成、聚合是弱耦合，一个类通过持有另一个类的实例来调用方法，避免继承的局限性。

// 错误示例：过度使用继承
public class Car {
    public void startEngine() { /* 启动引擎 */ }
    public void stopEngine() { /* 停止引擎 */ }
}

public class ElectricCar extends Car {
    // 继承了不必要的引擎方法
}

// 正确示例：使用组合
public class Engine {
    public void start() { /* 启动 */ }
    public void stop() { /* 停止 */ }
}

public class ElectricMotor {
    public void start() { /* 启动电机 */ }
    public void stop() { /* 停止电机 */ }
}

public class Car {
    private Engine engine;
    
    public Car(Engine engine) {
        this.engine = engine;
    }
    
    public void start() {
        engine.start();
    }
}