Java开发者必知：23种设计模式深度解析与应用实战
一、引言
设计模式是软件开发中的一种经验总结，它可以帮助开发者解决在软件开发过程中遇到的一些常见问题。Java作为一种广泛应用于企业级开发的语言，拥有丰富的设计模式库。本文将深入解析Java中23种设计模式，并结合实际案例进行实战应用。
二、创建型模式
1. 单例模式（Singleton）
单例模式确保一个类只有一个实例，并提供一个全局访问点。在实际应用中，单例模式常用于管理全局资源，如数据库连接、文件读取等。
案例：使用单例模式管理数据库连接。
```java
public class DatabaseConnection {
private static DatabaseConnection instance;
private Connection connection;
private DatabaseConnection() {
connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "username", "password");
}
public static DatabaseConnection getInstance() {
if (instance == null) {
instance = new DatabaseConnection();
}
return instance;
}
public Connection getConnection() {
return connection;
}
}
```
2. 工厂方法模式（Factory Method）
工厂方法模式定义了一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
案例：使用工厂方法模式创建不同类型的交通工具。
```java
public interface Vehicle {
void run();
}
public class Car implements Vehicle {
public void run() {
System.out.println("Car is running...");
}
}
public class Bicycle implements Vehicle {
public void run() {
System.out.println("Bicycle is running...");
}
}
public class VehicleFactory {
public static Vehicle createVehicle(String type) {
if ("car".equals(type)) {
return new Car();
} else if ("bicycle".equals(type)) {
return new Bicycle();
}
return null;
}
}
```
3. 抽象工厂模式（Abstract Factory）
抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
案例：使用抽象工厂模式创建不同类型的电脑。
```java
public interface Computer {
void assemble();
}
public class DesktopComputer implements Computer {
public void assemble() {
System.out.println("Desktop Computer is assembling...");
}
}
public class LaptopComputer implements Computer {
public void assemble() {
System.out.println("Laptop Computer is assembling...");
}
}
public abstract class ComputerFactory {
public abstract Computer createComputer();
}
public class DesktopComputerFactory extends ComputerFactory {
public Computer createComputer() {
return new DesktopComputer();
}
}
public class LaptopComputerFactory extends ComputerFactory {
public Computer createComputer() {
return new LaptopComputer();
}
}
```
三、结构型模式
1. 适配器模式（Adapter）
适配器模式使对象接口兼容，允许将一个类的接口转换成客户期望的另一个接口。适配器模式分为对象适配器和类适配器。
案例：使用适配器模式将一个不兼容的接口转换为兼容的接口。
```java
public interface Target {
void request();
}
public class Adaptee {
public void specificRequest() {
System.out.println("Specific request.");
}
}
public class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
public void request() {
adaptee.specificRequest();
}
}
```
2. 桥接模式（Bridge）
桥接模式将抽象部分与实现部分分离，使它们都可以独立地变化。桥接模式适用于具有多个抽象类和实现类的系统。
案例：使用桥接模式创建一个具有不同显示效果和操作方式的文本编辑器。
```java
public interface Display {
void display();
}
public class TextDisplay implements Display {
public void display() {
System.out.println("Text Display");
}
}
public class ImageDisplay implements Display {
public void display() {
System.out.println("Image Display");
}
}
public class Editor {
private Display display;
public Editor(Display display) {
this.display = display;
}
public void show() {
display.display();
}
}
```
四、行为型模式
1. 职责链模式（Chain of Responsibility）
职责链模式将请求的发送者和接收者解耦，使得请求的发送者不需要知道具体的接收者是谁，发送者将请求沿着链传递，直到找到能够处理该请求的接收者。
案例：使用职责链模式处理不同类型的请求。
```java
public interface Handler {
void handle(String request);
}
public class ConcreteHandlerA implements Handler {
private Handler handler;
public ConcreteHandlerA(Handler handler) {
this.handler = handler;
}
public void handle(String request) {
if (request.equals("A")) {
System.out.println("Handler A handles request A.");
} else {
handler.handle(request);
}
}
}
public class ConcreteHandlerB implements Handler {
private Handler handler;
public ConcreteHandlerB(Handler handler) {
this.handler = handler;
}
public void handle(String request) {
if (request.equals("B")) {
System.out.println("Handler B handles request B.");
} else {
handler.handle(request);
}
}
}
```
2. 观察者模式（Observer）
观察者模式定义了对象间的一对多依赖关系，当一个对象改变状态时，所有依赖于它的对象都会得到通知并自动更新。
案例：使用观察者模式实现一个股票信息推送系统。
```java
public interface Observer {
void update(String info);
}
public class Stock implements Subject {
private List
public void addObserver(Observer observer) {
observers.add(observer);
}
public void removeObserver(Observer observer) {
observers.remove(observer);
}
public void notifyObservers(String info) {
for (Observer observer : observers) {
observer.update(info);
}
}
public void changeStock(String info) {
System.out.println("Stock changed: " + info);
notifyObservers(info);
}
}
public class StockObserver implements Observer {
public void update(String info) {
System.out.println("Stock observer received: " + info);
}
}
```
五、总结
本文深入解析了Java中的23种设计模式，并结合实际案例进行了实战应用。通过对设计模式的深入学习，可以帮助开发者提高代码质量、降低耦合度，从而提高软件开发的效率。在实际开发过程中，我们需要根据具体需求选择合适的设计模式，灵活运用，以实现最佳的开发效果。
