Java中的主要设计模式

Java中的设计模式是一套被广泛认可的解决特定问题的解决方案。它们分为三大类：创建型模式、结构型模式和行为型模式。以下是一些常见的设计模式及其简要介绍和代码实现示例：

创建型模式

1. 单例模式（Singleton）： 确保一个类只有一个实例，并提供一个全局访问点。

   public class Singleton {private static Singleton instance;private Singleton() {}public static synchronized Singleton getInstance() {if (instance == null) {instance = new Singleton();}return instance;}
   }

2. 工厂方法模式（Factory Method）： 定义一个用于创建对象的接口，让子类决定实例化哪一个类。

   interface Product {void use();
   }class ConcreteProduct implements Product {public void use() {System.out.println("Using ConcreteProduct");}
   }abstract class Creator {abstract Product factoryMethod();
   }class ConcreteCreator extends Creator {public Product factoryMethod() {return new ConcreteProduct();}
   }

3. 建造者模式（Builder）： 用于创建一个复杂对象，同时允许用户只通过指定复杂对象的类型和内容就能构建它们。

   class Product {private String part1;private String part2;public static class Builder {private String part1;private String part2;public Builder setPart1(String part1) {this.part1 = part1;return this;}public Builder setPart2(String part2) {this.part2 = part2;return this;}public Product build() {return new Product(this.part1, this.part2);}}private Product(String part1, String part2) {this.part1 = part1;this.part2 = part2;}
   }

结构型模式

1. 适配器模式（Adapter）： 允许对象间的接口不兼容问题通过一个“适配器”来解决。

   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. 装饰器模式（Decorator）： 动态地给一个对象添加额外的职责。

   interface Component {void operate();
   }class ConcreteComponent implements Component {public void operate() {System.out.println("ConcreteComponent");}
   }abstract class Decorator implements Component {protected Component component;public Decorator(Component component) {this.component = component;}public void operate() {component.operate();}
   }class ConcreteDecoratorA extends Decorator {public ConcreteDecoratorA(Component component) {super(component);}public void operate() {super.operate();// Add additional behaviorSystem.out.println("ConcreteDecoratorA");}
   }

行为型模式

1. 策略模式（Strategy）： 定义一系列算法，把它们一个个封装起来，并使它们可互换。

   interface Strategy {void execute();
   }class ConcreteStrategyA implements Strategy {public void execute() {System.out.println("Strategy A");}
   }class Context {private Strategy strategy;public Context(Strategy strategy) {this.strategy = strategy;}public void executeStrategy() {strategy.execute();}
   }

2. 观察者模式（Observer）： 对象间的一对多依赖关系，当一个对象改变状态时，所有依赖于它的对象都会得到通知并自动更新。

   interface Observer {void update();
   }class ConcreteObserver implements Observer {public void update() {System.out.println("Observer updated");}
   }class Subject {private List<Observer> observers = new ArrayList<>();public void attach(Observer observer) {observers.add(observer);}public void notifyObservers() {for (Observer observer : observers) {observer.update();}}
   }