设计模式的概念--设计原则

##一、设计模式的基本原则

1. 单一职责原则（Single Responsibility Principle，SRP）： 一个类应该只有一个引起它变化的原因。每个类应该专注于单一的功能或责任。

// 不遵循SRP的例子
class Employee {
    void performTasks() {
        // 执行多种任务，包括计算工资和更新数据库
    }
}
// 遵循SRP的例子
class Employee {
    void performTasks() {
        // 执行员工相关任务
    }
}

2. 开闭原则（Open/Closed Principle，OCP）： 软件实体（类、模块、函数等）应该对扩展是开放的，但对修改是封闭的。在不修改现有代码的情况下，通过扩展来添加新功能。

// 不遵循OCP的例子
class Shape {
    void draw() {
        // 绘制通用形状
    }
}
class Circle extends Shape {
    void draw() {
        // 绘制圆形
    }
}
// 遵循OCP的例子
interface Drawable {
    void draw();
}
class Shape implements Drawable {
    @Override
    public void draw() {
        // 绘制通用形状
    }
}
class Circle implements Drawable {
    @Override
    public void draw() {
        // 绘制圆形
    }
}

3. 里氏替换原则（Liskov Substitution Principle，LSP）： 子类应该能够替换它们的基类，并且程序的行为不会受到影响。子类应该保持基类的行为规范。

// 不遵循LSP的例子
class Bird {
    void fly() {
        // 飞行
    }
}
class Ostrich extends Bird {
    void fly() {
        throw new UnsupportedOperationException("Ostriches can't fly");
    }
}
// 遵循LSP的例子
interface Bird {
    void move();
}
class Sparrow implements Bird {
    @Override
    public void move() {
        // 飞行
    }
}
class Ostrich implements Bird {
    @Override
    public void move() {
        // 跑步
    }
}

4. 依赖倒置原则（Dependency Inversion Principle，DIP）： 高层模块不应该依赖于低层模块，二者都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。

// 不遵循DIP的例子
class LightBulb {
    void turnOn() {
        // 打开灯泡
    }
}
class Switch {
    private LightBulb bulb;

    Switch() {
        bulb = new LightBulb();
    }

    void operate() {
        bulb.turnOn();
    }
}
// 遵循DIP的例子
interface Switchable {
    void turnOn();
}
class LightBulb implements Switchable {
    @Override
    public void turnOn() {
        // 打开灯泡
    }
}
class Switch {
    private Switchable device;

    Switch(Switchable device) {
        this.device = device;
    }

    void operate() {
        device.turnOn();
    }
}

5. 接口隔离原则（Interface Segregation Principle，ISP）： 不应该强迫客户端实现它们不需要的接口。客户端应该不依赖于它不使用的接口。

// 不遵循ISP的例子
interface Worker {
    void work();
    void eat();
}
class Manager implements Worker {
    @Override
    public void work() {
        // 管理工作
    }

    @Override
    public void eat() {
        // 吃饭
    }
}
// 遵循ISP的例子
interface Worker {
    void work();
}
interface Eater {
    void eat();
}
class Manager implements Worker, Eater {
    @Override
    public void work() {
        // 管理工作
    }

    @Override
    public void eat() {
        // 吃饭
    }
}

6. 合成/聚合复用原则（Composition/Aggregation Reuse Principle，CARP）： 优先使用组合（合成）和聚合，而不是继承来实现代码重用。通过对象组合建立更灵活的关系，减少类之间的耦合。

// 不遵循CARP的例子
class Engine {
    // 引擎实现
}
class Car extends Engine {
    // 汽车继承引擎，不利于复用
}
// 遵循CARP的例子
class Engine {
    // 引擎实现
}
class Car {
    private Engine engine;

    Car(Engine engine) {
        this.engine = engine;
    }
}

7. 迪米特法则（Law of Demeter，LoD）： 也被称为最少知识原则，一个模块不应该了解其他模块内部的太多细节。只与你的直接朋友交流，减少类之间的耦合。

// 不遵循LoD的例子
class TeamLeader {
    void assignTasks() {
        // 分配任务，直接和成员交流
    }
}
class TeamMember {
    void performTask() {
        // 执行任务
    }
}
// 遵循LoD的例子
class TeamLeader {
    void assignTasks(List<TeamMember> members) {
        // 分配任务，通过团队成员列表间接交流
    }
}
class TeamMember {
    void performTask() {
        // 执行任务
    }
}