单例模式（Singleton Pattern）
定义：确保一个类只有一个实例，并提供一个全局访问点。
原理：通过私有化构造函数和提供一个静态方法来获取实例。
优点：
- 控制实例数量：保证只有一个实例。
- 提供全局访问点：方便在全局范围内访问该实例。
// 单例类 public class Singleton { // 唯一实例 private static Singleton instance; // 私有构造函数，防止外部实例化 private Singleton() {} // 提供全局访问点 public static Singleton getInstance() { if (instance == null) { instance = new Singleton(); // 懒汉式加载 } return instance; } }
工厂方法模式（Factory Method Pattern）
定义：定义一个创建对象的接口，但由子类决定实例化哪个类。
原理：将对象的创建逻辑放在子类中，而不是在客户端代码中。
优点：
- 灵活性：可以在运行时决定创建对象的类型。
- 符合开闭原则：对扩展开放，对修改关闭。
// 产品接口 public interface Product { void operation(); } // 具体产品A public class ConcreteProductA implements Product { @Override public void operation() { System.out.println("ConcreteProductA operation"); } } // 具体产品B public class ConcreteProductB implements Product { @Override public void operation() { System.out.println("ConcreteProductB operation"); } } // 工厂接口 public abstract class Creator { public abstract Product factoryMethod(); } // 具体工厂A public class ConcreteCreatorA extends Creator { @Override public Product factoryMethod() { return new ConcreteProductA(); } } // 具体工厂B public class ConcreteCreatorB extends Creator { @Override public Product factoryMethod() { return new ConcreteProductB(); } } // 客户端代码 public class Client { public static void main(String[] args) { Creator creator = new ConcreteCreatorA(); Product product = creator.factoryMethod(); product.operation(); } }
抽象工厂模式（Abstract Factory Pattern）
定义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
原理：通过定义多个工厂接口，每个接口负责创建一组相关的对象。
优点：
- 一致性：确保创建的一系列对象具有一致性。
- 扩展性：易于扩展产品系列，而不影响现有代码。
// 产品A接口 public interface ProductA { void operationA(); } // 产品B接口 public interface ProductB { void operationB(); } // 具体产品A1 public class ConcreteProductA1 implements ProductA { @Override public void operationA() { System.out.println("ConcreteProductA1 operationA"); } } // 具体产品B1 public class ConcreteProductB1 implements ProductB { @Override public void operationB() { System.out.println("ConcreteProductB1 operationB"); } } // 具体产品A2 public class ConcreteProductA2 implements ProductA { @Override public void operationA() { System.out.println("ConcreteProductA2 operationA"); } } // 具体产品B2 public class ConcreteProductB2 implements ProductB { @Override public void operationB() { System.out.println("ConcreteProductB2 operationB"); } } // 抽象工厂接口 public interface AbstractFactory { ProductA createProductA(); ProductB createProductB(); } // 具体工厂1 public class ConcreteFactory1 implements AbstractFactory { @Override public ProductA createProductA() { return new ConcreteProductA1(); } @Override public ProductB createProductB() { return new ConcreteProductB1(); } } // 具体工厂2 public class ConcreteFactory2 implements AbstractFactory { @Override public ProductA createProductA() { return new ConcreteProductA2(); } @Override public ProductB createProductB() { return new ConcreteProductB2(); } } // 客户端代码 public class Client { public static void main(String[] args) { AbstractFactory factory = new ConcreteFactory1(); ProductA productA = factory.createProductA(); ProductB productB = factory.createProductB(); productA.operationA(); productB.operationB(); } }
观察者模式（Observer Pattern）
定义：定义对象之间的一对多依赖，使得当一个对象改变状态时，所有依赖于它的对象都得到通知并被自动更新。
原理：通过定义观察者接口和被观察者类来实现一对多的通知机制。
优点：
- 解耦：观察者和被观察者之间的解耦。
- 动态更新：自动更新所有观察者
import java.util.ArrayList; import java.util.List; // 观察者接口 public interface Observer { void update(String message); } // 被观察者接口 public interface Subject { void addObserver(Observer observer); void removeObserver(Observer observer); void notifyObservers(String message); } // 具体被观察者 public class ConcreteSubject implements Subject { private List<Observer> observers = new ArrayList<>(); @Override public void addObserver(Observer observer) { observers.add(observer); } @Override public void removeObserver(Observer observer) { observers.remove(observer); } @Override public void notifyObservers(String message) { for (Observer observer : observers) { observer.update(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); } } // 客户端代码 public class Client { public static void main(String[] args) { ConcreteSubject subject = new ConcreteSubject(); Observer observer1 = new ConcreteObserver("Observer1"); Observer observer2 = new ConcreteObserver("Observer2"); subject.addObserver(observer1); subject.addObserver(observer2); subject.notifyObservers("Hello Observers!"); } }
