常见的设计模式

苟且.2024-07-06 11:58

单例/工厂比较常见，不写了

1. 原型模式（Prototype Pattern）

定义：通过复制现有对象来创建新对象的一种方式，而不是通过实例化类。

适用场景：

  • 当一个系统应该独立于它的产品创建、构成和表示时。
  • 要避免重复初始化的一些复杂对象。

示例代码：

java 复制代码 
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）

定义：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模版方法使得子类可以不改变算法的结构即可重新定义该算法的某些步骤。

适用场景：

  • 在多个子类中有公共的行为逻辑。
  • 控制子类扩展。

示例代码：

java 复制代码 
// 抽象类，包含模板方法
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）

定义：定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换。本模式使得算法可独立于使用它的客户而变化。

适用场景：

  • 需要在不同情况下使用不同的算法。
  • 需要避免使用条件语句来选择算法。

示例代码：

java 复制代码 
// 策略接口
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）

定义：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

适用场景：

  • 当一个对象的改变需要同时改变其他对象时。
  • 当一个对象必须通知其他对象，而它又不能假定其他对象是谁时。

示例代码：

java 复制代码 
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）

定义：为其他对象提供一种代理以控制对这个对象的访问。

适用场景：

  • 需要控制对对象的访问。
  • 需要在访问对象时附加额外的功能。

示例代码：

java 复制代码 
// 接口
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）

定义：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰者模式比生成子类更为灵活。

适用场景：

  • 需要扩展一个类的功能或给一个类增加附加功能。
  • 需要动态地给一个对象添加功能。

示例代码：

java 复制代码 
// 组件接口
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）

定义：为解除请求的发送者和接收者之间的耦合，而使多个对象都有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

适用场景：

  • 有多个对象可以处理一个请求，但具体处理者未知。
  • 需要动态指定处理者。

示例代码：

java 复制代码 
// 抽象处理者


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）

定义：委托者模式是一种将操作的实现委托给其他对象来处理的模式。

适用场景：

  • 需要在不同对象间共享行为。
  • 需要动态地改变对象的行为。

示例代码：

java 复制代码 
// 委托者接口
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!");
    }
}
相关推荐
wrx繁星点点6 小时前
状态模式（State Pattern）详解
java·开发语言·ui·设计模式·状态模式
金池尽干8 小时前
设计模式之——观察者模式
观察者模式·设计模式
也无晴也无风雨8 小时前
代码中的设计模式-策略模式
设计模式·bash·策略模式
捕鲸叉17 小时前
MVC（Model-View-Controller）模式概述
开发语言·c++·设计模式
wrx繁星点点17 小时前
享元模式：高效管理共享对象的设计模式
java·开发语言·spring·设计模式·maven·intellij-idea·享元模式
凉辰17 小时前
设计模式 策略模式 场景Vue （技术提升）
vue.js·设计模式·策略模式
菜菜-plus17 小时前
java设计模式之策略模式
java·设计模式·策略模式
暗黑起源喵17 小时前
设计模式-迭代器
设计模式
lexusv8ls600h19 小时前
微服务设计模式 - 网关路由模式（Gateway Routing Pattern）
spring boot·微服务·设计模式
sniper_fandc1 天前
抽象工厂模式
java·设计模式·抽象工厂模式
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解