设计模式（Design Patterns）是软件开发中解决常见问题的通用解决方案。它们提供了一种标准化的方法来处理特定类型的问题，从而提高了代码的可维护性、可扩展性和复用性。以下是常见的设计模式及其在Java项目中的应用。
1. 创建型模式（Creational Patterns）
这些模式主要关注对象的创建机制，提供了灵活的方式来创建对象，而不是直接使用构造函数。
1.1 单例模式（Singleton Pattern）
确保一个类只有一个实例，并提供一个全局访问点。
- 应用场景：日志记录器、配置管理器等需要唯一实例的地方。
- 实现方式： \\\`java public 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; } } \\\`
1.2 工厂方法模式（Factory Method Pattern）
定义一个用于创建对象的接口，但由子类决定实例化哪一个类。
- 应用场景：当一个类不知道它所必须创建的对象的类的时候。
- 实现方式： \\\`java interface Product { void use(); }
class ConcreteProduct implements Product { public void use() { System.out.println("Using ConcreteProduct"); } }
abstract class Creator { public abstract Product factoryMethod(); public void doSomething() { Product product = factoryMethod(); product.use(); } }
class ConcreteCreator extends Creator { public Product factoryMethod() { return new ConcreteProduct(); } } \\\`
1.3 抽象工厂模式（Abstract Factory Pattern）
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。
- 应用场景：当需要一组相关的对象时。
- 实现方式： \\\`java interface GUIFactory { Button createButton(); }
interface Button { void paint(); }
class WinFactory implements GUIFactory { public Button createButton() { return new WinButton(); } }
class MacFactory implements GUIFactory { public Button createButton() { return new MacButton(); } }
class WinButton implements Button { public void paint() { System.out.println("I'm a Windows button"); } }
class MacButton implements Button { public void paint() { System.out.println("I'm a Mac button"); } } \\\`
1.4 建造者模式（Builder Pattern）
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
- 应用场景：当对象的构建过程非常复杂时。
- 实现方式： \\\`java class MealBuilder { Meal meal = new Meal();
public MealBuilder addBurger(String burger) { meal.addItem(new Burger(burger)); return this; }
public MealBuilder addDrink(String drink) { meal.addItem(new Drink(drink)); return this; }
public Meal build() { return meal; } } \\\`
1.5 原型模式（Prototype Pattern）
通过复制现有对象来创建新对象，而不是通过常规的构造函数。
- 应用场景：当创建对象的成本较高时。
- 实现方式： \\\`java class Prototype implements Cloneable { private String value;
public Prototype(String value) { this.value = value; }
@Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } } \\\`
2. 结构型模式（Structural Patterns）
这些模式关注类和对象的组合，主要用于简化复杂的结构。
2.1 适配器模式（Adapter Pattern）
将一个类的接口转换成客户希望的另一个接口。
- 应用场景：使两个不兼容的接口能够一起工作。
- 实现方式： \\\`java interface Target { void request(); }
class Adaptee { public void specificRequest() { System.out.println("Specific Request"); } }
class Adapter implements Target { private Adaptee adaptee;
public Adapter(Adaptee adaptee) { this.adaptee = adaptee; }
public void request() { adaptee.specificRequest(); } } \\\`
2.2 桥接模式（Bridge Pattern）
将抽象部分与它的实现部分分离，使它们都可以独立变化。
- 应用场景：当不希望因为实现细节的变化而修改抽象部分时。
- 实现方式： \\\`java interface Implementor { void operationImpl(); }
class ConcreteImplementorA implements Implementor { public void operationImpl() { System.out.println("ConcreteImplementorA"); } }
abstract class Abstraction { protected Implementor implementor;
public void setImplementor(Implementor implementor) { this.implementor = implementor; }
public abstract void operation(); }
class RefinedAbstraction extends Abstraction { public void operation() { implementor.operationImpl(); } } \\\`
2.3 组合模式（Composite Pattern）
将对象组合成树形结构以表示“部分-整体”的层次结构。
- 应用场景：文件系统、图形界面组件等。
- 实现方式： \\\`java interface Component { void operation(); }
class Leaf implements Component { public void operation() { System.out.println("Leaf operation"); } }
class Composite implements Component { private List children = new ArrayList<>();
public void add(Component component) { children.add(component); }
public void remove(Component component) { children.remove(component); }
public void operation() { for (Component child : children) { child.operation(); } } } \\\`
2.4 装饰器模式（Decorator Pattern）
动态地给一个对象添加一些额外的职责。
- 应用场景：需要在运行时为对象添加功能时。
- 实现方式： \\\`java abstract class Component { public abstract void operation(); }
class ConcreteComponent extends Component { public void operation() { System.out.println("ConcreteComponent operation"); } }
abstract class Decorator extends Component { protected Component component;
public Decorator(Component component) { this.component = component; }
public void operation() { component.operation(); } }
class ConcreteDecoratorA extends Decorator { public ConcreteDecoratorA(Component component) { super(component); }
public void operation() { super.operation(); addedBehavior(); }
private void addedBehavior() { System.out.println("Added behavior A"); } } \\\`
2.5 外观模式（Facade Pattern）
为子系统中的一组接口提供一个一致的界面。
- 应用场景：简化复杂系统的接口。
- 实现方式： \\\`java class SubsystemA { public void methodA() { System.out.println("SubsystemA methodA"); } }
class SubsystemB { public void methodB() { System.out.println("SubsystemB methodB"); } }
class Facade { private SubsystemA subsystemA = new SubsystemA(); private SubsystemB subsystemB = new SubsystemB();
public void operation() { subsystemA.methodA(); subsystemB.methodB(); } } \\\`
2.6 享元模式（Flyweight Pattern）
通过共享技术有效地支持大量细粒度的对象。
- 应用场景：当需要大量相似对象时。
- 实现方式： \\\`java class FlyweightFactory { private Map
public Flyweight getFlyweight(String key) { if (!flyweights.containsKey(key)) { flyweights.put(key, new ConcreteFlyweight(key)); } return flyweights.get(key); } }
interface Flyweight { void operation(String extrinsicState); }
class ConcreteFlyweight implements Flyweight { private String intrinsicState;
public ConcreteFlyweight(String intrinsicState) { this.intrinsicState = intrinsicState; }
public void operation(String extrinsicState) { System.out.println(intrinsicState + " " + extrinsicState); } } \\\`
3. 行为型模式（Behavioral Patterns）
这些模式关注对象之间的责任分配，主要用于描述对象之间的交互。
3.1 策略模式（Strategy Pattern）
定义一系列算法，把它们一个个封装起来，并且使它们可以互相替换。
- 应用场景：当需要在运行时选择算法时。
- 实现方式： \\\`java interface Strategy { void execute(); }
class ConcreteStrategyA implements Strategy { public void execute() { System.out.println("Executing strategy A"); } }
class Context { private Strategy strategy;
public void setStrategy(Strategy strategy) { this.strategy = strategy; }
public void executeStrategy() { strategy.execute(); } } \\\`
3.2 观察者模式（Observer Pattern）
定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。
- 应用场景：事件驱动系统。
- 实现方式： \\\`java interface Observer { void update(String message); }
class ConcreteObserver implements Observer { private String name;
public ConcreteObserver(String name) { this.name = name; }
public void update(String message) { System.out.println(name + " received: " + message); } }
interface Subject { void registerObserver(Observer observer); void notifyObservers(String message); }
class ConcreteSubject implements Subject { private List observers = new ArrayList<>();
public void registerObserver(Observer observer) { observers.add(observer); }
public void notifyObservers(String message) { for (Observer observer : observers) { observer.update(message); } } } \\\`
3.3 命令模式（Command Pattern）
将请求封装成对象，从而使你可以用不同的请求对客户进行参数化。
- 应用场景：命令队列、日志记录等。
- 实现方式： \\\`java interface Command { void execute(); }
class ConcreteCommand implements Command { private Receiver receiver;
public ConcreteCommand(Receiver receiver) { this.receiver = receiver; }
public void execute() { receiver.action(); } }
class Receiver { public void action() { System.out.println("Receiver action"); } }
class Invoker { private Command command;
public void setCommand(Command command) { this.command = command; }
public void invoke() { command.execute(); } } \\\`
3.4 迭代器模式（Iterator Pattern）
提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露其内部表示。
- 应用场景：遍历集合。
- 实现方式： \\\`java interface Iterator { boolean hasNext(); Object next(); }
interface Container { Iterator getIterator(); }
class MyContainer implements Container { private List list = new ArrayList<>();
public void add(Object obj) { list.add(obj); }
public Iterator getIterator() { return new MyIterator(); }
private class MyIterator implements Iterator { private int index = 0;
public boolean hasNext() { return index < list.size(); }
public Object next() { return list.get(index++); } } } \\\`
3.5 中介者模式（Mediator Pattern）
用一个中介对象来封装一系列的对象交互。
- 应用场景：多个对象之间复杂的交互。
- 实现方式： \\\`java interface Mediator { void send(String message, Colleague colleague); }
class ConcreteMediator implements Mediator { private ColleagueA colleagueA; private ColleagueB colleagueB;
public void setColleagueA(ColleagueA colleagueA) { this.colleagueA = colleagueA; }
public void setColleagueB(ColleagueB colleagueB) { this.colleagueB = colleagueB; }
public void send(String message, Colleague colleague) { if (colleague == colleagueA) { colleagueB.notify(message); } else { colleagueA.notify(message); } } }
abstract class Colleague { protected Mediator mediator;
public Colleague(Mediator mediator) { this.mediator = mediator; }
public abstract void send(String message); public abstract void notify(String message); }
class ColleagueA extends Colleague { public ColleagueA(Mediator mediator) { super(mediator); }
public void send(String message) { mediator.send(message, this); }
public void notify(String message) { System.out.println("ColleagueA received: " + message); } }
class ColleagueB extends Colleague { public ColleagueB(Mediator mediator) { super(mediator); }
public void send(String message) { mediator.send(message, this); }
public void notify(String message) { System.out.println("ColleagueB received: " + message); } } \\\`
3.6 备忘录模式（Memento Pattern）
在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
- 应用场景：撤销操作。
- 实现方式： \\\`java class Originator { private String state;
public void setState(String state) { this.state = state; }
public String getState() { return state; }
public Memento saveStateToMemento() { return new Memento(state); }
public void getStateFromMemento(Memento memento) { state = memento.getState(); } }
class Memento { private String state;
public Memento(String state) { this.state = state; }
public String getState() { return state; } }
class Caretaker { private Memento memento;
public void setMemento(Memento memento) { this.memento = memento; }
public Memento getMemento() { return memento; } } \\\`
3.7 访问者模式（Visitor Pattern）
表示一个作用于某对象结构中的各元素的操作。
- 应用场景：当需要对不同类型的对象执行相同的操作时。
- 实现方式： \\\`java interface Element { void accept(Visitor visitor); }
class ConcreteElementA implements Element { public void accept(Visitor visitor) { visitor.visit(this); }
public void operationA() { System.out.println("ConcreteElementA operationA"); } }
class ConcreteElementB implements Element { public void accept(Visitor visitor) { visitor.visit(this); }
public void operationB() { System.out.println("ConcreteElementB operationB"); } }
interface Visitor { void visit(ConcreteElementA element); void visit(ConcreteElementB element); }
class ConcreteVisitor implements Visitor { public void visit(ConcreteElementA element) { element.operationA(); }
public void visit(ConcreteElementB element) { element.operationB(); } } \\\`
总结
设计模式可以帮助你编写更清晰、更易维护的代码。在实际项目中，选择合适的设计模式取决于具体的需求和上下文。理解每种模式的优缺点，并根据实际情况灵活运用，是提高代码质量的关键。
