掌握软件设计的秘诀：构建灵活可靠的代码之道

大家好，我是codeyang

接下来会和大家学习下程序员必备的知识设计模式，我将会结合自己的经验给大家分享。关注公众号codeyang

首先，什么是设计模式了～。设计模式是我们在软件开发时针对常见问题的通用解决方案并不是一种新的技术，也可以说是编程思想。它是前辈们不断实践后总结出来的解决方案，也就是我们说的套路。掌握了设计模式最直接的就是可以减少你的烂代码、提高开发效率、编写可维护的整洁高效的代码。

今天我们先来了解下软件设计的重要原则。

1.单一职责原则（Single Responsibility Principle）

定义：一个类或方法应该只负责单一的功能或任务。

通俗解释：就像一个人专注于做一件事情，一个类或方法也应该专注于完成一个具体的功能，不承担过多的责任。

例子：一个计算器类应该只负责进行数学计算，而不负责处理用户界面显示或数据持久化操作。

// 例子代码
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }

    // 其他计算操作...
}

2.开放封闭原则（Open-Closed Principle）

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

通俗解释：就像搭积木一样，我们可以添加新的积木来扩展功能，而不需要修改已有的积木块。

例子：一个图形绘制程序中，通过添加新的图形类来扩展支持的图形类型，而无需修改绘制程序的核心逻辑。

// 例子代码
public abstract class Shape {
    public abstract void draw();
}

public class Circle extends Shape {
    public void draw() {
        // 绘制圆形的逻辑...
    }
}

public class Rectangle extends Shape {
    public void draw() {
        // 绘制矩形的逻辑...
    }
}

// 在绘制程序中使用图形对象进行绘制
public class DrawingProgram {
    public void drawShape(Shape shape) {
        shape.draw();
    }
}

3.里氏替换原则（Liskov Substitution Principle）

定义：子类对象可以替换父类对象，而程序的行为不受影响。

通俗解释：就像不同品牌的手机可以使用相同的手机壳一样，子类对象可以在不影响程序功能的情况下替换父类对象。

例子：有一个父类Animal，子类有Dog和Cat，可以将Dog或Cat对象传递给接受Animal对象的方法，并正常运行。

// 例子代码
public class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

public class Dog extends Animal {
    public void makeSound() {
        System.out.println("狗发出汪汪的声音");
    }
}

public class Cat extends Animal {
    public void makeSound() {
        System.out.println("猫发出喵喵的声音");
    }
}

// 调用方法，接受Animal对象作为参数
public class AnimalSound {
    public void playSound(Animal animal) {
        animal.makeSound();
    }
}

4.依赖倒置原则（Dependency Inversion Principle）

定义：高层模块不应该依赖低层模块，二者都应该依赖于抽象接口。

通俗解释：就像人们与电源插座的关系，我们不依赖于特定类型的插头，而是依赖于标准的插座接口。

例子：一个电灯类不应该直接依赖于具体的电源接口，而是依赖于一个通用的电源接口，从而实现解耦和灵活性。

// 例子代码
public interface PowerSource {
    void turnOn();
    void turnOff();
}

public class ElectricPower implements PowerSource {
    public void turnOn() {
        // 打开电源的逻辑...
    }

    public void turnOff() {
        // 关闭电源的逻辑...
    }
}

public class Light {
    private PowerSource powerSource;

    public Light(PowerSource powerSource) {
        this.powerSource = powerSource;
    }

    public void turnOn() {
        powerSource.turnOn();
    }

    public void turnOff() {
        powerSource.turnOff();
    }
}

5. 接口隔离原则（Interface Segregation Principle）

定义：客户端不应该依赖于它不需要的接口。

通俗解释：就像人们使用电视遥控器，只需要用到开关、音量和频道调节的按钮，而不需要了解电视内部的复杂细节。

例子：一个用户界面类不应该直接实现多个功能接口，而是根据需要实现相应的接口，避免不必要的依赖和臃肿。

// 例子代码
public interface Switchable {
    void turnOn();
    void turnOff();
}

public interface VolumeAdjustable {
    void increaseVolume();
    void decreaseVolume();
}

public class Television implements Switchable, VolumeAdjustable {
    public void turnOn() {
        // 打开电视的逻辑...
    }

    public void turnOff() {
        // 关闭电视的逻辑...
    }

    public void increaseVolume() {
        // 增加音量的逻辑...
    }

    public void decreaseVolume() {
        // 减少音量的逻辑...
    }
}

6.迪米特法则（Law of Demeter）

定义：一个对象应该尽量少与其他对象发生相互作用，只与其直接的朋友发生交互。

通俗解释：就像人们通过中间人进行交流，而不是直接与陌生人交流一样，对象之间应该通过尽可能少的中间对象进行通信。

例子：一个订单类不应该直接调用库存管理类和用户管理类的方法，而是通过订单管理类进行中转。

// 例子代码
public class Order {
    private OrderManager orderManager;

    public void processOrder() {
        // 处理订单逻辑...
        orderManager.updateOrderStatus(this);
    }
}

public class OrderManager {
    private InventoryManager inventoryManager;
    private UserManager userManager;

    public void updateOrderStatus(Order order) {
        // 更新订单状态的逻辑...
        inventoryManager.updateInventory(order);
        userManager.notifyUser(order);
    }
}

7.组合/聚合复用原则（Composite/Aggregate Reuse Principle）

定义：优先使用组合和聚合关系，而不是继承关系，以达到代码复用的目的。

通俗解释：就像组装模型玩具一样，我们可以通过组合和聚合不同的部件来创建新的对象，而不是继承一个已有的对象。

例子：一个汽车类可以通过组合和聚合多个部件（发动机、轮胎、座椅等）来创建汽车对象，而不是继承已有的车型。

// 例子代码
public class Car {
    private Engine engine;
    private Tire[] tires;
    private Seat[] seats;

    // 构造函数和其他方法...
}

public class Engine {
    // 引擎相关的属性和方法...
}

public class Tire {
    // 轮胎相关的属性和方法...
}

public class Seat {
    // 座椅相关的属性和方法...
}

这些示例代码仅是用来说明加深理解，并不完整不可直接运行。也没有考虑所有的细节和实现。在实际开发中，根据具体情况进行适当的设计和实现。

好了，这次分享就到这。接下来我们逐个学习23个设计模式!✌️