常见的设计模式
单例/工厂比较常见，不写了
1. 原型模式（Prototype Pattern）
定义：通过复制现有对象来创建新对象的一种方式，而不是通过实例化类。
适用场景：
- 当一个系统应该独立于它的产品创建、构成和表示时。
- 要避免重复初始化的一些复杂对象。
示例代码：
import java.util.HashMap;
import java.util.Map;
// 原型接口
interface Prototype extends Cloneable {
Prototype clone();
}
// 具体原型类
class ConcretePrototype implements Prototype {
private String field;
public ConcretePrototype(String field) {
this.field = field;
}
public void setField(String field) {
this.field = field;
}
public String getField() {
return field;
}
@Override
public Prototype clone() {
return new ConcretePrototype(field);
}
}
// 客户端使用代码
public class PrototypePatternDemo {
public static void main(String[] args) {
ConcretePrototype prototype1 = new ConcretePrototype("Field1");
ConcretePrototype prototype2 = (ConcretePrototype) prototype1.clone();
System.out.println(prototype1.getField()); // 输出: Field1
System.out.println(prototype2.getField()); // 输出: Field1
}
}
2. 模版方法（Template Method）
定义：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模版方法使得子类可以不改变算法的结构即可重新定义该算法的某些步骤。
适用场景：
- 在多个子类中有公共的行为逻辑。
- 控制子类扩展。
示例代码：
// 抽象类，包含模板方法
abstract class AbstractClass {
// 模板方法
public final void templateMethod() {
primitiveOperation1();
primitiveOperation2();
concreteOperation();
}
// 基本方法（由子类实现）
protected abstract void primitiveOperation1();
protected abstract void primitiveOperation2();
// 具体方法
private void concreteOperation() {
System.out.println("Concrete Operation");
}
}
// 具体类
class ConcreteClass extends AbstractClass {
@Override
protected void primitiveOperation1() {
System.out.println("Primitive Operation 1");
}
@Override
protected void primitiveOperation2() {
System.out.println("Primitive Operation 2");
}
}
// 客户端代码
public class TemplateMethodPatternDemo {
public static void main(String[] args) {
AbstractClass abstractClass = new ConcreteClass();
abstractClass.templateMethod();
}
}
3. 策略模式（Strategy Pattern）
定义：定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换。本模式使得算法可独立于使用它的客户而变化。
适用场景：
- 需要在不同情况下使用不同的算法。
- 需要避免使用条件语句来选择算法。
示例代码：
// 策略接口
interface Strategy {
int doOperation(int num1, int num2);
}
// 具体策略类
class OperationAdd implements Strategy {
@Override
public int doOperation(int num1, int num2) {
return num1 + num2;
}
}
class OperationSubtract implements Strategy {
@Override
public int doOperation(int num1, int num2) {
return num1 - num2;
}
}
class OperationMultiply implements Strategy {
@Override
public 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);
}
}
// 客户端代码
public class StrategyPatternDemo {
public static void main(String[] args) {
Context context = new Context(new OperationAdd());
System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
context = new Context(new OperationSubtract());
System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
context = new Context(new OperationMultiply());
System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
}
}
4. 观察者模式（Observer Pattern）
定义：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
适用场景：
- 当一个对象的改变需要同时改变其他对象时。
- 当一个对象必须通知其他对象，而它又不能假定其他对象是谁时。
示例代码：
import java.util.ArrayList;
import java.util.List;
// 观察者接口
interface Observer {
void update(String message);
}
// 具体观察者类
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);
}
}
// 被观察者类
class Subject {
private List<Observer> observers = new ArrayList<>();
public void addObserver(Observer observer) {
observers.add(observer);
}
public void removeObserver(Observer observer) {
observers.remove(observer);
}
public void notifyObservers(String message) {
for (Observer observer : observers) {
observer.update(message);
}
}
}
// 客户端代码
public class ObserverPatternDemo {
public static void main(String[] args) {
Subject subject = new Subject();
Observer observer1 = new ConcreteObserver("Observer 1");
Observer observer2 = new ConcreteObserver("Observer 2");
subject.addObserver(observer1);
subject.addObserver(observer2);
subject.notifyObservers("Hello Observers!");
}
}
5. 代理模式（Proxy Pattern）
定义：为其他对象提供一种代理以控制对这个对象的访问。
适用场景：
- 需要控制对对象的访问。
- 需要在访问对象时附加额外的功能。
示例代码：
// 接口
interface RealSubject {
void request();
}
// 真实对象
class RealSubjectImpl implements RealSubject {
@Override
public void request() {
System.out.println("RealSubject Request");
}
}
// 代理对象
class Proxy implements RealSubject {
private RealSubject realSubject;
public Proxy(RealSubject realSubject) {
this.realSubject = realSubject;
}
@Override
public void request() {
System.out.println("Proxy: Pre-processing");
realSubject.request();
System.out.println("Proxy: Post-processing");
}
}
// 客户端代码
public class ProxyPatternDemo {
public static void main(String[] args) {
RealSubject realSubject = new RealSubjectImpl();
Proxy proxy = new Proxy(realSubject);
proxy.request();
}
}
6. 装饰者模式（Decorator Pattern）
定义：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰者模式比生成子类更为灵活。
适用场景：
- 需要扩展一个类的功能或给一个类增加附加功能。
- 需要动态地给一个对象添加功能。
示例代码：
// 组件接口
interface Component {
void operation();
}
// 具体组件
class ConcreteComponent implements Component {
@Override
public void operation() {
System.out.println("ConcreteComponent Operation");
}
}
// 装饰者抽象类
abstract class Decorator implements Component {
protected Component component;
public Decorator(Component component) {
this.component = component;
}
@Override
public void operation() {
component.operation();
}
}
// 具体装饰者
class ConcreteDecorator extends Decorator {
public ConcreteDecorator(Component component) {
super(component);
}
@Override
public void operation() {
super.operation();
addedFunction();
}
private void addedFunction() {
System.out.println("ConcreteDecorator Added Function");
}
}
// 客户端代码
public class DecoratorPatternDemo {
public static void main(String[] args) {
Component component = new ConcreteComponent();
Component decoratedComponent = new ConcreteDecorator(component);
decoratedComponent.operation();
}
}
7. 责任链模式（Chain of Responsibility Pattern）
定义：为解除请求的发送者和接收者之间的耦合，而使多个对象都有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。
适用场景：
- 有多个对象可以处理一个请求，但具体处理者未知。
- 需要动态指定处理者。
示例代码：
// 抽象处理者
abstract class Handler {
protected Handler successor;
public void setSuccessor(Handler successor) {
this.successor = successor;
}
public abstract void handleRequest(int request);
}
// 具体处理者
class ConcreteHandler1 extends Handler {
@Override
public void handleRequest(int request) {
if (request < 10) {
System.out.println("ConcreteHandler1 handled request " + request);
} else if (successor != null) {
successor.handleRequest(request);
}
}
}
class ConcreteHandler2 extends Handler {
@Override
public void handleRequest(int request) {
if (request >= 10 && request < 20) {
System.out.println("ConcreteHandler2 handled request " + request);
} else if (successor != null) {
successor.handleRequest(request);
}
}
}
// 客户端代码
public class ChainOfResponsibilityPatternDemo {
public static void main(String[] args) {
Handler handler1 = new ConcreteHandler1();
Handler handler2 = new ConcreteHandler2();
handler1.setSuccessor(handler2);
int[] requests = {5, 14, 22};
for (int request : requests) {
handler1.handleRequest(request);
}
}
}
8. 委托者模式（Delegator Pattern）
定义：委托者模式是一种将操作的实现委托给其他对象来处理的模式。
适用场景：
- 需要在不同对象间共享行为。
- 需要动态地改变对象的行为。
示例代码：
// 委托者接口
interface Printer {
void print(String message);
}
// 具体委托者
class RealPrinter implements Printer {
@Override
public void print(String message) {
System.out.println(message);
}
}
// 委托者
class PrinterDelegate {
private Printer printer;
public PrinterDelegate(Printer printer) {
this.printer = printer;
}
public void print(String message) {
printer.print(message);
}
}
// 客户端代码
public class DelegatorPatternDemo {
public static void main(String[] args) {
Printer realPrinter = new RealPrinter();
PrinterDelegate printerDelegate = new PrinterDelegate(realPrinter);
printerDelegate.print("Hello, Delegation!");
}
}
原文地址：https://blog.csdn.net/qq_38096989/article/details/140218453
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！