文档章节

设计模式(4)

jit-hakase
 jit-hakase
发布于 2017/08/29 13:54
字数 919
阅读 2
收藏 0

设计模式

行为型模式

策略模式(strategy)

策略模式多用在算法决策系统中, 外部用户只需要决定用哪个算法即可.

interface Algorithm {
	void exec();
}

class Dijkstra implements Algorithm {

	@Override
	public void exec() {
		System.out.println("dijkstra algorithm...");
	}
}

class Floyd implements Algorithm {

	@Override
	public void exec() {
		System.out.println("floyd algorithm...");
	}
	
}

public class Main {
	
	public static void main(String[] args) {
		
		Algorithm algo = new Dijkstra();
		algo.exec();
	}
}

中介者模式(Mediator)

使用这种模式能够减少对象两两之间复杂的引用关系, 使之成为一个松耦合的系统.

与Facade不同的是, Facade是单向的, 而Mediator是双向的.

interface Hardware {  
	void startup();
	void shutdown();
}

class CPU implements Hardware {
	
	private Mediator mediator;
	
	public CPU(Mediator mediator) {
		this.mediator = mediator;
	}
	
	public Mediator getMediator() {
		return mediator;
	}
	
	@Override
	public void startup() {
		System.out.println("CPU startup...");
	}
	@Override
	public void shutdown() {
		System.out.println("CPU shutdown...");
	}
}

class Memory implements Hardware {
	
	private Mediator mediator;
	
	public Memory(Mediator mediator) {
		this.mediator = mediator;
	}
	
	public Mediator getMediator() {
		return mediator;
	}
	
	@Override
	public void startup() {
		System.out.println("memory startup...");
	}
	@Override
	public void shutdown() {
		System.out.println("memory shutdown...");
	}
}

class Mediator {
	
	private CPU cpu;
	private Memory memory;
	
	public void createMediator() {
		cpu = new CPU(this);
		memory = new Memory(this); 
	}
	
	public void startup() {
		cpu.startup();
		memory.startup();
	}
	
	public void shutdown() {
		memory.shutdown();
		cpu.shutdown();
	}

	public CPU getCpu() { return cpu; }
	public Memory getMemory() { return memory; }
}

public class Main {
	
	public static void main(String[] args) {
		
		Mediator mediator = new Mediator();
		mediator.createMediator();
		
		mediator.startup();
		mediator.shutdown();
	}
}

责任链模式(Chain of Responsibility)

每个对象持有对下一个对象的引用, 这样就会形成一条链, 请求在这条链上传递, 直到某一对象决定处理该请求. 但发出者并不清楚到底最终那个对象会处理该请求, 所以在隐瞒客户端的情况下, 可以对系统进行动态调整. 链接上的请求可以是链和树, 还可以是一个环, 命令只允许由一个对象传给另一个对象, 而不允许传给多个对象.

class Handler {
	
	private String operator;
	private Handler handler;
	
	public Handler(String operator) {
		this.operator = operator;
	}

	public void setHandler(Handler handler) {
		this.handler = handler;
	}
	
	public void operate() {
		System.out.println(operator + " operate...");
		if (handler != null) {
			handler.operate();
		}
	}
}

public class Main {
	
	public static void main(String[] args) {
		
		Handler startupHandler = new Handler("startup");
		Handler actionHandler = new Handler("action");
		Handler shutdownHandler = new Handler("shutdown");
		
		startupHandler.setHandler(actionHandler);
		actionHandler.setHandler(shutdownHandler);
		
		startupHandler.operate();
	}
}

模板方法模式(Template method)

定义一个操作中的算法的骨架, 而将一些步骤延迟到子类中.

abstract class OS {
	
	public final void process() {
		startup();
		loadCore();
		shutdown();
	}
	
	private void startup() {
		System.out.println("startup...");
	}
	
	public abstract void loadCore();
	
	private void shutdown() {
		System.out.println("shutdown...");
	}
}

class Linux extends OS {
	@Override
	public void loadCore() {
		System.out.println("load linux-core...");	
	}
}

class Windows extends OS {
	@Override
	public void loadCore() {
		System.out.println("load windows-core...");	
	}
}

public class Main {
	
	public static void main(String[] args) {
      
		OS os = new Linux();
		os.process();
	}
}

观察者模式(Observer)

定义对象间的一种一对多的依赖关系, 当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新, 常用于事件触发.

import java.util.ArrayList;
import java.util.List;

interface Observer {
	void update();
}

class MouseObserver implements Observer {
	@Override
	public void update() {
		System.out.println("update mouse observer");
	}
}

class KeyboardObserver implements Observer {
	@Override
	public void update() {
		System.out.println("update keyboard observer");
	}
}

interface Subject {
	void add(Observer observer);
	void remove(Observer observer);
	void notifyObservers();
	void operate();
}

abstract class AbstractSubject implements Subject {
  
	private List<Observer> observers = new ArrayList<>();
	
	@Override
	public void add(Observer observer) {
		observers.add(observer);
	}
	@Override
	public void remove(Observer observer) {
		observers.remove(observer);
	}
	@Override
	public void notifyObservers() {
		for (Observer ob : observers) {
			ob.update();
		}
	}
}

class Game extends AbstractSubject {
	@Override
	public void operate() {
		System.out.println("notify observers...");
		super.notifyObservers();
	}
}

public class Main {
  
	public static void main(String[] args) {
		
		Game game = new Game();
		
		game.add(new MouseObserver());
		game.add(new KeyboardObserver());
		
		game.operate();
	}
}

访问者模式(Visitor)

访问者模式适用于数据结构相对稳定的系统, 能解除数据结构和算法的耦合性.

不同身份访问不同对象的例子

interface Visitor {
	void visit(Subject subject);
}

class AdminVisitor implements Visitor {
	@Override
	public void visit(Subject subject) {
		System.out.println("admin visit: " + subject.getName());
	}
}

class GuestVisitor implements Visitor {
	@Override
	public void visit(Subject subject) {
		if (subject.getName().equals("admin")) {
			System.out.println("deny...");
		} else {
			System.out.println("guest visit: " + subject.getName());
		}
	}
}

interface Subject {
	void accept(Visitor visitor);
	String getName();
}

class GuestSubject implements Subject {
	@Override
	public String getName() {
		return "guest";
	}
	@Override
	public void accept(Visitor visitor) {
		visitor.visit(this);
	}
}

class AdminSubject implements Subject {
	@Override
	public String getName() {
		return "admin";
	}
	@Override
	public void accept(Visitor visitor) {
		visitor.visit(this);
	}
}

public class Main {
	
	public static void main(String[] args) {
		
		Subject adminSubject = new AdminSubject();
		Subject guestSubject = new GuestSubject();
		
		Visitor adminVisitor = new AdminVisitor();
		Visitor guestVisitor = new GuestVisitor();
		
		adminSubject.accept(adminVisitor);
		adminSubject.accept(guestVisitor);
		
		guestSubject.accept(adminVisitor);
		guestSubject.accept(guestVisitor);
	}
}

© 著作权归作者所有

jit-hakase
粉丝 0
博文 26
码字总数 30408
作品 0
南京
程序员
代理模式(Proxy Pattern):动态代理 - 最易懂的设计模式解析

前言 今天我来全面总结开发中最常用的设计模式 - 代理模式中的动态代理模式 其他设计模式介绍 1分钟全面了解“设计模式” 单例模式(Singleton) - 最易懂的设计模式解析 简单工厂模式(Sim...

Carson_Ho
04/09
0
0
JavaScript常用设计模式

设计模式 设计模式是一种在长时间的经验与错误中总结出来可服用的解决方案。 设计模式主要分为3类: 创建型设计模式:专注于处理对象的创建 Constructor构造器模式,Factory工厂模式,Singl...

a独家记忆
07/13
0
0
设计模式 2014-12-19

book: 阎宏《JAVA与模式》 架构设计栏目 http://blog.csdn.net/enterprise/column.html 概要: http://bbs.csdn.net/forums/Embeddeddriver 23种设计模式分别是: 1.单例模式 2.工厂方法模式...

jayronwang
2014/12/19
0
0
系统架构技能之设计模式-单件模式

一、开篇 其实我本来不是打算把系统架构中的一些设计模式单独抽出来讲解的,因为很多的好朋友也比较关注这方面的内容,所以我想通过我理解及平时项目中应用到的一 些常见的设计模式,拿出来给...

wbf961127
2017/11/12
0
0
【设计模式笔记】(十六)- 代理模式

一、简述 代理模式(Proxy Pattern),为其他对象提供一个代理,并由代理对象控制原有对象的引用;也称为委托模式。 其实代理模式无论是在日常开发还是设计模式中,基本随处可见,中介者模式中...

MrTrying
06/24
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

jetbrains系产品IDEA:mac上面提示快捷键设置

原因 由于Mac上面的Ctrl+空格变成输入法切换的快捷键,在使用IDEA的过程中,代码提示很不方便,需要使用option+/这种传统eclipse上面的代码提示快捷键作为主要快捷键。 怎么修改? 移除【opt...

亚林瓜子
33分钟前
0
0
Exclipse 输出结果时换行

System.out.println(f1 + "\n" + d1 + "\n" + d2);

笑丶笑
34分钟前
1
0
怎样治疗标签不能触发onblur事件

I realize this was over a year ago, but it showed up for me in Google while trying to solve this same issue. It seems Chrome does not consider some elements, like body and ancho......

Weijuer
37分钟前
0
0
vue常见库安装

移动设备上的浏览器默认会在用户点击屏幕大约延迟300毫秒后才会触发点击事件,这是为了检查用户是否在做双击。为了能够立即响应用户的点击事件,才有了FastClick。 安装fastclick npm insta...

林夏夕
39分钟前
0
0
kafka 教程(三) kafka Java API 编程

下午写

MrPei
40分钟前
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部