设计模式：编程中的智慧之道
设计模式是软件开发中的一种解决方案，提供了在特定上下文中解决常见问题的模板。这些模式帮助我们构建更加灵活、可维护和可扩展的系统。本文将探讨设计模式的不同类型及其在Java中的应用。
设计模式的层次
设计模式可以类比于道路的建造：如果你希望让十字路口更加安全，可以安装一些交通信号灯，或者修建包含行人地下通道在内的多层互通式立交桥。根据复杂程度、细节层次以及在系统中的应用范围，设计模式分为以下几类：
惯用技巧（Idioms）：最基础的、底层的模式，通常只能在一种编程语言中使用。例如，Java中的单例模式。
设计模式（Design Patterns）：通用的、高层次的模式，可以在多种编程语言中使用。例如，工厂模式、观察者模式等。
架构模式（Architectural Patterns）：最高层次的模式，适用于整个应用程序的架构设计。例如，MVC（模型-视图-控制器）模式、微服务架构。
设计模式的分类
设计模式可以根据其意图或目的来分类，主要分为以下三类：
创建型模式：提供创建对象的机制，增加已有代码的灵活性和可复用性。
结构型模式：介绍如何将对象和类组装成较大的结构，保持结构的灵活和高效。
行为模式：负责对象间的高效沟通和职责委派。
创建型模式
单例模式（Singleton Pattern）
单例模式确保一个类只有一个实例，并提供一个全局访问点。
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
工厂模式（Factory Pattern）
工厂模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。
public abstract class Product {
public abstract void use();
}
public class ConcreteProductA extends Product {
@Override
public void use() {
System.out.println("Using Product A");
}
}
public class ConcreteProductB extends Product {
@Override
public void use() {
System.out.println("Using Product B");
}
}
public abstract class Factory {
public abstract Product createProduct();
public Product getProduct() {
Product product = createProduct();
return product;
}
}
public class ConcreteFactoryA extends Factory {
@Override
public Product createProduct() {
return new ConcreteProductA();
}
}
public class ConcreteFactoryB extends Factory {
@Override
public Product createProduct() {
return new ConcreteProductB();
}
}
public class Client {
public static void main(String[] args) {
Factory factory = new ConcreteFactoryA();
Product product = factory.getProduct();
product.use();
}
}
结构型模式
适配器模式（Adapter Pattern）
适配器模式将一个类的接口转换成客户希望的另一个接口，使得原本因接口不兼容而无法一起工作的类可以协同工作。
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;
}
@Override
public void request() {
adaptee.specificRequest();
}
}
public class Client {
public static void main(String[] args) {
Adaptee adaptee = new Adaptee();
Target target = new Adapter(adaptee);
target.request();
}
}
装饰器模式（Decorator Pattern）
装饰器模式动态地将责任附加到对象上。若要扩展功能，装饰器提供了比继承更有弹性的替代方案。
public interface Component {
void operation();
}
public class ConcreteComponent implements Component {
@Override
public void operation() {
System.out.println("ConcreteComponent operation");
}
}
public class Decorator implements Component {
protected Component component;
public Decorator(Component component) {
this.component = component;
}
@Override
public void operation() {
component.operation();
}
}
public class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
@Override
public void operation() {
super.operation();
addedBehavior();
}
private void addedBehavior() {
System.out.println("ConcreteDecoratorA added behavior");
}
}
public class Client {
public static void main(String[] args) {
Component component = new ConcreteComponent();
Component decoratedComponent = new ConcreteDecoratorA(component);
decoratedComponent.operation();
}
}
行为模式
策略模式（Strategy Pattern）
策略模式定义了一系列算法，并将每个算法封装起来，使它们可以互换。
public interface Strategy {
void execute();
}
public class ConcreteStrategyA implements Strategy {
@Override
public void execute() {
System.out.println("Strategy A");
}
}
public class ConcreteStrategyB implements Strategy {
@Override
public void execute() {
System.out.println("Strategy B");
}
}
public class Context {
private Strategy strategy;
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public void executeStrategy() {
strategy.execute();
}
}
public class Client {
public static void main(String[] args) {
Context context = new Context();
context.setStrategy(new ConcreteStrategyA());
context.executeStrategy();
context.setStrategy(new ConcreteStrategyB());
context.executeStrategy();
}
}
观察者模式（Observer Pattern）
观察者模式定义对象间的一种一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。
import java.util.ArrayList;
import java.util.List;
public interface Observer {
void update(String message);
}
public class ConcreteObserver implements Observer {
private String name;
public ConcreteObserver(String name) {
this.name = name;
}
@Override
public void update(String message) {
System.out.println(name + " received message: " + message);
}
}
public class Subject {
private List<Observer> observers = new ArrayList<>();
public void attach(Observer observer) {
observers.add(observer);
}
public void detach(Observer observer) {
observers.remove(observer);
}
public void notifyObservers(String message) {
for (Observer observer : observers) {
observer.update(message);
}
}
}
public class Client {
public static void main(String[] args) {
Subject subject = new Subject();
Observer observer1 = new ConcreteObserver("Observer 1");
Observer observer2 = new ConcreteObserver("Observer 2");
subject.attach(observer1);
subject.attach(observer2);
subject.notifyObservers("Hello Observers");
}
}
结论
设计模式是软件开发中的重要工具，通过使用设计模式，开发者可以构建更加灵活、可维护和可扩展的系统。本文介绍了创建型模式、结构型模式和行为模式中的一些常用模式及其Java实现，希望能为读者在实际开发中提供帮助。
