阅读量:4
设计模式：编程中的智慧之道
设计模式是软件开发中的一种解决方案，提供了在特定上下文中解决常见问题的模板。这些模式帮助我们构建更加灵活、可维护和可扩展的系统。本文将探讨设计模式的不同类型及其在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实现，希望能为读者在实际开发中提供帮助。
