Java中常见的设计模式

Java 中有 23 种经典设计模式，通常被分为三大类：创建型、结构型和行为型。每个设计模式都解决了不同类型的设计问题。以下是几种常见设计模式的总结，并附带了实际应用场景、示例代码和详细的注释说明。

一、创建型设计模式

这些设计模式关注对象的创建方式，避免在代码中直接创建对象。

1. 单例模式（Singleton Pattern）

定义：
单例模式确保一个类只有一个实例，并提供一个全局的访问点来获取该实例。
应用场景：
常用于配置类、数据库连接池、日志类等。
示例代码：

public class Singleton {// 1. 声明一个私有静态实例变量private static Singleton instance;// 2. 私有构造方法，防止外部创建多个实例private Singleton() {}// 3. 提供公共的静态方法，返回唯一实例public static Singleton getInstance() {if (instance == null) {synchronized (Singleton.class) {  // 4. 双重检查锁定，确保线程安全if (instance == null) {instance = new Singleton();  // 5. 创建实例}}}return instance;  // 6. 返回单例实例}
}

解释：
通过private构造器防止外部创建多个实例。
使用getInstance()方法获取唯一的实例，采用双重锁定来保证线程安全。

2. 工厂模式（Factory Pattern）

定义：
工厂模式提供一个创建对象的接口，但由子类决定实例化哪一个类。它让客户端无需知道具体的实现类，就可以创建出所需的对象。
应用场景：
用于创建对象的场景，尤其是类的实例化非常复杂或需要根据不同条件创建不同的对象时。
示例代码：

// 1. 定义产品接口
public interface Animal {void sound();
}// 2. 具体产品类：Dog
public class Dog implements Animal {public void sound() {System.out.println("Woof!");}
}// 3. 具体产品类：Cat
public class Cat implements Animal {public void sound() {System.out.println("Meow!");}
}// 4. 工厂类，负责创建产品实例
public class AnimalFactory {public Animal createAnimal(String type) {if ("dog".equalsIgnoreCase(type)) {return new Dog();  // 5. 创建Dog对象} else if ("cat".equalsIgnoreCase(type)) {return new Cat();  // 6. 创建Cat对象}return null;  // 7. 返回null表示无法创建对象}
}// 8. 客户端代码
public class Client {public static void main(String[] args) {AnimalFactory factory = new AnimalFactory();  // 9. 创建工厂对象Animal dog = factory.createAnimal("dog");    // 10. 通过工厂创建Dog对象dog.sound();  // 11. 输出：Woof!Animal cat = factory.createAnimal("cat");    // 12. 通过工厂创建Cat对象cat.sound();  // 13. 输出：Meow!}
}

解释：
AnimalFactory负责根据参数创建不同的Animal类型对象，避免客户端直接依赖具体类。

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

定义：
抽象工厂模式提供一个接口，用来创建一系列相关或相互依赖的对象，而无需指定具体的类。
应用场景：
需要创建一系列相关的对象，而无需指定具体类。
用于产品族的创建，确保一系列相关的对象符合某种约定。
示例代码：

// 1. 定义抽象产品接口：ProductA
public interface ProductA {void doSomething();
}// 2. 具体产品A1
public class ProductA1 implements ProductA {public void doSomething() {System.out.println("ProductA1 does something");}
}// 3. 具体产品A2
public class ProductA2 implements ProductA {public void doSomething() {System.out.println("ProductA2 does something");}
}// 4. 定义抽象产品接口：ProductB
public interface ProductB {void doSomethingElse();
}// 5. 具体产品B1
public class ProductB1 implements ProductB {public void doSomethingElse() {System.out.println("ProductB1 does something else");}
}// 6. 具体产品B2
public class ProductB2 implements ProductB {public void doSomethingElse() {System.out.println("ProductB2 does something else");}
}// 7. 定义抽象工厂接口
public interface AbstractFactory {ProductA createProductA();ProductB createProductB();
}// 8. 具体工厂A1
public class ConcreteFactoryA1 implements AbstractFactory {public ProductA createProductA() {return new ProductA1();  // 9. 返回ProductA1}public ProductB createProductB() {return new ProductB1();  // 10. 返回ProductB1}
}// 10. 具体工厂A2
public class ConcreteFactoryA2 implements AbstractFactory {public ProductA createProductA() {return new ProductA2();  // 11. 返回ProductA2}public ProductB createProductB() {return new ProductB2();  // 12. 返回ProductB2}
}// 13. 客户端代码
public class Client {public static void main(String[] args) {AbstractFactory factory = new ConcreteFactoryA1();  // 14. 使用工厂A1ProductA productA = factory.createProductA();  // 15. 创建ProductAproductA.doSomething();  // 16. 输出：ProductA1 does somethingProductB productB = factory.createProductB();  // 17. 创建ProductBproductB.doSomethingElse();  // 18. 输出：ProductB1 does something else}
}

解释：
AbstractFactory定义了两个产品的创建方法，具体工厂实现不同产品的创建。
ConcreteFactoryA1和ConcreteFactoryA2根据需要创建一系列产品。

tips: Java中工厂模式和抽象工厂模式的区别

二、结构型设计模式

这些设计模式主要关注类和对象的组合，帮助我们设计灵活、易于扩展和维护的系统。

4. 适配器模式（Adapter Pattern）

定义：
适配器模式通过将一个类的接口转换成客户端期望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。
应用场景：
用于将一个类的接口转换为客户期望的另一个接口，常见于第三方库的集成时。
示例代码：

// 1. 目标接口
public interface Target {void request();
}// 2. 适配者类，已经存在的接口
public class Adaptee {public void specificRequest() {System.out.println("Specific request");}
}// 3. 适配器类，实现目标接口，并委托调用适配者的方法
public class Adapter implements Target {private Adaptee adaptee;public Adapter(Adaptee adaptee) {this.adaptee = adaptee;  // 4. 构造方法，传入适配者}public void request() {adaptee.specificRequest();  // 5. 调用适配者的特定方法}
}// 6. 客户端代码
public class Client {public static void main(String[] args) {Adaptee adaptee = new Adaptee();  // 7. 创建适配者对象Target target = new Adapter(adaptee);  // 8. 使用适配器target.request();  // 9. 输出：Specific request}
}

解释：
Target是客户期望的接口，Adaptee是已经存在的接口，通过Adapter类适配两者的差异。

5. 桥接模式（Bridge Pattern）

定义：
桥接模式通过将抽象部分和实现部分分离，使它们可以独立变化。它主要用于接口和实现的解耦。
应用场景：
用于将抽象部分与实现部分分离，使它们可以独立变化。常用于图形绘制、设备控制等场景。
示例代码：

// 1. 抽象类
public abstract class Shape {protected DrawingAPI drawingAPI;  // 2. 依赖抽象的实现类public Shape(DrawingAPI drawingAPI) {this.drawingAPI = drawingAPI;}public abstract void draw();  // 3. 抽象方法
}// 4. 具体形状类：Circle
public class Circle extends Shape {private double x, y, radius;public Circle(double x, double y, double radius, DrawingAPI drawingAPI) {super(drawingAPI);  // 5. 调用父类构造器，传入实现类this.x = x;this.y = y;this.radius = radius;}public void draw() {drawingAPI.drawCircle(x, y, radius);  // 6. 委托给实现类}
}// 7. 抽象实现类
public interface DrawingAPI {void drawCircle(double x, double y, double radius);  // 8. 绘制圆的方法
}// 9. 具体实现类：DrawingAPI1
public class DrawingAPI1 implements DrawingAPI {public void drawCircle(double x, double y, double radius) {System.out.println("Drawing Circle using DrawingAPI1 at (" + x + ", " + y + ") with radius " + radius);}
}// 10. 具体实现类：DrawingAPI2
public class DrawingAPI2 implements DrawingAPI {public void drawCircle(double x, double y, double radius) {System.out.println("Drawing Circle using DrawingAPI2 at (" + x + ", " + y + ") with radius " + radius);}
}// 11. 客户端代码
public class Client {public static void main(String[] args) {Shape shape1 = new Circle(1, 2, 3, new DrawingAPI1());  // 12. 使用API1shape1.draw();  // 13. 输出：Drawing Circle using DrawingAPI1 at (1, 2) with radius 3Shape shape2 = new Circle(4, 5, 6, new DrawingAPI2());  // 14. 使用API2shape2.draw();  // 15. 输出：Drawing Circle using DrawingAPI2 at (4, 5) with radius 6}
}

解释：
Shape类定义了抽象的draw()方法，依赖于DrawingAPI接口。
Circle类实现了具体的图形操作，将绘制行为委托给具体的实现类（DrawingAPI1或DrawingAPI2）。

三、行为型设计模式

6. 策略模式（Strategy Pattern）

定义：
策略模式定义了一系列算法，将每一个算法封装起来，并使它们可以互换。它让算法的变化独立于使用算法的客户。
应用场景：
策略模式用于定义一系列算法或策略，并允许在运行时切换策略。策略模式可以让你避免使用大量的 if-else 或 switch 语句来处理不同的行为。
示例代码：
假设你在开发一个支付系统，需要根据不同的支付方式（如支付宝、微信支付、信用卡支付）选择不同的支付策略。

// 策略接口，定义支付行为
interface PaymentStrategy {void pay(int amount);
}// 具体策略：支付宝支付
class AlipayPayment implements PaymentStrategy {@Overridepublic void pay(int amount) {System.out.println("Using Alipay to pay " + amount + " units.");}
}// 具体策略：微信支付
class WeChatPayment implements PaymentStrategy {@Overridepublic void pay(int amount) {System.out.println("Using WeChat to pay " + amount + " units.");}
}// 具体策略：信用卡支付
class CreditCardPayment implements PaymentStrategy {@Overridepublic void pay(int amount) {System.out.println("Using Credit Card to pay " + amount + " units.");}
}// 上下文类，持有一个策略对象
class PaymentContext {private PaymentStrategy paymentStrategy;// 设置支付策略public void setPaymentStrategy(PaymentStrategy paymentStrategy) {this.paymentStrategy = paymentStrategy;}// 执行支付public void executePayment(int amount) {paymentStrategy.pay(amount);}
}// 客户端代码
public class StrategyPatternExample {public static void main(String[] args) {// 创建上下文对象PaymentContext paymentContext = new PaymentContext();// 设置支付宝支付策略paymentContext.setPaymentStrategy(new AlipayPayment());paymentContext.executePayment(100);  // 输出: Using Alipay to pay 100 units.// 设置微信支付策略paymentContext.setPaymentStrategy(new WeChatPayment());paymentContext.executePayment(200);  // 输出: Using WeChat to pay 200 units.// 设置信用卡支付策略paymentContext.setPaymentStrategy(new CreditCardPayment());paymentContext.executePayment(300);  // 输出: Using Credit Card to pay 300 units.}
}

解释：
- PaymentStrategy 是一个策略接口，定义了支付方法。
- AlipayPayment、WeChatPayment、CreditCardPayment 是具体的支付策略，分别实现了 PaymentStrategy 接口。
- PaymentContext 类持有一个支付策略对象，并在运行时动态改变使用的支付策略。
- 在客户端代码中，使用不同的支付策略（支付宝、微信、信用卡）来执行支付。

7. 观察者模式（Observer Pattern）

定义：
观察者模式定义了对象间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会自动更新。
应用场景：
观察者模式用于一对多的场景，一个对象的状态改变时，所有依赖于它的对象都会得到通知并自动更新。比如在实现事件监听机制时，常常使用观察者模式。
示例代码：
假设你在开发一个天气预报系统，当天气变化时，所有的观察者（如显示板、手机应用等）都需要得到通知并更新天气信息。

import java.util.ArrayList;
import java.util.List;// 观察者接口，定义更新方法
interface Observer {void update(String weather);
}// 具体观察者：显示板
class DisplayBoard implements Observer {@Overridepublic void update(String weather) {System.out.println("DisplayBoard updated with weather: " + weather);}
}// 具体观察者：手机应用
class MobileApp implements Observer {@Overridepublic void update(String weather) {System.out.println("MobileApp updated with weather: " + weather);}
}// 被观察者：天气数据
class WeatherData {private List<Observer> observers = new ArrayList<>();private String weather;// 添加观察者public void addObserver(Observer observer) {observers.add(observer);}// 移除观察者public void removeObserver(Observer observer) {observers.remove(observer);}// 设置天气信息并通知所有观察者public void setWeather(String weather) {this.weather = weather;notifyObservers();}// 通知所有观察者更新private void notifyObservers() {for (Observer observer : observers) {observer.update(weather);}}
}// 客户端代码
public class ObserverPatternExample {public static void main(String[] args) {WeatherData weatherData = new WeatherData();// 创建观察者DisplayBoard displayBoard = new DisplayBoard();MobileApp mobileApp = new MobileApp();// 添加观察者weatherData.addObserver(displayBoard);weatherData.addObserver(mobileApp);// 改变天气信息，通知所有观察者weatherData.setWeather("Sunny");  // 输出: DisplayBoard updated with weather: Sunny// 输出: MobileApp updated with weather: Sunny// 修改天气信息，观察者会自动更新weatherData.setWeather("Rainy");  // 输出: DisplayBoard updated with weather: Rainy// 输出: MobileApp updated with weather: Rainy}
}

解释：
- Observer 是观察者接口，定义了 update 方法来接收通知。
- DisplayBoard 和 MobileApp 是具体的观察者，分别实现了 Observer 接口。
- WeatherData 是被观察者，保存了观察者的列表，并在天气变化时通知所有观察者。
- 在客户端代码中，当天气信息发生变化时，所有已注册的观察者都会接收到更新通知。

8. 命令模式（Command Pattern）

定义：
命令模式将请求封装为对象，从而使用户可以通过不同的请求对客户端进行参数化。
应用场景：
命令模式将请求封装成对象，从而使你可以用不同的请求、队列和日志来参数化其他对象。它通常用于需要进行操作的场景，尤其是按钮点击、任务调度等。
示例代码：
假设你在设计一个遥控器系统，每个按钮上绑定不同的命令操作（如开灯、关灯）。

// 命令接口，定义执行操作的方法
interface Command {void execute();
}// 具体命令：开灯命令
class TurnOnLightCommand implements Command {private Light light;public TurnOnLightCommand(Light light) {this.light = light;}@Overridepublic void execute() {light.turnOn();}
}// 具体命令：关灯命令
class TurnOffLightCommand implements Command {private Light light;public TurnOffLightCommand(Light light) {this.light = light;}@Overridepublic void execute() {light.turnOff();}
}// 接收者类：灯
class Light {public void turnOn() {System.out.println("The light is on.");}public void turnOff() {System.out.println("The light is off.");}
}// 调用者类：遥控器
class RemoteControl {private Command command;public void setCommand(Command command) {this.command = command;}public void pressButton() {command.execute();}
}// 客户端代码
public class CommandPatternExample {public static void main(String[] args) {Light light = new Light();Command turnOn = new TurnOnLightCommand(light);Command turnOff = new TurnOffLightCommand(light);RemoteControl remoteControl = new RemoteControl();// 按下开灯按钮remoteControl.setCommand(turnOn);remoteControl.pressButton();  // 输出: The light is on.// 按下关灯按钮remoteControl.setCommand(turnOff);remoteControl.pressButton();  // 输出: The light is off.}
}

解释：
- Command 是命令接口，定义了 execute 方法来执行具体操作。
- TurnOnLightCommand 和 TurnOffLightCommand 是具体命令类，实现了 Command 接口，封装了开灯和关灯操作。
- Light 是接收者类，实际执行开关灯操作。
- RemoteControl 是调用者类，接收命令并调用命令的 execute 方法。