简单回顾

设计模式是什么：

设计模式是软件工程中常用的解决特定问题的经验总结。设计模式的选择取决于问题的性质和需求的特定情况。每种模式都有其优缺点，了解这些模式有助于开发人员更好地设计和构建可维护和可扩展的软件系统。

为什么要用设计模式：

提高代码的可维护性和可扩展性： 设计模式可以帮助你编写易于理解、易于修改和易于扩展的代码。通过遵循设计模式，你可以建立起一种共同的设计语言，使团队成员更容易理解彼此的代码，并且在未来的需求变更或功能扩展时更容易进行修改和扩展。
促进代码重用： 设计模式提供了经过验证的解决方案，可以用于解决常见的软件设计问题。通过使用设计模式，你可以避免重新发明轮子，并且能够利用已有的、经过测试的解决方案，从而提高代码的重用性。
增强代码的可读性： 设计模式通常具有良好的命名和结构，这使得代码更易于阅读和理解。当其他开发人员阅读你的代码时，他们可以更快地理解你的设计意图，并且更容易在其基础上进行进一步的开发或维护工作。
提高软件的灵活性和可靠性： 使用设计模式可以使软件更加灵活，能够更容易地适应变化和应对不同的需求。通过将通用的设计原则和最佳实践纳入到代码中，设计模式可以帮助你构建更加稳健和可靠的软件系统。
提高开发效率： 设计模式可以帮助你在开发过程中更快地做出决策，并且能够以更快的速度编写高质量的代码。通过使用设计模式，你可以避免陷入一些常见的设计陷阱，从而节省时间并降低开发成本。

创建型模式（Creational Patterns）：

处理对象创建机制，试图以适合的方式创建对象。主要包括：

1. 工厂方法模式（Factory Method Pattern）

- - 定义一个用于创建对象的接口，但由子类决定要实例化的类是哪一个。

2. 抽象工厂模式（Abstract Factory Pattern）

- - 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

3. 单例模式（Singleton Pattern）

- - 确保一个类只有一个实例，并提供全局访问点。

4. 建造者模式（Builder Pattern）

- - 将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

5. 原型模式（Prototype Pattern）

- - 通过复制现有对象来创建新对象，而不是通过实例化。

结构型模式（Structural Patterns）：

处理类和对象的组合，以形成更大的结构。主要包括：

1. 适配器模式（Adapter Pattern）

- - 将一个类的接口转换成客户希望的另一个接口。

2. 桥接模式（Bridge Pattern）

- - 将抽象部分与它的实现部分分离，使它们可以独立变化。

3. 装饰器模式（Decorator Pattern）

- - 动态地给一个对象添加一些额外的职责。

4. 组合模式（Composite Pattern）

- - 将对象组合成树形结构以表示“整体/部分”层次结构。

5. 外观模式（Facade Pattern）

- - 提供了一个统一的接口，用来访问子系统中的一群接口。

6. 享元模式（Flyweight Pattern）

- - 通过共享技术来有效地支持大量细粒度对象的复用。

7. 代理模式（Proxy Pattern）

- - 为其他对象提供一种代理以控制对这个对象的访问。

行为型模式（Behavioral Patterns）：

关注对象之间的通信，以及职责的分配。主要包括：

1. 模板方法模式（Template Method Pattern）

- - 定义一个操作中的算法的框架，而将一些步骤延迟到子类中。

2. 策略模式（Strategy Pattern）

- - 定义一系列算法，将每个算法封装起来，并使它们可以相互替换。

3. 观察者模式（Observer Pattern）

- - 定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都得到通知并自动更新。

4. 迭代器模式（Iterator Pattern）

- - 提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露其内部表示。

5. 责任链模式（Chain of Responsibility Pattern）

- - 将请求的发送者和接收者解耦，将多个对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

6. 命令模式（Command Pattern）

- - 将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化。

7. 状态模式（State Pattern）

- - 允许对象在其内部状态改变时改变它的行为。

8. 访问者模式（Visitor Pattern）

- - 在不改变对象结构的前提下，定义作用于对象结构中的各元素的操作。

9. 中介者模式（Mediator Pattern）

- - 用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显示地相互引用。

10. 解释器模式（Interpreter Pattern）

- - 给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

设计模式怎么让代码优雅示例

这次简单分享下 策略模式、适配器模式、抽象工厂模式、工厂方法模式几种常用的设计模式，怎么优化你的代码。

1. 策略模式 (Strategy Pattern)

旧的代码：

// 旧的代码中，存在大量的if-else语句，不易扩展和维护
public class PaymentProcessor {
    public void processPayment(String paymentMethod, double amount) {
        if (paymentMethod.equals("credit_card")) {
            System.out.println("Processing credit card payment of $" + amount);
            // 实际的支付处理逻辑
        } else if (paymentMethod.equals("paypal")) {
            System.out.println("Processing PayPal payment of $" + amount);
            // 实际的支付处理逻辑
        } else if (paymentMethod.equals("bitcoin")) {
            System.out.println("Processing Bitcoin payment of $" + amount);
            // 实际的支付处理逻辑
        } else {
            System.out.println("Unknown payment method: " + paymentMethod);
        }
    }
}

优化后的代码：

// 使用策略模式重构代码，将不同支付方式的处理逻辑封装成不同的策略类
public interface PaymentStrategy {
    void processPayment(double amount);
}

public class CreditCardPaymentStrategy implements PaymentStrategy {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing credit card payment of $" + amount);
        // 实际的支付处理逻辑
    }
}

public class PaypalPaymentStrategy implements PaymentStrategy {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing PayPal payment of $" + amount);
        // 实际的支付处理逻辑
    }
}

public class BitcoinPaymentStrategy implements PaymentStrategy {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing Bitcoin payment of $" + amount);
        // 实际的支付处理逻辑
    }
}

public class PaymentProcessor {
    private PaymentStrategy paymentStrategy;

    public PaymentProcessor(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void processPayment(double amount) {
        paymentStrategy.processPayment(amount);
    }
}

2. 适配器模式 (Adapter Pattern)

旧的代码：

// 旧的代码中，无法直接调用新的接口方法
public interface NewPaymentGateway {
    void processPayment(double amount);
}

public class NewPaymentGatewayImpl implements NewPaymentGateway {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing payment of $" + amount + " using new payment gateway");
        // 实际的支付处理逻辑
    }
}

public class PaymentGatewayAdapter {
    private NewPaymentGateway newPaymentGateway;

    public PaymentGatewayAdapter(NewPaymentGateway newPaymentGateway) {
        this.newPaymentGateway = newPaymentGateway;
    }

    public void processPayment(double amount) {
        // 在适配器中进行适配，调用新接口的方法
        newPaymentGateway.processPayment(amount);
    }
}

优化后的代码：

// 使用适配器模式优化代码，使得旧接口可以被直接调用
public interface OldPaymentGateway {
    void makePayment(double amount);
}

public class OldPaymentGatewayImpl implements OldPaymentGateway {
    @Override
    public void makePayment(double amount) {
        System.out.println("Making payment of $" + amount + " using old payment gateway");
        // 实际的支付处理逻辑
    }
}

public class NewToOldPaymentAdapter implements OldPaymentGateway {
    private NewPaymentGateway newPaymentGateway;

    public NewToOldPaymentAdapter(NewPaymentGateway newPaymentGateway) {
        this.newPaymentGateway = newPaymentGateway;
    }

    @Override
    public void makePayment(double amount) {
        // 在适配器中适配新接口的方法到旧接口
        newPaymentGateway.processPayment(amount);
    }
}

3. 工厂方法模式 (Factory Method Pattern)

旧的代码：

// 旧的代码中，工厂类负责创建具体产品的实例，导致需要修改工厂类来支持新产品
public interface Product {
    void operate();
}

public class ConcreteProductA implements Product {
    @Override
    public void operate() {
        System.out.println("Operating Concrete Product A");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void operate() {
        System.out.println("Operating Concrete Product B");
    }
}

public class ProductFactory {
    public Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        } else {
            throw new IllegalArgumentException("Unsupported product type: " + type);
        }
    }
}

优化后的代码：

// 使用工厂方法模式重构代码，将产品的创建延迟到子类中
public abstract class ProductFactory {
    public abstract Product createProduct();

    public void operateProduct() {
        Product product = createProduct();
        product.operate();
    }
}

public class ConcreteProductAFactory extends ProductFactory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

public class ConcreteProductBFactory extends ProductFactory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

设计模式小总结

简单回顾

设计模式是什么：

为什么要用设计模式：

创建型模式（Creational Patterns）：

1. 工厂方法模式（Factory Method Pattern）

2. 抽象工厂模式（Abstract Factory Pattern）

3. 单例模式（Singleton Pattern）

4. 建造者模式（Builder Pattern）

5. 原型模式（Prototype Pattern）

结构型模式（Structural Patterns）：

1. 适配器模式（Adapter Pattern）

2. 桥接模式（Bridge Pattern）

3. 装饰器模式（Decorator Pattern）

4. 组合模式（Composite Pattern）

5. 外观模式（Facade Pattern）

6. 享元模式（Flyweight Pattern）

7. 代理模式（Proxy Pattern）

行为型模式（Behavioral Patterns）：

1. 模板方法模式（Template Method Pattern）

2. 策略模式（Strategy Pattern）

3. 观察者模式（Observer Pattern）

4. 迭代器模式（Iterator Pattern）

5. 责任链模式（Chain of Responsibility Pattern）

6. 命令模式（Command Pattern）

7. 状态模式（State Pattern）

8. 访问者模式（Visitor Pattern）

9. 中介者模式（Mediator Pattern）

10. 解释器模式（Interpreter Pattern）

设计模式怎么让代码优雅示例

1. 策略模式 (Strategy Pattern)

旧的代码：

优化后的代码：

2. 适配器模式 (Adapter Pattern)

旧的代码：

优化后的代码：

3. 工厂方法模式 (Factory Method Pattern)

旧的代码：

优化后的代码：