文档章节

设计模式(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);
	}
}

© 著作权归作者所有

上一篇: DFS算法
下一篇: 设计模式(3)
jit-hakase
粉丝 1
博文 26
码字总数 30408
作品 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
【设计模式笔记】(十六)- 代理模式

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

MrTrying
06/24
0
0
设计模式已经陨落了?

你现在是坐在一个程序员旁边吗?如果是的话,那么在你读下面的段落之前,有一个简单的实验。让他们到一边去,问问他们两个问题并记录下答案。首先问他们“什么是设计模式?”然后再问“说出你...

oschina
2014/03/11
9.1K
69
《PHP设计模式大全》系列分享专栏

《PHP设计模式大全》已整理成PDF文档,点击可直接下载至本地查阅 https://www.webfalse.com/read/201739.html 文章 php设计模式介绍之编程惯用法第1/3页 php设计模式介绍之值对象模式第1/5页...

kaixin_code
11/06
0
0
炒冷饭系列:设计模式 抽象工厂模式

炒冷饭系列:设计模式 抽象工厂模式 摘要: 原创出处: http://www.cnblogs.com/Alandre/ 泥沙砖瓦浆木匠 希望转载,保留摘要,谢谢! 亲爱我,孝何难;亲恶我,孝方贤。 一、什么是抽象工厂模...

泥沙砖瓦浆木匠
2014/07/24
0
0

没有更多内容

加载失败,请刷新页面

加载更多

大数据教程(9.5)用MR实现sql中的jion逻辑

上一篇博客讲解了使用jar -jar的方式来运行提交MR程序,以及通过修改YarnRunner的源码来实现MR的windows开发环境提交到集群的方式。本篇博主将分享sql中常见的join操作。 一、需求 订单数据表...

em_aaron
15分钟前
1
0
十万个为什么之什么是resultful规范

起源 越来越多的人开始意识到,网站即软件,而且是一种新型的软件。这种"互联网软件"采用客户端/服务器模式,建立在分布式体系上,通过互联网通信,具有高延时(high latency)、高并发等特点...

尾生
21分钟前
1
0
《告诉你真实的美国教育》的读后感3900字

《告诉你真实的美国教育》的读后感3900字: 文章的开篇分析了我们耳熟能详的关于美国教育的小故事,就是那个因为幼儿园的老师教了“0”这个字母,然后妈妈告老师剥夺了孩子的想象力,再然后幼...

原创小博客
29分钟前
0
0
Terraform配置文件(Terraform configuration)

Terraform配置文件 翻译自Terraform Configuration Terraform用文本文件来描述设备、设置变量。这些文件被称为Terraform配置文件,以.tf结尾。这一部分将讲述Terraform配置文件的加载与格式。...

buddie
44分钟前
2
0
exportfs命令, vsftp搭建ftp服务

exportfs命令 当修改/etc/exports文件后,更改的内容是不会立即生效的。如果重启nfs服务,会导致客户端重启期间的请求是挂起等待的,可以把客户端的挂载umount进行卸载后,再重启nfs服务,但...

野雪球
55分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部