java常用设计模式学习总结

最新推荐文章于 2022-03-10 22:16:10 发布

星晨sta

最新推荐文章于 2022-03-10 22:16:10 发布

阅读量532

点赞数

文章标签： java 设计模式单例工厂装饰者

本文链接：https://blog.csdn.net/m0_37414960/article/details/81080665

版权

常用设计模式归纳：

创建型：单例模式，工厂方法模式等等

结构型：静态代理模式，动态代理模式，装饰者模式，适配器模式，桥接模式

行为型：观察者模式，命令模式，责任链模式，状态模式，访问者模式

1.单例模式

应用场景：顾名思义，自始至终都操作的是同一个对象的时候，需要用单例模式

/**
 * 单例懒汉式（比较常用）
 */
public class SingletonPatternLazy {
	
	private SingletonPatternLazy() {}
	
	public static SingletonPatternLazy getInstance () {
		return SingletonPatternInstance.singletonPatternLazy;
	}
	
	private static class SingletonPatternInstance {
		final static SingletonPatternLazy singletonPatternLazy = new SingletonPatternLazy();
	}
	
	public static void main(String[] args) {
		SingletonPatternLazy instance1 = SingletonPatternLazy.getInstance();
		SingletonPatternLazy instance2 = SingletonPatternLazy.getInstance();
		
		System.out.println(instance1 == instance2);
	}

}

/**
 * 单例饿汉式（比较常用）
 */
public class SingletonPattern {
	
	private SingletonPattern() {}
	
	private final static SingletonPattern singletonPattern = new SingletonPattern();
	
	public static SingletonPattern getInstance() {
		return singletonPattern;
	}

	public static void main(String[] args) {
		SingletonPattern instance1 = SingletonPattern.getInstance();
		SingletonPattern instance2 = SingletonPattern.getInstance();
		System.out.println(instance1 == instance2);
	}

}

单例模式优化升级版(推荐)

/**
 * 单例懒汉式（最标准的单例模式）
 */
public class SingletonPatternLazy {

	private static SingletonPatternLazy instance = null;

	private SingletonPatternLazy() {
	}

	public static SingletonPatternLazy getInstance() {
		if (instance == null) {
			newInstance();
		}
		return instance;
	}

	private synchronized static void newInstance() {
		if (instance == null) {
			instance = new SingletonPatternLazy();
		}
	}

	public static void main(String[] args) {
		
		for(int i = 0; i < 100; i ++) {
			new Thread(() -> System.out.println(SingletonPatternLazy.getInstance())).start();
		}

	}

}

2.工厂方法模式

应用场景：

当我们需要获取同一规范下的各个不同实现的对象，并且再获取这些对象的时候比较麻烦的情况下，可以考虑使用工厂模式。

在扩展规范的实现的时候，同时又需要去扩展工厂，为了便于扩展，适应于开闭原则，因此产生了工厂方法模式，即一个工厂只创建规范下的一个实现的对象。

不同的对象的创建对应不同的工厂，那么这些不同的工厂就可以抽象出一个模板出来，或者提前定义一个接口出来。


/*
 * 需要被使用工厂创建的source
 */
//Person规范
public interface Person {
	void work();
}

//Person的一个具体实现，Programmer
public class Programmer implements Person {
	@Override
	public void work() {
		System.out.println("程序员work");
	}
}

/*
 * 工厂相关
 */
//工厂规范
public interface PersonFactory {
	Person getInstance();
}

//工厂规范的一个实现ProgrammerFactory 
public class ProgrammerFactory implements PersonFactory {

	private Programmer programmer;
	
	@Override
	public Person getInstance() {
		if(programmer == null) {
			newInstance();
		}
		return programmer;
	}
	
	private synchronized void newInstance() {
		if(programmer == null) {
			programmer = new Programmer();
		}
	}

}

/*
 * 工厂方法模式测试
 */
public class PersonFactoryBuilder {

	
	public static PersonFactory build(Class<? extends PersonFactory> clazz) {
		try {
			return clazz.newInstance();
		} catch (InstantiationException | IllegalAccessException e) {
			throw new RuntimeException(e);
		}
	}
	
	public static void main(String[] args) {
		PersonFactory personFactory = PersonFactoryBuilder.build(ProgrammerFactory.class);
		for(int i = 0; i < 100; i ++) {
			new Thread(() -> System.out.println(personFactory.getInstance())).start();
		}
		
	}
	
}

3.静态代理模式

应用场景：用的不太多，一般用动态代理

//被代理的规范
public interface IPerson {
	void doSome();
}

//被代理的实现
public class Person implements IPerson{
	
	public void doSome(){
		System.out.println("基本功能...");
	}
	
}

//代理类
public class PersonProxy implements IPerson{
	
	private IPerson person;
	
    //构造需要一个被代理的对象
	public PersonProxy(IPerson person){
		this.person = person;
	}
	
	public void doSome(){
		before();
		person.doSome();
		after();
	}
	
	public void before(){
		System.out.println("before...");
	}
	
	public void after(){
		System.out.println("after...");
	}
}

/*
 *测试静态代理
 */
public static void testProxy(){
	IPerson proxy = new PersonProxy(new Person());
	proxy.doSome();
}

4.动态代理模式

应用场景：spring的aop底层就是基于动态代理，当我们需要横向且动态对程序进行扩展，即扩展任意对象的方法的时候，可以用到动态代理

jdk动态代理

//被代理规范
public interface ISource {
	void doSome(String inputSome);
}

//被代理的实现
public class SourceImpl implements ISource{
	
	public void doSome(String inputSome){
		System.out.println("基本功能，输出内容：" + inputSome);
	}
	
}

//创建一个简单的代理内容的实现类
public class BeforeAfterInvocationHandler implements InvocationHandler {
	
	private Object source;

	public BeforeAfterInvocationHandler(Object source){
		this.source = source;
	}
	
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		before();
		method.invoke(source, args);
		after();
		return null;
	}
	
	
	public void before(){
		System.out.println("------执行before-------");
	}
	
	public void after(){
		System.out.println("------执行after-------");
	}
	
	/**
	 * 获取t对象的代理对象
	 * @param t 被代理的对象
	 * @return 返回代理对象
	 */
	@SuppressWarnings("all")
	public static <T> T getProxy(T t){
		BeforeAfterInvocationHandler invocationHandler = new BeforeAfterInvocationHandler(t);
		Class[] interfaces = t.getClass().getInterfaces();
		T tProxy = (T) Proxy.newProxyInstance(invocationHandler.getClass().getClassLoader(), interfaces, invocationHandler);
		return tProxy;
	}
	
}

//测试动态代理
public static void testDynamicProxy(){
	ISource source = new SourceImpl();
	BeforeAfterInvocationHandler.getProxy(source).doSome("这是动态代理测试的输出内容");
}

cglib动态代理

依赖cglib:

<dependency>
   <groupId>cglib</groupId>
   <artifactId>cglib</artifactId>
   <version>3.3.0</version>
</dependency>

//被代理类
public class Programmer {
	
	public String getUsername() {
		return "lucy";
	}

	public void doSome() {
		System.out.println("程序员doSome()");
	}

}

//代理类处理器
public class CGlibProxyHandler implements MethodInterceptor {
	
	public Object createProxy(Object source){
		Enhancer enhancer = new Enhancer();
		enhancer.setCallback(this);
		enhancer.setSuperclass(source.getClass());
		return enhancer.create();
	}

	@Override
	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
		before(obj, args);
		Object object = proxy.invokeSuper(obj, args);
		after(object);
		return object;
	}
	
	//前置增强
	private void before(Object obj, Object[] args) {
		System.out.println("before：" + obj.getClass().getSuperclass().getName());
	}
	
	//后置增强
	private void after(Object object) {
		System.out.println("after：" + JSONObject.toJSONString(object));
	}
	
	@SuppressWarnings("unchecked")
	public static <T> T getProxy(T t){
		CGlibProxyHandler handler = new CGlibProxyHandler();
		return (T) handler.createProxy(t);
	}

}

//测试
public static void main(String[] args) {
	Programmer proxy = CGlibProxyHandler.getProxy(new Programmer());
	String name = proxy.getUsername();
	System.out.println(name);
	proxy.doSome();
}

5.装饰者模式

应用场景：当我们需要动态的横向扩展程序的时候，即动态的扩展某一对象的方法，可以用装饰者模式

注意与动态代理的区别：

动态代理是对任意对象的方法扩展，但扩展的内容是固定不变的

装饰者模式是对某一个对象的方法扩展，扩展的内容是可以动态变化的

//被装饰的规范
public interface IPerson {
	void doSome();
}

//被装饰规范的实现
public class PersonImpl implements IPerson {

	public void doSome() {
		System.out.println("吃饭功能....");
	}

}

//抽象装饰器
public abstract class PersonDecorator implements IPerson {
	
	private IPerson person;
	
	public PersonDecorator(IPerson person){
		this.person = person;
	}
	
	//调用当前构造中接受的person实例的dosome()
	public void doSome() {
		person.doSome();
	}

}

//装饰器Student
public class Student extends PersonDecorator {
	
	//构造需要提供一个person实例
	public Student(IPerson person){
		//把构造参数交给父类
		super(person);
	}
	
	public void doSome(){

		/*
		 *首先，调用父类的doSome()
		 *然后，父类中又调用当前构造中接受的person实例的dosome()
		 */
		super.doSome();
		System.out.println("学习功能...");
	}
}

//装饰器Worker
public class Worker extends PersonDecorator {
	
	public Worker(IPerson person){
		super(person);
	}
	
	public void doSome(){
		super.doSome();
		System.out.println("工作功能...");
	}

}

//测试装饰者模式
public static void testDecorator(){
	//基本的person
	PersonImpl person = new PersonImpl();
	System.out.println("--------------person: --------------");
	//基本的person所做的事
	person.doSome();

	//被worker装饰过的基本person
	Worker worker = new Worker(person);
	System.out.println("--------------worker: --------------");
	//被worker装饰过的person所做的事
	worker.doSome();

	//被学生装饰过的worker
	Student student = new Student(worker);
	System.out.println("--------------student: --------------");
	//被学生装饰过的worker所做的事
	student.doSome();
}

6.适配器模式

应用场景：比如应用中有一个类A，还有一个规范，且规范的某一个或多个方法具有和类A相同的实现，因此就不需要再单独去实现这些方法了，可以新增一个抽象适配器类，直接去继承类A，然后定义新的抽象规范

//被适配者
public class Animal {
	public void eat() {
		System.out.println("eat()*************************");
	}
}

//需要适配Animal的接口
public interface IPerson {	
	public void doWork();	
}

//适配器
public class AnimalAdpter extends Animal implements IPerson {

	@Override
	public void doWork() {
		before();
		super.eat();
		after();
	}
	
	private void before() {
		System.out.println("AnimalAdpter.before()*************************");
	}
	
	private void after() {
		System.out.println("AnimalAdpter.after()*************************");
	}
	
	public static void main(String[] args) {
		IPerson person = new AnimalAdpter();
		person.doWork();
	}

}

7.桥接模式

应用场景：当我们需要操作规范，但又无法固定实现的时候，可以提供一组规范，让客户方来实现，我们操作的时候只需注入客户方的实现对象，这种模式就是桥接模式，例如：jdbc定义了驱动规范，各个数据库厂商提供不同的驱动实现

//需要桥接的规范IBridgeAble
public interface IBridgeAble {	
	public void doSome(String arg0, String arg1);	
}

//定义对该规范的伪实现BridgeAble
public class BridgeAble implements IBridgeAble {
	
	private IBridgeAble bridgeAble;
	
	public BridgeAble(IBridgeAble bridgeAble){
		this.bridgeAble = bridgeAble;
	}

	public void doSome(String arg0, String arg1) {	
		bridgeAble.doSome(arg0, arg1);
	}

}

//A客户方提供的实现BrideAbleImplA
public class BrideAbleImplA implements IBridgeAble{

	public void doSome(String arg0, String arg1) {
		System.out.println("BrideAbleImplA.arg0: " + arg0 + " BrideAbleImplA.arg1: " + arg1);
	}

}

//B客户方提供的实现BrideAbleImplB
public class BrideAbleImplB implements IBridgeAble{

	public void doSome(String arg0, String arg1) {
		System.out.println("BrideAbleImplB.arg0: " + arg0 + " BrideAbleImplB.arg1: " + arg1);
	}

}

//测试桥接模式
public static void testBridge(){
	BridgeAble bridge = new BridgeAble(new BrideAbleImplA());
	bridge.doSome("A", "A1");
}

8.观察者模式

应用场景：观察者模式略微难理解，但十分重要，例如监听器就需要使用观察者模式来实现

//定义观察者规范
public interface IObserver {
	void operate();
}

//观察者ObserverOne，额外提供了单例模式获取对象，通常情况观察者，都是单例的
public class ObserverOne implements IObserver {
	@Override
	public void operate() {
		System.out.println("观察者1观察到了变化");
	}
}

//观察者ObserverTwo
public class ObserverTwo implements IObserver {
	@Override
	public void operate() {
		System.out.println("观察者2观察到了变化");
	}
}

//抽象的被观察者BeObserver
public abstract class BeObserver {
	
	private Set<IObserver> observers;
	
	public BeObserver(Set<IObserver> observers) {
		this.observers = observers;
	}
	
	public abstract void doSome();

	protected void notifyObserver() {
		if(observers != null) {
			observers.forEach(observer -> observer.operate());			
		}
	}

}

//被观察者实现DefaultBeObserver
public class DefaultBeObserver extends BeObserver {
	
	public DefaultBeObserver(Set<IObserver> observers) {
		super(observers);
	}

	@Override
	public void doSome() {
		super.notifyObserver();
		System.out.println("doSome()***********");
	}

}

//测试观察者模式
public static void testObserver(){
	HashSet<IObserver> observers = new HashSet<IObserver>();
	observers.add(new ObserverOne());
	observers.add(new ObserverTwo());
	new DefaultBeObserver(observers).doSome();
}

9.监听器

//事件
public class Event {
	public void print() {
		System.out.println("当前时间：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date()));
	}
}

//暴露监听器接口
public interface Listener {
	void onEvent(Event e);
}

//需要客户编写的监听器实现
public class ListenerImpl implements Listener{	
	@Override
	public void onEvent(Event e) {
		e.print();
	}
}

//事件源
public class EventResource {

	private List<Listener> listenerList = new ArrayList<>();
	
	private Event e = new Event();
	
	public void register(Listener listener) {
		this.listenerList.add(listener);
	}
	
	public void operte() {
		System.out.println("EventResource.operte***************");
		this.listenerList.forEach(listener -> listener.onEvent(e));
	}
	
	public static void main(String[] args) {
		EventResource eventResource = new EventResource();
		eventResource.register(new ListenerImpl());
		eventResource.operte();
	}
	
}

10.命令模式

应用场景：应用不是太广泛，举个例子说明一下，activiti对数据库的各种操作就使用了命令模式，activiti把对数据库的操作都封装在各个不同的命令中，调用方即命令下达者，操作数据库的API即执行者，相互之间依赖接口是解耦的。

这里需要注意三个对象，命令下达者(持有命令对象)，命令(持有至少一个命令执行者对象和命令内容)，命令执行者(执行命令)

//命令下达规范
public interface ILeader {
	//下达命令
	void command();
}

//命令下达者的一个实现
public class LeaderImplOne implements ILeader{

	//持有命令对象
	private ICommand command;

	//构造注入一个命令
	public LeaderImplOne(ICommand command){
		this.command = command;
	}
	
	//下达命令
	public void command() {
		command.transferCommand();
	}

}

//命令下达者实现...N

//命令规范
public interface ICommand {
	//传递命令
	void transferCommand();
}

//命令实现1
public class CommandImplOne implements ICommand{
	
	//持有若干执行者的对象
	private IExecutor[] executors;
	
	//持有某个执行者的对象
	private IExecutor executor;
	
	//持有命令内容
	private String content;
	
	//构建一个命令对象，需要接收一个或多个执行者，和命令内容
	public CommandImplOne (IExecutor[] executors,String content){
		this.executors = executors;
		this.content = content;
	}
	
	//构建一个命令对象，需要接收一个或多个执行者，和命令内容
	public CommandImplOne (IExecutor executor,String content){
		this.executor = executor;
		this.content = content;
	}

	//传递命令给执行者去执行命令
	public void transferCommand() {
		if(executors != null && executors.length > 0){
			for(int i = 0; i < executors.length; i++){
				executors[i].execute(content);
			}
		}		
		
		if(executor != null){
			executor.execute(content);
		}
		
	}
	
}

//命令实现2
public class CommandImplTwo implements ICommand{
	
	//持有若干执行者的对象
	private IExecutor[] executors;
	
	//持有某个执行者的对象
	private IExecutor executor;
	
	//持有命令内容
	private Map<String, Object> content;
	
	//构建一个命令对象，需要接收一个或多个执行者，和命令内容
	public CommandImplTwo (IExecutor[] executors,Map<String, Object> content){
		this.executors = executors;
		this.content = content;
	}
	
	//构建一个命令对象，需要接收一个或多个执行者，和命令内容
	public CommandImplTwo (IExecutor executor,Map<String, Object> content){
		this.executor = executor;
		this.content = content;
	}

	//传递命令给执行者去执行命令
	public void transferCommand() {
		if(executors != null && executors.length > 0){
			for(int i = 0; i < executors.length; i++){
				executors[i].execute(content);
			}
		}
		
		if(executor != null){
			executor.execute(content);
		}
		
	}
	
}

//命令实现...N

//命令执行者规范
public interface IExecutor {
	//执行命令
	void execute(String content);
	
	//执行命令
	void execute(Map<String, Object> content);
}

//命令执行者实现1
public class ExecutorImplOne implements IExecutor {


	public void execute(String content) {
		//模拟执行者执行命令逻辑
		System.out.println("命令执行1执行了命令，打印 content:" + content);
	}

	public void execute(Map<String, Object> content) {		
		//模拟执行者执行命令逻辑
		System.out.println("命令执行1执行了命令，打印 content.size:" + content.size());
	}

}

//命令执行者实现2
public class ExecutorImpTwo implements IExecutor {


	public void execute(String content) {
		//模拟执行者执行命令逻辑
		System.out.println("命令执行者2执行了命令，打印 content:" + content);
	}

	public void execute(Map<String, Object> content) {		
		//模拟执行者执行命令逻辑
		System.out.println("命令执行者2执行了命令，打印 content.size:" + content.size());
	}

}

//命令执行者实现...N

//测试命令模式
public static void testCommand(){
	//构建多个命令执行者的数组对象
	IExecutor[] executors = {new ExecutorImplOne(),new ExecutorImpTwo()};

	//构建命令对象,并传入多个执行者的数组对象，命令内容		
	CommandImplOne commandOne = new CommandImplOne(executors,"命令1");
	
	//构建命令下达者，下达命令
	new LeaderImplOne(commandOne).command();
}

11.责任链模式

应用场景：责任链应用还是相当广泛的，例如springmvc的处理器链就使用了该设计模式，其原理是，前台发送一个请求，会被处理器链中的各种拦截器进行拦截，分别进行各自的处理。总之，如果你有一个对象需要同时被其他多个对象分别进行不同的处理，并且这个过程是线性的，即同步执行的，那么我们可以考虑使用责任链模式。这么做的好处是，被处理对象和各个处理对象进行解耦，进行自由组装。

//首先定义一个处理器模板
public abstract class Handler {

	//下一任处理器
	protected Handler nextHandler;
	
	//上一任处理器
	protected Handler lastHandler;
	
	//当前处理器名称
	protected String handlerName;
	
	//构造注入处理器名称
	public Handler (String handlerName){
		this.handlerName = handlerName;
	}
	
	//注入下一步处理器，同时把当前处理器赋值给下一任处理器的前任
	public void setNextHandler(Handler nextHandler){
		this.nextHandler = nextHandler;
		nextHandler.lastHandler = this; 
	}

	//模板处理方法，接收一个Request参数
	public abstract void handle(Request request);

}

//自定义一个请求
public class Request {
	
	//持有一个map作为属性栈
	private Map<String, Object> attributes;

	//构造时不注入，则new一个attributes
	public Request(){
		attributes = new HashMap<>();
	}
	
	//构造时注入一个attributes
	public Request(Map<String, Object> attributes){
		this.attributes = attributes;
	}

	//attributes的set、get方法
	public Map<String, Object> getAttributes() {
		return attributes;
	}
	public void setAttributes(Map<String, Object> attributes) {
		this.attributes = attributes;
	}
	
	//向attributes中添加属性
	public void setAttribute(String key,Object value){
		attributes.put(key, value);
	}
	
	//根据key从attributes中获取属性
	public Object getAttribute(String key){
		return attributes.get(key);
	}
	
}

//处理器的一个实现HandlerImplA
public class HandlerImplA extends Handler {

	public HandlerImplA(String handlerName) {
		super(handlerName);
	}

	@Override
	public void handle(Request request) {
		System.out.println("HandlerImplA打印当前request中的属性数量：" + request.getAttributes().size());
		request.setAttribute(this.handlerName + ".attr", this.handlerName + ".val");	
		nextHandler.handle(request);
	}

}

//处理器的一个实现HandlerImplB
public class HandlerImplB extends Handler {

	public HandlerImplB(String handlerName) {
		super(handlerName);
	}

	@Override
	public void handle(Request request) {
		System.out.println("HandlerImplB打印它的上一任处理名称：" + lastHandler.handlerName);
		nextHandler.handle(request);
	}

}

//最终处理请求的实现ActualHandler
public class ActualHandler extends Handler {

	public ActualHandler(String handlerName) {
		super(handlerName);
	}

	@Override
	public void handle(Request request) {
		System.out.println("ActualHandler打印request中的所有参数如下：");
		Map<String, Object> attributes = request.getAttributes();
		Set<Entry<String, Object>> entrySet = attributes.entrySet();
		for (Entry<String, Object> entry : entrySet) {
			System.out.println("request.attrName:" + entry.getKey() + " request.attrVal:" + entry.getValue());
		}
	}

}

//测试责任链模式
public static void testResponsibility(){
	//构建请求
	Request request = new Request();
	ActualHandler handler = new ActualHandler("handler");
	HandlerImplB handlerB = new HandlerImplB("handlerB");
	handlerB.setNextHandler(handler);
	HandlerImplA handlerA = new HandlerImplA("handlerA");
	handlerA.setNextHandler(handlerB);
	//从A开始处理
	handlerA.handle(request);
}

控制台打印如下：

HandlerImplA打印当前request中的属性数量：0
HandlerImplB打印它的上一任处理名称：handlerA
ActualHandler打印request中的所有参数如下：
request.attrName:handlerA.attr request.attrVal:handlerA.val

12.状态模式

应用场景：逻辑上超过 3 层的 if-else 代码可以使用卫语句，或者状态模式来实现。这句话是阿里的java开发手册中的规范，很明显，状态模式的设计就是为了替换if-else的。那么为什么要用状态模式替换if-else呢？这才是用状态模式的原因，网上大多数人云亦云的解释都说是为了便于维护和扩展，我却没觉得用了状态模式怎么就能不修改原代码的情况下进行扩展，但是还是来学习一下吧，因为确实是便于维护了

//定义一个持有状态的事物
public class ThingObject {
	
	//持有状态
	private StateTemplate state;

	//构造把状态置为null
	public ThingObject() {
		this.state = null;
	}
	
	//获取当前的状态
	public StateTemplate getState() {
		return state;
	}

	//改变当前状态，并改变对应状态的行为
	public boolean setState(StateTemplate state) {
		this.state = state;
		return state.doAction();				
	}
	
	//没有对应的状态情的况下的行为
	public static void doAction(){
		//执行没有对应状态的逻辑
		System.out.println("没有对应状态执行的逻辑");
	}
	
}

//定义一个状态模板
public abstract class StateTemplate {
	
	//状态参数
	protected int states;
	
	//构造注入状态参数
	public StateTemplate(int states){
		this.states = states;
	}

	//抽象行为
	public abstract boolean doAction();
	
}

//定义一个关于状态参数states的枚举
public enum StatesEnum {
	
	STATE1(1),STATE2(2),STATE3(3),STATE4(4),STATE5(5),STATE6(6),STATE7(7),STATE8(8);
	
	public Integer value;
	
	private StatesEnum(Integer value){
		this.value = value;
	}
	
}

//状态1实现
public class StateOne extends StateTemplate {
	
	//构造注入状态参数并交由父类
	public StateOne(int states) {
		super(states);
	}

	@Override
	public boolean doAction() {

		//如果当前状态参数是1就执行该行为，否则什么也不做
		if(super.states == StatesEnum.STATE1.value){
			System.out.println("状态111执行的逻辑");
			return true;
		}
		return false;
	}

}

//状态2实现
public class StateTwo extends StateTemplate {

	public StateTwo(int states) {
		super(states);
	}

	@Override
	public boolean doAction() {
		if(super.states == StatesEnum.STATE2.value){
			//状态2对应的行为
			System.out.println("状态222执行的逻辑");
			return true;
		}
		return false;
	}

}

//状态3实现
public class StateThree extends StateTemplate {

	public StateThree(int states) {
		super(states);
	}

	@Override
	public boolean doAction() {
		if(super.states == StatesEnum.STATE3.value){
			//状态2对应的行为
			System.out.println("状态333执行的逻辑");
			return true;
		}
		return false;
	}

}

//状态N...实现

//测试状态模式
public static void testState(int states){		
	
	ThingObject t = new ThingObject();
	if(t.setState(new StateOne(states))) return;
	if(t.setState(new StateTwo(states))) return;	
	if(t.setState(new StateThree(states))) return;
	
	//执行没有对应状态的逻辑
	ThingObject.doAction();
	
}

上述测试代码的if return可以去掉的，只是为了完全真实模拟if-else的效果才加的，如果现在我需要扩展一个条件4的情况，那么只需加一个状态模板的实现StateFour，然后再测试代码的倒数第二行在加一句if(t.setState(new StateFour(states))) return;即可，很明显客户端还是要修改源码，并没有真正的实现开闭原则。

13.访问者模式

应用场景：把对源对象的各种不同操作，抽象出来成为一个规范，然后实现该规范的各个实现类即是访问者对象，访问者持有源对象，因此可以操作源对象的数据结构。这种时候就可以使用该模式，例如开发一个模块的多张报表的时候，可以使用这种模式，如果需要新增报表，只需添加访问者即可

//被访问者对象
public class BeVisitor {

    //接受一个访问
	public void accept(IVisitor visitor) {
		visitor.visite(this);
	}

	private Integer attr1;
	private String attr2;
	private boolean attr3;

	public Integer getAttr1() {
		return attr1;
	}

	public void setAttr1(Integer attr1) {
		this.attr1 = attr1;
	}

	public String getAttr2() {
		return attr2;
	}

	public void setAttr2(String attr2) {
		this.attr2 = attr2;
	}

	public boolean isAttr3() {
		return attr3;
	}

	public void setAttr3(boolean attr3) {
		this.attr3 = attr3;
	}

}

//访问者规范
public interface IVisitor {
	void visite(BeVisitor beVisitor);
}

//访问者1
public class VisitorOne implements IVisitor {

	public void visite(BeVisitor beVisitor) {
		System.out.println("------------VisitorOne print:------------");
		System.out.println(beVisitor.getAttr1() + "---" + beVisitor.getAttr2());
	}

}

//访问者2
public class VisitorTwo implements IVisitor {

	public void visite(BeVisitor beVisitor) {
		System.out.println("------------VisitorTwo print:------------");
		if(beVisitor.isAttr3()){
			System.out.println(beVisitor.getAttr1() + "---" + beVisitor.getAttr2());
		}else{
			System.out.println("beVisitor.isAttr3(): " + false);
		}
	}

}

//测试访问者模式
public static void testVisitor(){
	BeVisitor beVisitor = new BeVisitor();
	beVisitor.setAttr1(20);
	beVisitor.setAttr2("张三");
	beVisitor.setAttr3(false);
    //接受访问者1的访问
	beVisitor.accept(new VisitorOne());
    //接受访问者2的访问
	beVisitor.accept(new VisitorTwo());
}

14.模板方法

应用场景：如果需要分别实现规范中的方法，可以使用这种模式

//规范
public interface IPhone {
	
	public void call();
	
	public void photograph();
	
	public void music();
	
	public void sendMsg();
}

//模板方法类
public abstract class PhoneTemplate implements IPhone {

	@Override
	public void call() {
		System.out.println("call()*********");
	}

	@Override
	public void sendMsg() {
		System.out.println("sendMsg()********");
	}

}

//实现Vivo
public class Vivo extends PhoneTemplate {

	@Override
	public void photograph() {
		System.out.println("vivo -> photograph()********");
	}

	@Override
	public void music() {
		System.out.println("vivo -> music()********");
	}
	
}

//实现XiaoMi
public class XiaoMi extends PhoneTemplate {

	@Override
	public void photograph() {
		System.out.println("XiaoMi -> photograph()********");
	}

	@Override
	public void music() {
		System.out.println("XiaoMi -> music()********");
	}

}

//测试
public static void main(String[] args) {
	XiaoMi xiaoMi = new XiaoMi();
	xiaoMi.call();
	xiaoMi.sendMsg();
	xiaoMi.music();
}

15.策略模式

使用场景非常广泛，一个行为有不同的表现形式的时候，可以使用策略模式。

策略模式与桥接模式在代码层面没有本质区别，只是设计的出发点不同。

例如：四则运算法则，定义一个运算行为(策略)，有加减乘除四则运算形式(策略实现)，策略持有(策略使用者)

//计算策略
public interface StrategyCalculate {

	public double calculate(double a, double b);
	
}

//默认策略实现
public class DefaultStrategyCalculate implements StrategyCalculate {

	@Override
	public double calculate(double a, double b) {
		return a + b;
	}

}

//另一个策略实现
public class SubtractionStrategyCalculate implements StrategyCalculate {

	@Override
	public double calculate(double a, double b) {
		return a - b;
	}

}

//策略使用者
public class StrategyCalculateHolder {
	
	private StrategyCalculate strategyCalculate;
	
	public StrategyCalculateHolder(StrategyCalculate strategyCalculate) {
		this.strategyCalculate = strategyCalculate;
	}
	
	public double calculate(double a, double b) {
		return this.strategyCalculate.calculate(a, b);
	}
	
	public static void main(String[] args) {
		System.out.println(new StrategyCalculateHolder(new DefaultStrategyCalculate()).calculate(20, 10));
		System.out.println(new StrategyCalculateHolder(new SubtractionStrategyCalculate()).calculate(20, 10));
	}
	
}

星晨sta

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
java常用设计模式学习总结

常用设计模式归纳：创建型：单例模式，工厂方法模式等等结构型：静态代理模式，动态代理模式，装饰者模式，适配器模式，桥接模式行为型：观察者模式，命令模式，责任链模式，状态模式，访问者模式1.单例模式应用场景：顾名思义，自始至终都操作的是同一个对象的时候，需要用单例模式/** * 单例懒汉式（比较常用） */public class SingletonPatternLa...
复制链接

扫一扫