文档章节

设计模式(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
设计模式-工厂模式/委派模式/代理模式/单例模式

1.工厂模式:spring中运用的都是工厂模式,不参与业务的枚举就是工厂模式,所有人均可以调用,工厂模式就是在底层框架中写好. 例如:new 了一个Map 那这个Map创造的过程其实是底层工厂模式代码创造...

森火
09/11
0
0
设计模式知识汇总(附github分享)

写在前面 主要内容 为了更系统的学习设计模式,特地开了这样一个基于Java的设计模式【集中营】,都是笔者在实际工作中用到过或者学习过的一些设计模式的一些提炼或者总检。慢慢地初见规模,也...

landy8530
10/10
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

没有更多内容

加载失败,请刷新页面

加载更多

linux使用ntfs-3g操作ntfs格式硬盘

Linux内核目前只支持对微软NTFS文件系统的读取。 NTFS-3G 是微软 NTFS 文件系统的一个开源实现,同时支持读和写。NTFS-3G 开发者使用 FUSE 文件系统来辅助开发,同时对可移植性有益。 安装 ...

linuxprobe16
今天
1
0
kubeadm部署kubernetes集群

一、环境要求 这里使用RHEL7.5 master、etcd:192.168.10.101,主机名:master node1:192.168.10.103,主机名:node1 node2:192.168.10.104,主机名:node2 所有机子能基于主机名通信,编辑...

人在艹木中
今天
10
0
Shell特殊符号总结以及cut,sort,wc,uniq,tee,tr,split命令

特殊符号总结一 * 任意个任意字符 ? 任意一个字符 # 注释字符 \ 脱义字符 | 管道符 # #号后的备注被忽略[root@centos01 ~]# ls a.txt # 备注 a.txt[root@centos01 ~]# a=1[root@centos01...

野雪球
今天
3
0
OSChina 周二乱弹 —— 程序员圣衣

Osc乱弹歌单(2018)请戳(这里) 【今日歌曲】 @达尔文:分享Skeeter Davis的单曲《The End of the World》 《The End of the World》- Skeeter Davis 手机党少年们想听歌,请使劲儿戳(这里...

小小编辑
今天
20
0
[ python import module ] 导入模块

import moudle_name ----> import module_name.py ---> import module_name.py文件路径 -----> sys.path (这里进行查找文件) # from app.web import Personimport app.web.Person as Pe......

_______-
昨天
5
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部