六类行为型设计模式

最新推荐文章于 2024-04-26 14:53:11 发布

沐风听雨_A

最新推荐文章于 2024-04-26 14:53:11 发布

阅读量464

点赞数 16

文章标签：设计模式 java 开发语言

本文链接：https://blog.csdn.net/wehpd/article/details/137125408

版权

1、模板方法模式：

package com.model.templatemethod;

//AbstractClass是抽象类，定义了一个模板方法templateMethod()来定义算法的骨架.
//它调用了三个步骤，其中两个步骤stepOne()和stepTwo()在AbstractClass中被定义为抽象方法，需要由具体的子类来实现.
//而stepThree()是一个可选的步骤，可以在子类中选择是否重写。
//抽象类，定义算法的骨架
abstract class AbstractClass {
	// 模板方法，定义算法的骨架
	public final void templateMethod() {
		// 步骤一
		stepOne();

		// 步骤二
		stepTwo();

		// 步骤三，留给子类实现
		stepThree();
	}

	// 步骤一，具体的实现在子类中
	abstract void stepOne();

	// 步骤二，具体的实现在子类中
	abstract void stepTwo();

	// 步骤三，由子类实现
	void stepThree() {
		// 默认实现
		System.out.println("AbstractClass: stepThree");
	}
}

package com.model.templatemethod;
//ConcreteClass是一个具体的子类，实现了AbstractClass中的两个抽象方法，并重写了stepThree()方法。
//具体的子类，实现具体的步骤
class ConcreteClass extends AbstractClass {
	@Override
	void stepOne() {
		System.out.println("ConcreteClass: stepOne");
	}

	@Override
	void stepTwo() {
		System.out.println("ConcreteClass: stepTwo");
	}

	@Override
	void stepThree() {
		System.out.println("ConcreteClass: stepThree");
	}
}

package com.model.templatemethod;
//调用templateMethod()方法，从而实现一个具体的算法。
public class Main {
	public class TemplateMethodPatternDemo {
	    public static void main(String[] args) {
	        AbstractClass abstractClass = new ConcreteClass();
	        abstractClass.templateMethod();
	    }
	}
}

2、策略模式：

package com.model.strategic;

//策略接口,定义一个execute()方法.
//具体的策略类ConcreteStrategyA和ConcreteStrategyB分别实现了该接口。
//每个具体的策略类都提供了自己的实现。
interface Strategy {
	
 void execute();
 
}

package com.model.strategic;
//具体的策略类实现策略接口
class ConcreteStrategyA implements Strategy {

	@Override
	public void execute() {

		System.out.println("Strategy A is executed.");

	}

}

package com.model.strategic;
//具体的策略类实现策略接口
class ConcreteStrategyB implements Strategy {
	@Override
	public void execute() {
		
		System.out.println("Strategy B is executed.");
	}
}

package com.model.strategic;
//上下文类，持有一个策略对象，并在执行算法时调用策略对象的execute()方法,用于切换不同的策略.
class Context {
 private Strategy strategy;

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

 public void executeStrategy() {
     strategy.execute();
 }
}

package com.model.strategic;
public class Main {
//策略模式允许在运行时动态地切换算法，使得算法的选择和使用可以独立于客户端代码。
	public class StrategyPatternDemo {
	    public static void main(String[] args) {
	        // 创建具体的策略对象
	        Strategy strategyA = new ConcreteStrategyA();
	        
	        Strategy strategyB = new ConcreteStrategyB();

	        // 创建上下文对象，并将具体的策略对象传入
	        Context context = new Context(strategyA);

	        // 执行策略A
	        context.executeStrategy();

	        // 切换策略B
	        context = new Context(strategyB);

	        // 执行策略B
	        context.executeStrategy();
	    }
	}
}

3、观察者模式：

package com.model.observer;
//Subject是主题接口，定义了注册、移除和通知观察者的方法。
interface Subject {
 void registerObserver(Observer observer);
 void removeObserver(Observer observer);
 void notifyObservers();
}

package com.model.observer;

//观察者接口,定义一个更新方法，用于接收主题的通知。
interface Observer {
	
 void update(String message);
 
}

import java.util.List;
//具体主题类,实现主题接口，并维护一个观察者列表。
class ConcreteSubject implements Subject {
	private List<Observer> observers;
	private String message;

	public ConcreteSubject() {
		observers = new ArrayList<>();
	}

	@Override
	public void registerObserver(Observer observer) {
		observers.add(observer);
	}

	@Override
	public void removeObserver(Observer observer) {
		observers.remove(observer);
	}

	@Override
	public void notifyObservers() {
		for (Observer observer : observers) {
			observer.update(message);
		}
	}

	public void setMessage(String message) {
		this.message = message;
		notifyObservers();
	}
}

package com.model.observer;

//具体观察者类,实现观察者接口，并在更新方法中输出接收到的消息。
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 a message: " + message);
	}
}

package com.model.observer;
//通过调用主题的setMessage()方法来更新消息。
//当主题的消息发生改变时，所有注册的观察者都会收到通知，并根据收到的消息进行相应的处理。
public class ObserverPatternDemo {
    public static void main(String[] args) {
        // 创建具体主题对象
        ConcreteSubject subject = new ConcreteSubject();

        // 创建具体观察者对象
        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");
        Observer observer3 = new ConcreteObserver("Observer 3");

        // 注册观察者到主题
        subject.registerObserver(observer1);
        subject.registerObserver(observer2);
        subject.registerObserver(observer3);

        // 更新主题消息，观察者会收到通知并进行相应的处理
        subject.setMessage("Hello World!");
    }
}

4、责任链模式：

package com.model.chain;
//抽象处理者
abstract class Handler {
 protected Handler next;

 public void setNext(Handler next) {
     this.next = next;
 }

 public abstract void handleRequest(int amount);
}

package com.model.chain;
//具体处理者1
class ConcreteHandler1 extends Handler {
 @Override
 public void handleRequest(int amount) {
     if (amount <= 100) {
         System.out.println("ConcreteHandler1: Processing request");
     } else if (next != null) {
         next.handleRequest(amount);
     }
 }
}

package com.model.chain;
//具体处理者2
class ConcreteHandler2 extends Handler {
 @Override
 public void handleRequest(int amount) {
     if (amount > 100 && amount <= 200) {
         System.out.println("ConcreteHandler2: Processing request");
     } else if (next != null) {
         next.handleRequest(amount);
     }
 }
}

package com.model.chain;
//具体处理者3
class ConcreteHandler3 extends Handler {
 @Override
 public void handleRequest(int amount) {
     if (amount > 200) {
         System.out.println("ConcreteHandler3: Processing request");
     } else if (next != null) {
         next.handleRequest(amount);
     }
 }
}

package com.model.chain;
//根据责任链的设计，具体处理者1无法处理这个请求，所以它将请求传递给下一个处理者，即具体处理者2。
//具体处理者2判断金额在其能处理的范围内，对该请求进行处理。
	public class ChainOfResponsibilityPatternDemo {
	    public static void main(String[] args) {
	        // 创建具体处理者对象
	        Handler handler1 = new ConcreteHandler1();
	        Handler handler2 = new ConcreteHandler2();
	        Handler handler3 = new ConcreteHandler3();

	        // 设置处理者之间的关系
	        handler1.setNext(handler2);
	        handler2.setNext(handler3);

	        // 发起请求
	        handler1.handleRequest(150);
	    }
	}

5、命令模式：

package com.model.command;
//命令接口,定义执行操作的方法execute()。
interface Command {
	
 void execute();
 
}

package com.model.command;
//具体命令,持有一个接收者对象，并在execute()方法中调用接收者的action()方法完成具体的操作。
class ConcreteCommand implements Command {
	
 private Receiver receiver;

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

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

package com.model.command;
//接收者
class Receiver {
 public void action() {
     System.out.println("Receiver: Action executed");
 }
}

package com.model.command;
//调用者，持有一个命令对象，并在executeCommand()方法中调用命令对象的execute()方法来执行操作。
class Invoker {
 private Command command;

 public Invoker(Command command) {
     this.command = command;
 }

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

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

package com.model.command;
//命令模式可以帮助我们将请求发送者和接收者解耦，让发送者不需要知道接收者的具体信息.
public class CommandPatternDemo {
    public static void main(String[] args) {
        // 创建接收者对象
        Receiver receiver = new Receiver();

        // 创建具体命令对象，并传入接收者对象
        Command command = new ConcreteCommand(receiver);

        // 创建调用者对象，并传入具体命令对象
        Invoker invoker = new Invoker(command);

        // 调用者执行命令
        invoker.executeCommand();
    }
}

6、访问者模式：

package com.model.accessor;
//元素接口,定义接受访问者的方法。
interface Element {
	
 void accept(Visitor visitor);
 
}

package com.model.accessor;
//具体元素,提供具体的操作。
class ConcreteElementA implements Element {
 @Override
 public void accept(Visitor visitor) {
     visitor.visit(this);
 }

 public void operationA() {
     System.out.println("ConcreteElementA: Operation A");
 }
}

package com.model.accessor;
//具体元素,提供具体的操作。
class ConcreteElementB implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    public void operationB() {
        System.out.println("ConcreteElementB: Operation B");
    }
}

package com.model.accessor;
//访问者接口,定义访问元素的方法。
interface Visitor {
	
 void visit(ConcreteElementA element);

 void visit(ConcreteElementB element);
}

package com.model.accessor;
//具体访问者实现访问者接口，提供具体的操作。
class ConcreteVisitor implements Visitor {
 @Override
 public void visit(ConcreteElementA element) {
     element.operationA();
 }

 @Override
 public void visit(ConcreteElementB element) {
     element.operationB();
 }
}

package com.model.accessor;
//访问者模式将操作与数据结构分离，使得新增操作不需要修改现有数据结构的代码。
public class VisitorPatternDemo {
	
    public static void main(String[] args) {
    	
        Element elementA = new ConcreteElementA();
        
        Element elementB = new ConcreteElementB();

        Visitor visitor = new ConcreteVisitor();

        elementA.accept(visitor);
        
        elementB.accept(visitor);
    }
}