设计模式是面向对象编程中一种解决特定问题的通用方案。它并不是直接可以用来复制的代码而是解决问题的思路和结构框架。在这篇博客中我们将详细讨论几种常见的设计模式单例模式、工厂模式简单工厂、工厂方法、抽象工厂、策略模式和责任链模式。1. 单例模式Singleton Pattern定义单例模式是一种创建型设计模式旨在确保一个类只有一个实例并提供一个全局的访问点来获取该实例。优缺点优点确保系统中该类只有一个实例。提供全局访问点便于管理资源。缺点不容易进行单元测试。难以扩展如果需要增加多个实例就不适用了。典型代码饿汉式Eager Singletonpublic class Singleton { // 类加载时就创建实例 private static final Singleton instance new Singleton(); private Singleton() {} public static Singleton getInstance() { return instance; } }懒汉式Lazy Singletonpublic class Singleton { private static volatile Singleton instance; private Singleton() {} public static Singleton getInstance() { if (instance null) { synchronized (Singleton.class) { if (instance null) { instance new Singleton(); } } } return instance; } }使用代码public class Main { public static void main(String[] args) { Singleton singleton1 Singleton.getInstance(); Singleton singleton2 Singleton.getInstance(); System.out.println(singleton1 singleton2); // 输出 true } }2. 工厂模式Factory Pattern工厂模式属于创建型设计模式主要用于定义一个创建对象的接口让子类决定实例化哪个类。工厂方法把类的实例化推迟到子类。简单工厂模式Simple Factory定义简单工厂模式通过一个工厂类来创建不同类型的对象。工厂类根据传入的参数决定实例化哪一个产品类。优缺点优点简化了对象的创建过程。客户端不需要了解对象的创建过程只需提供输入参数。缺点增加新的产品时需要修改工厂类违背了开放-封闭原则。典型代码public class Product { public void show() { System.out.println(Product created!); } } public class SimpleFactory { public static Product createProduct() { return new Product(); } }使用代码public class Main { public static void main(String[] args) { Product product SimpleFactory.createProduct(); product.show(); } }工厂方法模式Factory Method定义工厂方法模式通过定义一个接口来创建对象由子类来决定实例化哪一个类。与简单工厂不同的是工厂方法不由工厂类来控制实例化过程。优缺点优点增加新产品时不需要修改已有代码符合开放-封闭原则。每个具体工厂类负责创建一个具体产品遵循单一职责原则。缺点如果产品种类较多工厂类数量也会增加导致类的数量激增。典型代码// 产品接口 public interface Product { void show(); } // 具体产品实现 public class ProductA implements Product { public void show() { System.out.println(ProductA created!); } } // 工厂接口 public interface Factory { Product createProduct(); } // 具体工厂 public class FactoryA implements Factory { public Product createProduct() { return new ProductA(); } }使用代码public class Main { public static void main(String[] args) { Factory factory new FactoryA(); Product product factory.createProduct(); product.show(); } }抽象工厂模式Abstract Factory定义抽象工厂模式提供一个接口用于创建相关或依赖对象的家族而无需明确指定具体类。抽象工厂模式通过创建多个工厂来创建相关对象。优缺点优点提供一个接口来创建一系列相关的对象客户端无需知道具体实现类。增加新的产品系列时只需要增加具体工厂类即可符合开放-封闭原则。缺点工厂类会增加系统复杂度上升。典型代码// 产品接口 public interface ProductA { void showA(); } public interface ProductB { void showB(); } // 具体产品 public class ProductA1 implements ProductA { public void showA() { System.out.println(ProductA1 created!); } } public class ProductB1 implements ProductB { public void showB() { System.out.println(ProductB1 created!); } } // 抽象工厂 public interface AbstractFactory { ProductA createProductA(); ProductB createProductB(); } // 具体工厂 public class ConcreteFactory1 implements AbstractFactory { public ProductA createProductA() { return new ProductA1(); } public ProductB createProductB() { return new ProductB1(); } }使用代码public class Main { public static void main(String[] args) { AbstractFactory factory new ConcreteFactory1(); ProductA productA factory.createProductA(); ProductB productB factory.createProductB(); productA.showA(); productB.showB(); } }3. 策略模式Strategy Pattern定义策略模式是一种行为型设计模式定义了一系列算法并将每个算法封装起来使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户端。优缺点优点客户端可以根据需要选择算法避免了大量的条件判断。新增算法时客户端不需要修改只需要新增策略类即可。缺点可能会增加系统中的类数过多的策略类会导致系统复杂度上升。典型代码// 策略接口 public interface Strategy { void execute(); } // 具体策略 public class StrategyA implements Strategy { public void execute() { System.out.println(Executing StrategyA); } } public class StrategyB implements Strategy { public void execute() { System.out.println(Executing StrategyB); } } // 上下文 public class Context { private Strategy strategy; public Context(Strategy strategy) { this.strategy strategy; } public void executeStrategy() { strategy.execute(); } }使用代码public class Main { public static void main(String[] args) { Strategy strategyA new StrategyA(); Context context new Context(strategyA); context.executeStrategy(); // 执行 StrategyA Strategy strategyB new StrategyB(); context new Context(strategyB); context.executeStrategy(); // 执行 StrategyB } }4. 责任链模式Chain of Responsibility Pattern定义责任链模式是一种行为型设计模式旨在避免请求发送者与多个请求处理者之间的耦合关系。通过链式传递能够将请求传递给不同的处理者直到一个处理者处理该请求。优缺点优点请求发送者不需要知道哪个处理者处理了请求解耦了发送者与处理者。可以动态地增加或删除处理者符合开放-封闭原则。缺点责任链的处理者如果设置不当可能导致请求无法得到处理。需要确保责任链中所有处理者的顺序和逻辑。典型代码// 抽象处理者 public abstract class Handler { protected Handler nextHandler; public void setNextHandler(Handler nextHandler) { this.nextHandler nextHandler; } public abstract void handleRequest(int request); } // 具体处理者 public class ConcreteHandlerA extends Handler { public void handleRequest(int request) { if (request 10) { System.out.println(HandlerA handling request request); } else if (nextHandler ! null) { nextHandler.handleRequest(request); } } } public class ConcreteHandlerB extends Handler { public void handleRequest(int request) { if (request 10) { System.out.println(HandlerB handling request request); } else if (nextHandler ! null) { nextHandler.handleRequest(request); } } }使用代码public class Main { public static void main(String[] args) { Handler handlerA new ConcreteHandlerA(); Handler handlerB new ConcreteHandlerB(); handlerA.setNextHandler(handlerB); handlerA.handleRequest(5); // HandlerA handling request 5 handlerA.handleRequest(15); // HandlerB handling request 15 } }