常见的设计模式

苟且.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!");
    }
}
相关推荐
lxyzcm10 小时前
深入理解C++23的Deducing this特性（上）：基础概念与语法详解
开发语言·c++·spring boot·设计模式·c++23
越甲八千10 小时前
重温设计模式--单例模式
单例模式·设计模式
Vincent（朱志强）10 小时前
设计模式详解（十二）：单例模式——Singleton
android·单例模式·设计模式
诸葛悠闲11 小时前
设计模式——桥接模式
设计模式·桥接模式
捕鲸叉16 小时前
C++软件设计模式之外观（Facade）模式
c++·设计模式·外观模式
小小小妮子~16 小时前
框架专题：设计模式
设计模式·框架
先睡16 小时前
MySQL的架构设计和设计模式
数据库·mysql·设计模式
Damon_X1 天前
桥接模式（Bridge Pattern）
设计模式·桥接模式
越甲八千1 天前
重温设计模式--享元模式
设计模式·享元模式
码农爱java1 天前
设计模式--抽象工厂模式【创建型模式】
java·设计模式·面试·抽象工厂模式·原理·23种设计模式·java 设计模式
热门推荐
0119个Web前端交互式3D JavaScript框架和库02优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间03玄机平台应急响应—webshell查杀04RAG 实践- Ollama+RagFlow 部署本地知识库05基于大语言模型（LLM）的合成数据生成、策展和评估的综述06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07【一文读懂】NTN（非地面网络）技术介绍08HCIA-datacom数通题库和录播视频资料09Docker 夺命连环 15 问10ZZ038 物联网应用与服务赛题第J套