编辑“︁设计模式原则”︁

= 设计模式原则 =

设计模式原则是面向对象编程中指导设计模式创建和应用的核心思想。这些原则帮助开发者编写可维护、可扩展和可复用的代码。理解这些原则是掌握设计模式的基础，也是成为优秀软件工程师的关键。

== 简介 ==

设计模式原则源于'''面向对象设计（OOD）'''的多年实践总结，最早由Robert C. Martin（又称Uncle Bob）提出，后由四人帮（GoF）在《设计模式》一书中系统化。这些原则不是具体的设计模式，而是设计模式背后的指导思想。

== SOLID原则 ==

SOLID是五个重要设计原则的首字母缩写：

=== 单一职责原则（Single Responsibility Principle, SRP） ===
一个类应该只有一个引起它变化的原因，即一个类只负责一项职责。

<syntaxhighlight lang="java">
// 违反SRP的例子
class User {
    void login() { /* 登录逻辑 */ }
    void sendEmail() { /* 发送邮件逻辑 */ }
}

// 遵循SRP的改进
class User {
    void login() { /* 登录逻辑 */ }
}

class EmailService {
    void sendEmail() { /* 发送邮件逻辑 */ }
}
</syntaxhighlight>

=== 开闭原则（Open-Closed Principle, OCP） ===
软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。

<syntaxhighlight lang="java">
// 违反OCP的例子
class Shape {
    String type;
    
    void draw() {
        if (type.equals("circle")) {
            drawCircle();
        } else if (type.equals("square")) {
            drawSquare();
        }
    }
}

// 遵循OCP的改进
interface Shape {
    void draw();
}

class Circle implements Shape {
    void draw() { /* 画圆 */ }
}

class Square implements Shape {
    void draw() { /* 画方形 */ }
}
</syntaxhighlight>

=== 里氏替换原则（Liskov Substitution Principle, LSP） ===
子类必须能够替换它们的基类而不引起程序错误。

<syntaxhighlight lang="java">
// 违反LSP的例子
class Bird {
    void fly() { /* 飞行 */ }
}

class Penguin extends Bird {
    void fly() {
        throw new UnsupportedOperationException("企鹅不会飞！");
    }
}

// 遵循LSP的改进
interface Bird {
    void move();
}

class FlyingBird implements Bird {
    void move() { fly(); }
    void fly() { /* 飞行 */ }
}

class Penguin implements Bird {
    void move() { swim(); }
    void swim() { /* 游泳 */ }
}
</syntaxhighlight>

=== 接口隔离原则（Interface Segregation Principle, ISP） ===
客户端不应该被迫依赖它们不使用的接口。

<syntaxhighlight lang="java">
// 违反ISP的例子
interface Worker {
    void work();
    void eat();
}

class Human implements Worker {
    void work() { /* 工作 */ }
    void eat() { /* 吃饭 */ }
}

class Robot implements Worker {
    void work() { /* 工作 */ }
    void eat() { throw new UnsupportedOperationException(); }
}

// 遵循ISP的改进
interface Workable {
    void work();
}

interface Eatable {
    void eat();
}

class Human implements Workable, Eatable {
    void work() { /* 工作 */ }
    void eat() { /* 吃饭 */ }
}

class Robot implements Workable {
    void work() { /* 工作 */ }
}
</syntaxhighlight>

=== 依赖倒置原则（Dependency Inversion Principle, DIP） ===
高层模块不应该依赖低层模块，二者都应该依赖抽象。

<syntaxhighlight lang="java">
// 违反DIP的例子
class LightBulb {
    void turnOn() { /* 开灯 */ }
}

class Switch {
    private LightBulb bulb;
    
    void operate() {
        bulb.turnOn();
    }
}

// 遵循DIP的改进
interface Switchable {
    void turnOn();
}

class LightBulb implements Switchable {
    void turnOn() { /* 开灯 */ }
}

class Switch {
    private Switchable device;
    
    void operate() {
        device.turnOn();
    }
}
</syntaxhighlight>

== 其他重要原则 ==

=== 组合优于继承原则（Composition Over Inheritance） ===
优先使用对象组合而不是类继承来复用代码。

<syntaxhighlight lang="java">
// 继承方式
class Bird {
    void fly() { /* 飞行 */ }
}

class Penguin extends Bird {
    // 企鹅不会飞，但继承了fly方法
}

// 组合方式
interface Flyable {
    void fly();
}

class FlyingBehavior implements Flyable {
    void fly() { /* 飞行 */ }
}

class Bird {
    private Flyable flyable;
    
    void setFlyable(Flyable f) { flyable = f; }
    void performFly() { flyable.fly(); }
}
</syntaxhighlight>

=== 迪米特法则（Law of Demeter, LoD） ===
一个对象应该对其他对象有最少的了解。

<syntaxhighlight lang="java">
// 违反LoD的例子
class Customer {
    Wallet wallet;
    
    Wallet getWallet() { return wallet; }
}

class Paperboy {
    void charge(Customer customer, float payment) {
        Wallet wallet = customer.getWallet();
        wallet.removeMoney(payment);
    }
}

// 遵循LoD的改进
class Customer {
    private Wallet wallet;
    
    void pay(float amount) {
        wallet.removeMoney(amount);
    }
}

class Paperboy {
    void charge(Customer customer, float payment) {
        customer.pay(payment);
    }
}
</syntaxhighlight>

== 实际应用案例 ==

'''案例：电商系统订单处理'''

<mermaid>
classDiagram
    class OrderProcessor {
        <<interface>>
        +processOrder()
    }
    
    class BasicOrderProcessor {
        +processOrder()
    }
    
    class DiscountOrderProcessor {
        -OrderProcessor processor
        +processOrder()
    }
    
    class TaxOrderProcessor {
        -OrderProcessor processor
        +processOrder()
    }
    
    OrderProcessor <|-- BasicOrderProcessor
    OrderProcessor <|-- DiscountOrderProcessor
    OrderProcessor <|-- TaxOrderProcessor
    DiscountOrderProcessor --> OrderProcessor
    TaxOrderProcessor --> OrderProcessor
</mermaid>

这个设计遵循了：
1. '''OCP'''：可以轻松添加新的订单处理器而不修改现有代码
2. '''DIP'''：高层模块依赖OrderProcessor抽象
3. '''SRP'''：每个处理器只负责一项功能

== 数学表达 ==

设计模式原则可以用数学方式表达其核心思想。例如，开闭原则可以表示为：

<math>
\forall f \in F, \exists e \in E : f' = f \circ e
</math>

其中：
- <math>F</math> 是软件实体集合
- <math>E</math> 是扩展行为集合
- <math>f'</math> 是扩展后的实体
- <math>\circ</math> 表示组合操作

== 总结 ==

设计模式原则是构建高质量软件的基础。掌握这些原则可以帮助开发者：
* 编写更易维护的代码
* 提高代码复用性
* 降低系统耦合度
* 增强系统扩展性

理解这些原则后，学习具体的设计模式会变得更加容易，因为所有设计模式都是这些原则的具体应用。

[[Category:计算机科学]]
[[Category:面试技巧]]
[[Category:设计模式]]