java设计模式：04-行为型模式-概览

最新推荐文章于 2024-11-03 11:01:20 发布

Mr_Air_Boy

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量772

点赞数 29

分类专栏： java设计模式文章标签： java 设计模式开发语言

本文链接：https://blog.csdn.net/Mr_Air_Boy/article/details/140626997

版权

java设计模式专栏收录该内容

21 篇文章 0 订阅

订阅专栏

行为型模式（Behavioral Patterns）

行为型模式（Behavioral Patterns）主要关注对象之间的通信和职责分配，旨在通过对象之间的相互作用来实现特定的功能。行为型模式不仅关注类和对象的结构，还关注它们之间的协作。通过使用行为型模式，可以提高系统的灵活性和可维护性，减少对象之间的耦合。

1. 责任链模式 (Chain of Responsibility Pattern)

定义：将请求沿着处理链传递，直到有一个对象处理它。
详细释义：责任链模式通过将请求沿着处理链传递，直到有一个对象处理它。每个对象都包含对下一个对象的引用，从而形成一条链。请求从链的一端开始，沿着链传递，直到有一个对象处理它或到达链的末端。

public abstract class Handler {
    protected Handler successor;

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public abstract void handleRequest(int request);
}

public class ConcreteHandler1 extends Handler {
    public void handleRequest(int request) {
        if (request < 10) {
            System.out.println("ConcreteHandler1 handled request: " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

public class ConcreteHandler2 extends Handler {
    public void handleRequest(int request) {
        if (request >= 10 && request < 20) {
            System.out.println("ConcreteHandler2 handled request: " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

2. 命令模式 (Command Pattern)

定义：将请求封装成对象，以便使用不同的请求、队列或日志来参数化其他对象。
详细释义：命令模式通过将请求封装成对象，使得你可以使用不同的请求、队列或日志来参数化其他对象。每个命令对象都实现一个统一的接口，包含执行请求的所有信息。这样可以在不修改调用者代码的情况下更改请求的执行方式。

public interface Command {
    void execute();
}

public class ConcreteCommand implements Command {
    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    public void execute() {
        receiver.action();
    }
}

public class Receiver {
    public void action() {
        System.out.println("Receiver action");
    }
}

public class Invoker {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void executeCommand() {
        command.execute();
    }
}

3. 解释器模式 (Interpreter Pattern)

定义：给定一个语言，定义其文法的一种表示，并提供一个解释器来处理语言中的句子。
详细释义：解释器模式用于定义一个语言的文法表示，并提供一个解释器来处理这些表示。通常用于实现简单的语法解析器，如正则表达式引擎、计算器等。解释器模式适用于那些频繁出现的、可以用简单语法规则定义的领域。

public interface Expression {
    boolean interpret(String context);
}

public class TerminalExpression implements Expression {
    private String data;

    public TerminalExpression(String data) {
        this.data = data;
    }

    public boolean interpret(String context) {
        return context.contains(data);
    }
}

public class OrExpression implements Expression {
    private Expression expr1;
    private Expression expr2;

    public OrExpression(Expression expr1, Expression expr2) {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }

    public boolean interpret(String context) {
        return expr1.interpret(context) || expr2.interpret(context);
    }
}

4. 迭代器模式 (Iterator Pattern)

定义：提供一种方法顺序访问聚合对象中的各个元素，而不暴露其内部表示。
详细释义：迭代器模式通过提供一种方法顺序访问聚合对象中的各个元素，而不暴露其内部表示。迭代器模式使得你可以遍历一个集合对象的元素而不需要了解其底层实现。迭代器通常包含两个核心方法：hasNext()和next()。

public interface Iterator {
    boolean hasNext();
    Object next();
}

public interface Container {
    Iterator getIterator();
}

public class NameRepository implements Container {
    public String[] names = {"John", "Jane", "Doe"};

    public Iterator getIterator() {
        return new NameIterator();
    }

    private class NameIterator implements Iterator {
        int index;

        public boolean hasNext() {
            return index < names.length;
        }

        public Object next() {
            if (this.hasNext()) {
                return names[index++];
            }
            return null;
        }
    }
}

5. 中介者模式 (Mediator Pattern)

定义：用一个中介对象来封装一系列对象之间的交互，使得这些对象之间不需要显式地相互引用。
详细释义：中介者模式通过使用一个中介对象来封装一系列对象之间的交互，使得这些对象之间不需要显式地相互引用。这种模式通过减少对象之间的直接依赖，降低了系统的耦合度，增加了系统的灵活性。

public interface Mediator {
    void sendMessage(String message, Colleague colleague);
}

public abstract class Colleague {
    protected Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }
}

public class ConcreteMediator implements Mediator {
    private Colleague1 colleague1;
    private Colleague2 colleague2;

    public void setColleague1(Colleague1 colleague1) {
        this.colleague1 = colleague1;
    }

    public void setColleague2(Colleague2 colleague2) {
        this.colleague2 = colleague2;
    }

    public void sendMessage(String message, Colleague colleague) {
        if (colleague == colleague1) {
            colleague2.notify(message);
        } else {
            colleague1.notify(message);
        }
    }
}

public class Colleague1 extends Colleague {
    public Colleague1(Mediator mediator) {
        super(mediator);
    }

    public void send(String message) {
        mediator.sendMessage(message, this);
    }

    public void notify(String message) {
        System.out.println("Colleague1 got message: " + message);
    }
}

public class Colleague2 extends Colleague {
    public Colleague2(Mediator mediator) {
        super(mediator);
    }

    public void send(String message) {
        mediator.sendMessage(message, this);
    }

    public void notify(String message) {
        System.out.println("Colleague2 got message: " + message);
    }
}

6. 备忘录模式 (Memento Pattern)

定义：在不破坏封装性的前提下，捕获并保存对象的内部状态，以便可以在以后恢复。
详细释义：备忘录模式通过在不破坏封装性的前提下，捕获并保存对象的内部状态，以便在以后恢复。备忘录模式通常用于实现撤销操作，通过保存对象的状态，可以在需要时将对象恢复到之前的状态。

public class Memento {
    private String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }
}

public class Originator {
    private String state;

    public void setState(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public Memento saveStateToMemento() {
        return new Memento(state);
    }

    public void getStateFromMemento(Memento memento) {
        state = memento.getState();
    }
}

public class Caretaker {
    private List<Memento> mementoList = new ArrayList<>();

    public void add(Memento state) {
        mementoList.add(state);
    }

    public Memento get(int index) {
        return mementoList.get(index);
    }
}

7. 观察者模式 (Observer Pattern)

定义：定义对象之间的一种一对多的依赖关系，使得当一个对象的状态发生变化时，其相关依赖对象皆得到通知并被自动更新。
详细释义：观察者模式定义对象之间的一种一对多的依赖关系，使得当一个对象的状态发生变化时，其相关依赖对象皆得到通知并被自动更新。这种模式通常用于实现事件处理系统，如GUI事件模型。

public interface Observer {
    void update(String state);
}

public class ConcreteObserver implements Observer {
    private String observerState;

    public void update(String state) {
        observerState = state;
        System.out.println("Observer state updated: " + observerState);
    }
}

public interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers();
}

public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String state;

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void detach(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers

() {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }

    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }

    public String getState() {
        return state;
    }
}

8. 状态模式 (State Pattern)

定义：允许对象在其内部状态改变时改变其行为，对象看起来好像修改了其类。
详细释义：状态模式通过将状态相关的行为封装到不同的状态对象中，使得对象在其内部状态改变时可以改变其行为。状态模式通过状态对象实现状态之间的转换，使得对象的行为随状态改变而改变。

public interface State {
    void doAction(Context context);
}

public class ConcreteStateA implements State {
    public void doAction(Context context) {
        System.out.println("State A action");
        context.setState(this);
    }
}

public class ConcreteStateB implements State {
    public void doAction(Context context) {
        System.out.println("State B action");
        context.setState(this);
    }
}

public class Context {
    private State state;

    public Context() {
        state = null;
    }

    public void setState(State state) {
        this.state = state;
    }

    public State getState() {
        return state;
    }

    public void doAction() {
        state.doAction(this);
    }
}

9. 策略模式 (Strategy Pattern)

定义：定义一系列算法，将每个算法封装起来，并让它们可以互相替换。
详细释义：策略模式定义一系列算法，将每个算法封装起来，并让它们可以互相替换。策略模式使得算法可以独立于使用它的客户而变化。通常用于实现多种算法或行为的选择，例如排序算法、压缩算法等。

public interface Strategy {
    int doOperation(int num1, int num2);
}

public class OperationAdd implements Strategy {
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

public class OperationSubtract implements Strategy {
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}

10. 模板方法模式 (Template Method Pattern)

定义：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，使得子类可以不改变算法结构地重定义该算法的某些特定步骤。
详细释义：模板方法模式定义一个操作中的算法骨架，而将一些步骤延迟到子类中。模板方法允许子类在不改变算法结构的情况下重新定义算法的某些特定步骤。模板方法模式常用于定义操作的标准步骤，并允许子类根据具体需求实现这些步骤。

public abstract class Game {
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();

    // 模板方法
    public final void play() {
        initialize();
        startPlay();
        endPlay();
    }
}

public class Cricket extends Game {
    void initialize() {
        System.out.println("Cricket Game Initialized");
    }

    void startPlay() {
        System.out.println("Cricket Game Started");
    }

    void endPlay() {
        System.out.println("Cricket Game Ended");
    }
}

public class Football extends Game {
    void initialize() {
        System.out.println("Football Game Initialized");
    }

    void startPlay() {
        System.out.println("Football Game Started");
    }

    void endPlay() {
        System.out.println("Football Game Ended");
    }
}

11. 访问者模式 (Visitor Pattern)

定义：表示一个作用于某对象结构中的各元素的操作，使得可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
详细释义：访问者模式通过将操作分离到访问者对象中，使得你可以在不改变元素类的前提下为这些元素定义新的操作。访问者模式通常用于对象结构较为复杂、需要对其元素进行多种不同操作的情况。

public interface Visitor {
    void visit(ConcreteElementA elementA);
    void visit(ConcreteElementB elementB);
}

public class ConcreteVisitor implements Visitor {
    public void visit(ConcreteElementA elementA) {
        System.out.println("Visiting ConcreteElementA");
    }

    public void visit(ConcreteElementB elementB) {
        System.out.println("Visiting ConcreteElementB");
    }
}

public interface Element {
    void accept(Visitor visitor);
}

public class ConcreteElementA implements Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

public class ConcreteElementB implements Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}