设计模式的概念--行为型模式

最新推荐文章于 2024-08-15 23:25:43 发布

kkkkm1

最新推荐文章于 2024-08-15 23:25:43 发布

阅读量235

点赞数 5

文章标签：设计模式 microsoft

本文链接：https://blog.csdn.net/kkkkm1/article/details/140399684

版权

###行为型模式：用于对象之间的通信，关注对象之间的交互。其中包括：

责任链模式（Chain of Responsibility Pattern）：为请求创建一个接收者对象的链。

/**
在这个示例中，我们有两种日志记录方式：控制台日志和文件日志。每个日志记录器都有一个级别，如果消息的级别满足日志记录器的要求，它将处理消息，否则将消息传递给下一个日志记录器。
**/
abstract class Logger {
    protected Logger nextLogger;
    public void setNextLogger(Logger nextLogger) {
        this.nextLogger = nextLogger;
    }
    public abstract void logMessage(int level, String message);
}
class ConsoleLogger extends Logger {
    public void logMessage(int level, String message) {
        if (level <= 1) {
            System.out.println("Console Logger: " + message);
        }
        if (nextLogger != null) {
            nextLogger.logMessage(level, message);
        }
    }
}
class FileLogger extends Logger {
    public void logMessage(int level, String message) {
        if (level <= 2) {
            System.out.println("File Logger: " + message);
        }
        if (nextLogger != null) {
            nextLogger.logMessage(level, message);
        }
    }
}
public class ChainOfResponsibilityPatternExample {
    public static void main(String[] args) {
        Logger consoleLogger = new ConsoleLogger();
        Logger fileLogger = new FileLogger();

        consoleLogger.setNextLogger(fileLogger);

        consoleLogger.logMessage(1, "This is an information.");
        consoleLogger.logMessage(2, "This is a warning.");
        consoleLogger.logMessage(3, "This is an error.");
    }
}

命令模式（Command Pattern）：将一个请求封装成一个对象，从而可以用不同的请求对客户进行参数化（Runnable）。
ps：可以理解为对抽象接口的具体实现

/**在这个示例中，我们有一个遥控器（RemoteControl）和一个电灯（Light）。我们定义了两个命令类：LightOnCommand 和 LightOffCommand，分别用于开灯和关灯操作。遥控器可以设置不同的命令，并通过按下按钮来执行不同的操作。**/
interface Command {
    void execute();
}
class Light {
    void turnOn() {
        System.out.println("Light is on");
    }
    void turnOff() {
        System.out.println("Light is off");
    }
}
class LightOnCommand implements Command {
    private Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }
    public void execute() {
        light.turnOn();
    }
}
class LightOffCommand implements Command {
    private Light light;
    public LightOffCommand(Light light) {
        this.light = light;
    }
    public void execute() {
        light.turnOff();
    }
}
class RemoteControl {
    private Command command;
    public void setCommand(Command command) {
        this.command = command;
    }
    public void pressButton() {
        command.execute();
    }
}
public class CommandPatternExample {
    public static void main(String[] args) {
        Light light = new Light();
        LightOnCommand lightOnCommand = new LightOnCommand(light);
        LightOffCommand lightOffCommand = new LightOffCommand(light);

        RemoteControl remoteControl = new RemoteControl();
        remoteControl.setCommand(lightOnCommand);
        remoteControl.pressButton();

        remoteControl.setCommand(lightOffCommand);
        remoteControl.pressButton();
    }
}

解释器模式（Interpreter Pattern）：提供了评估语言的语法或表达式的方式。
ps:对不同的日志格式进行统一处理。

/**在这个示例中，我们实现了一个简单的表达式解释器，用于判断某个文本是否满足给定的条件。TerminalExpression 表示一个终端表达式，OrExpression 和 AndExpression 分别表示或和与的**/
interface Expression {
    boolean interpret(String context);
}
class TerminalExpression implements Expression {
    private String data;

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

    public boolean interpret(String context) {
        return context.contains(data);
    }
}
class OrExpression implements Expression {
    private Expression expression1;
    private Expression expression2;

    public OrExpression(Expression expression1, Expression expression2) {
        this.expression1 = expression1;
        this.expression2 = expression2;
    }

    public boolean interpret(String context) {
        return expression1.interpret(context) || expression2.interpret(context);
    }
}
class AndExpression implements Expression {
    private Expression expression1;
    private Expression expression2;

    public AndExpression(Expression expression1, Expression expression2) {
        this.expression1 = expression1;
        this.expression2 = expression2;
    }

    public boolean interpret(String context) {
        return expression1.interpret(context) && expression2.interpret(context);
    }
}
public class InterpreterPatternExample {
    public static void main(String[] args) {
        Expression person1 = new TerminalExpression("John");
        Expression person2 = new TerminalExpression("Anna");
        Expression isSingle = new OrExpression(person1, person2);

        Expression person3 = new TerminalExpression("Emma");
        Expression isMarried = new TerminalExpression("Married");

        Expression isSingleAndMarried = new AndExpression(isSingle, isMarried);

        System.out.println("Is John single? " + isSingle.interpret("John"));
        System.out.println("Is Anna single? " + isSingle.interpret("Anna"));
        System.out.println("Is John married? " + isMarried.interpret("John Married"));
        System.out.println("Is Emma single and married? " + isSingleAndMarried.interpret("Emma Married"));
    }
}

迭代器模式（Iterator Pattern）：提供一种顺序访问聚合对象元素的方法，而不需要暴露其内部表示。

/**在这个示例中，我们定义了一个迭代器接口和一个容器接口。NameRepository 是具体的容器实现，它返回一个实现了迭代器接口的内部类 NameIterator。客户端可以通过容器的迭代器来遍历容器中的元素。**/
interface Iterator<T> {
    boolean hasNext();
    T next();
}
interface Container {
    Iterator<String> getIterator();
}
class NameRepository implements Container {
    private String[] names = {"John", "Anna", "Emma", "Tom"};

    public Iterator<String> getIterator() {
        return new NameIterator();
    }

    private class NameIterator implements Iterator<String> {
        private int index;

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

        public String next() {
            if (this.hasNext()) {
                return names[index++];
            }
            return null;
        }
    }
}
public class IteratorPatternExample {
    public static void main(String[] args) {
        NameRepository nameRepository = new NameRepository();
        Iterator<String> iterator = nameRepository.getIterator();

        while (iterator.hasNext()) {
            System.out.println("Name: " + iterator.next());
        }
    }
}

中介者模式（Mediator Pattern）：用一个中介对象来封装一系列的对象交互，从而使各对象不需要显式地相互引用。
ps:可能通过观察者模式实现中介者中的角色间的通讯

/**在这个示例中，我们有一个聊天室（ChatRoom）作为中介者，多个用户（User）作为同事。用户可以通过聊天室发送消息，聊天室负责转发消息给其他用户。这种方式可以避免用户直接彼此通信，而是通过中介者来实现交互。**/
class User {
    private String name;
    private ChatRoom chatRoom;

    public User(String name, ChatRoom chatRoom) {
        this.name = name;
        this.chatRoom = chatRoom;
    }

    public String getName() {
        return name;
    }

    public void sendMessage(String message) {
        chatRoom.showMessage(this, message);
    }
}
class ChatRoom {
    private List<User> users = new ArrayList<>();

    public void addUser(User user) {
        users.add(user);
    }

    public void showMessage(User user, String message) {
        System.out.println(user.getName() + " sends message: " + message);
    }
}
public class MediatorPatternExample {
    public static void main(String[] args) {
        ChatRoom chatRoom = new ChatRoom();

        User user1 = new User("John", chatRoom);
        User user2 = new User("Anna", chatRoom);

        chatRoom.addUser(user1);
        chatRoom.addUser(user2);

        user1.sendMessage("Hello, Anna!");
        user2.sendMessage("Hi, John!");
    }
}

备忘录模式（Memento Pattern）：在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
ps:暂存：如ctrl+z可以回退

/**在这个示例中，备忘录模式允许我们在不破坏对象封装的情况下，保存对象的内部状态，并在需要时恢复到之前的状态。**/
class Memento {
    private String state;

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

    public String getState() {
        return state;
    }
}
class Originator {
    private String state;

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

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

    public void getStateFromMemento(Memento memento) {
        state = memento.getState();
    }
}
class CareTaker {
    private List<Memento> mementoList = new ArrayList<>();

    public void addMemento(Memento memento) {
        mementoList.add(memento);
    }

    public Memento getMemento(int index) {
        return mementoList.get(index);
    }
}
public class MementoPatternExample {
    public static void main(String[] args) {
        Originator originator = new Originator();
        CareTaker careTaker = new CareTaker();

        originator.setState("State 1");
        careTaker.addMemento(originator.saveStateToMemento());

        originator.setState("State 2");
        careTaker.addMemento(originator.saveStateToMemento());

        originator.setState("State 3");
        careTaker.addMemento(originator.saveStateToMemento());

        System.out.println("Current State: " + originator.getState());

        originator.getStateFromMemento(careTaker.getMemento(1));
        System.out.println("Restored State: " + originator.getState());
    }
}

观察者模式（Observer Pattern）：定义了对象之间的一对多依赖关系，当一个对象改变状态时，所有依赖它的对象都会被通知并更新（Event、MQ）。

/**在这个示例中，观察者模式定义了一对多的依赖关系。当主题（Subject）的状态发生变化时，所有的观察者都会被通知并更新。**/
interface Observer {
    void update(String message);
}
class ConcreteObserver implements Observer {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    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 ObserverPatternExample {
    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!");
    }
}

状态模式（State Pattern）：允许对象在其内部状态改变时改变其行为。
ps:上下文的概念。

/**在这个示例中，状态模式允许对象在内部状态改变时改变其行为。根据不同的状态，对象可以执行不同的操作。**/
interface State {
    void doAction(Context context);
}
class StartState implements State {
    public void doAction(Context context) {
        System.out.println("Player is in start state");
        context.setState(this);
    }

    public String toString() {
        return "Start State";
    }
}
class StopState implements State {
    public void doAction(Context context) {
        System.out.println("Player is in stop state");
        context.setState(this);
    }

    public String toString() {
        return "Stop State";
    }
}
class Context {
    private State state;

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

    public State getState() {
        return state;
    }
}
public class StatePatternExample {
    public static void main(String[] args) {
        Context context = new Context();

        State startState = new StartState();
        startState.doAction(context);

        System.out.println(context.getState());

        State stopState = new StopState();
        stopState.doAction(context);

        System.out.println(context.getState());
    }
}

策略模式（Strategy Pattern）：定义了一系列的算法，将每个算法封装起来，使它们可以相互替换（Comparator接口传入List的sort方法里）。

/**在这个示例中，策略模式定义了一系列的算法，每个算法都被封装为一个策略。这使得可以在运行时选择不同的策略。**/
interface PaymentStrategy {
    void pay(int amount);
}
class CreditCardPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using credit card");
    }
}
class PayPalPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using PayPal");
    }
}
class ShoppingCart {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(int amount) {
        paymentStrategy.pay(amount);
    }
}
public class StrategyPatternExample {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();

        cart.setPaymentStrategy(new CreditCardPayment());
        cart.checkout(100);

        cart.setPaymentStrategy(new PayPalPayment());
        cart.checkout(150);
    }
}

模板方法模式（Template Method Pattern）：定义了一个算法的骨架，而将一些步骤延迟到子类中实现（AbstractArrayList、HttpServlet）（应用权限查询，支付流程）。

/**在这个示例中，模板方法模式定义了算法的骨架，但将一些步骤延迟到子类中实现。**/
abstract class Game {
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();

    public final void play() {
        initialize();
        startPlay();
        endPlay();
    }
}
class Cricket extends Game {
    void initialize() {
        System.out.println("Cricket Game Initialized! Start playing.");
    }

    void startPlay() {
        System.out.println("Cricket Game Started. Enjoy the game!");
    }

    void endPlay() {
        System.out.println("Cricket Game Finished!");
    }
}
class Football extends Game {
    void initialize() {
        System.out.println("Football Game Initialized! Start playing.");
    }

    void startPlay() {
        System.out.println("Football Game Started. Enjoy the game!");
    }

    void endPlay() {
        System.out.println("Football Game Finished!");
    }
}
public class TemplateMethodPatternExample {
    public static void main(String[] args) {
        Game cricket = new Cricket();
        cricket.play();

        Game football = new Football();
        football.play();
    }
}

访问者模式（Visitor Pattern）：表示一个作用于某对象结构中的各元素的操作，可以在不改变各元素的类的前提下定义新的操作（FileVisitor）。

/**在这个示例中，访问者模式定义了一系列作用于对象结构中元素的操作，这些操作可以在不改变元素类的前提下进行扩展。**/
interface Visitor {
    void visit(Element element);
}
class ConcreteVisitor implements Visitor {
    public void visit(Element element) {
        System.out.println("Visited " + element);
    }
}
interface Element {
    void accept(Visitor visitor);
}
class ConcreteElement implements Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}
public class VisitorPatternExample {
    public static void main(String[] args) {
        Visitor visitor = new ConcreteVisitor();
        Element element = new ConcreteElement();

        element.accept(visitor);
    }
}