设计模式是软件开发中可重复使用的解决方案，它们getShape(String shapeType) {if (shapeType.equals("CIRCLE")) {return new Circle();} else if (shapeType.equals("SQUARE")) {return new Square();} else if (shapeType.equals("RECTANGLE")) {return new Rectangle();}return null;} }// 创建不同的形状对象 Shape circle = ShapeFactory.getShape("CIRCLE"); Shape square = ShapeFactory.getShape("SQUARE"); Shape rectangle = ShapeFactory.getShape("RECTANGLE");

单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点。它通常用于创建全局对象，如数据库连接或缓存。单例模式的优点是它简化了对象的实例化，并强制应用程序只能有一个该对象的实例。

// 创建一个单例类
class Singleton {private static Singleton instance = null;private Singleton() {}public static Singleton getInstance() {if (instance == null) {instance = new Singleton();}return instance;}
}// 获取单例对象
Singleton singleton = Singleton.getInstance();

代理模式

代理模式为另一个对象提供了一个代理或占位符。它控制对目标对象的访问，并可以提供附加功能，如安全性、并发控制或延迟加载。代理模式的优点是它可以隐藏目标对象的复杂性，并允许对目标对象进行更细粒度的控制。

// 创建一个代理类
class Proxy implements Subject {private Subject realSubject;public Proxy(Subject realSubject) {this.realSubject = realSubject;}@Overridepublic void request() {// 在调用目标对象之前或之后执行一些附加操作realSubject.request();}
}// 创建一个目标对象
class RealSubject implements Subject {@Overridepublic void request() {// 执行实际的操作}
}// 使用代理对象
Subject subject = new Proxy(new RealSubject());
subject.request();

适配器模式

适配器模式将一个类的接口转换成另一个类所期望的接口。它使原本不兼容的类可以一起工作。适配器模式的优点是它可以消除不兼容性问题，并使代码更容易重用。

// 创建一个适配器类
class Adapter implements Target {private Adaptee adaptee;public Adapter(Adaptee adaptee) {this.adaptee = adaptee;}@Overridepublic void request() {adaptee.specificRequest();}
}// 创建一个需要适配的对象
class Adaptee {public void specificRequest() {// 执行特定操作}
}// 使用适配器对象
Target target = new Adapter(new Adaptee());
target.request();

策略模式

策略模式定义了一组算法，并将它们封装为独立的对象。它允许客户在运行时选择和修改算法。策略模式的优点是它提供了一种灵活的方式来改变应用程序的行为，而无需修改客户端代码。

// 创建一个策略接口
interface Strategy {public int dOOPeration(int num1, int num2);
}// 创建具体的策略类
class AdditionStrategyimplements Strategy {@Overridepublic int doOperation(int num1, int num2) {return num1 + num2;}
}class SubtractionStrategy implements Strategy {@Overridepublic int doOperation(int num1, int num2) {return num1 - num2;}
}// 创建一个策略上下文类
class Context {private Strategy strategy;public Context(Strategy strategy) {this.strategy = strategy;}public int executeStrategy(int num1, int num2) {return strategy.doOperation(num1, num2);}
}// 使用不同的策略对象
Context context = new Context(new AdditionStrategy());
int result = context.executeStrategy(10, 5);context = new Context(new SubtractionStrategy());
result = context.executeStrategy(10, 5);

观察者模式

观察者模式定义了一对一的多对多依赖关系，其中一个对象（称为主题）保持一个依赖对象的列表（称为观察者）。当主题的状态发生变化时，它会通知所有观察者。观察者模式的优点是它允许对象松散耦合，并允许它们在不了解彼此的情况下进行通信。

// 创建一个主题接口
interface Subject {public void registerObserver(Observer observer);public void removeObserver(Observer observer);public void notifyObservers();
}// 创建一个具体的主题类
class ConcreteSubject implements Subject {private List observers = new ArrayList<>();@Overridepublic void registerObserver(Observer observer) {observers.add(observer);}@Overridepublic void removeObserver(Observer observer) {observers.remove(observer);}@Overridepublic void notifyObservers() {for (Observer observer : observers) {observer.update();}}
}// 创建一个观察者接口
interface Observer {public void update();
}// 创建一个具体的观察者类
class ConcreteObserver implements Observer {@Overridepublic void update() {// 根据主题的更新执行一些操作}
}// 使用观察者模式
Subject subject = new ConcreteSubject();
Observer observer = new ConcreteObserver();
subject.registerObserver(observer);subject.notifyObservers();

结论