文档章节

设计模式(4)

jit-hakase
 jit-hakase
发布于 2017/08/29 13:54
字数 919
阅读 2
收藏 0
点赞 0
评论 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

系统架构技能之设计模式-单件模式

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

wbf961127 ⋅ 2017/11/12 ⋅ 0

C#设计模式(2)——简单工厂模式

一、引言   这个系列也是自己对设计模式的一些学习笔记,希望对一些初学设计模式的人有所帮助的,在上一个专题中介绍了单例模式,在这个专题中继续为大家介绍一个比较容易理解的模式——简单工...

技术小胖子 ⋅ 2017/11/08 ⋅ 0

JavaScript设计模式之观察者模式

前言 准备研究一下MVVM的一些东西,由于MVVM运用了观察者模式的思想,因此翻开了《JavaScript设计模式与开发实践》一书,将观察者模式学习了一遍,顺便有对一些常用的设计模式进行一些了解,...

Srtian ⋅ 05/22 ⋅ 0

JavaScript 中常见设计模式整理

开发中,我们或多或少地接触了设计模式,但是很多时候不知道自己使用了哪种设计模式或者说该使用何种设计模式。本文意在梳理常见设计模式的特点,从而对它们有比较清晰的认知。 JavaScript 中...

牧云云 ⋅ 05/18 ⋅ 0

设计模式之禅(第2版).epub

【下载地址】 本书是设计模式领域公认的3本经典著作之一,“极具趣味,容易理解,但讲解又极为严谨和透彻”是本书的写作风格和方法的最大特点。第1版2010年出版,畅销至今,广受好评,是该领...

winter730 ⋅ 05/16 ⋅ 0

设计模式梳理(一)

设计模式梳理(一) 总体来说设计模式分为三大类: @案例源码地址:https://gitlab.com/lxqxsyu/DisgnPattern 创建型模式 简单工厂模式 工厂类是整个模式的关键。它包含必要的判断逻辑,能够...

lxq_xsyu ⋅ 2017/11/02 ⋅ 0

一天一篇设计模式之--工厂模式与抽象工厂模式(创建型模式)

工厂模式与抽象工厂模式主要解决接口选择问题。 一、工厂模式 当明确计划需要在不同条件下创建不同实例时,可以使用工厂模式。 实例:发送邮件或者短信 1、创建发送信息的接口 2、创建两个实...

Timor_张先生 ⋅ 04/10 ⋅ 0

Java经典设计模式-结构型模式-适配器模式(Adapter)

适配器模式 适配器模式主要分为三类:类的适配器模式、对象的适配器模式、接口的适配器模式。 适配器模式将某个类的接口转换成客户端期望的另一个接口表示,目的是消除由于接口不匹配所造成的...

Idea ⋅ 01/20 ⋅ 0

设计模式.策略模式

策略模式跟抽象工厂非常相似,基本逻辑是根据需要实例化出需要用的类。不同的是策略模式需要调用者非常清晰的知道有哪些策略,各个策略的调用规则,而抽象工厂的话,需要知道有哪些类,找到调...

技术小胖子 ⋅ 2017/11/08 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

到底会改名吗?微软GVFS 改名之争

微软去年透露了 Git Virtual File System(GVFS)项目,GVFS 是 Git 版本控制系统的一个开源插件,允许 Git 处理 TB 规模的代码库,比如 270 GB 的 Windows 代码库。该项目公布之初就引发了争...

linux-tao ⋅ 18分钟前 ⋅ 0

笔试题之Java基础部分【简】【二】

1.静态变量和实例变量的区别 在语法定义上的区别:静态变量前要加static关键字,而实例变量前则不加。在程序运行时的区别:实例变量属于某个对象的属性,必须创建了实例对象,其中的实例变...

anlve ⋅ 35分钟前 ⋅ 0

Lombok简单介绍及使用

官网 通过简单注解来精简代码达到消除冗长代码的目的 优点 提高编程效率 使代码更简洁 消除冗长代码 避免修改字段名字时忘记修改方法名 4.idea中安装lombnok pom.xml引入 <dependency> <grou...

to_ln ⋅ 54分钟前 ⋅ 0

【转】JS浮点数运算Bug的解决办法

37.5*5.5=206.08 (JS算出来是这样的一个结果,我四舍五入取两位小数) 我先怀疑是四舍五入的问题,就直接用JS算了一个结果为:206.08499999999998 怎么会这样,两个只有一位小数的数字相乘,怎...

NickSoki ⋅ 59分钟前 ⋅ 0

table eg

user_id user_name full_name 1 zhangsan 张三 2 lisi 李四 `` ™ [========] 2018-06-18 09:42:06 星期一½ gdsgagagagdsgasgagadsgdasgagsa...

qwfys ⋅ 今天 ⋅ 0

一个有趣的Java问题

先来看看源码: public class TestDemo { public static void main(String[] args) { Integer a = 10; Integer b = 20; swap(a, b); System.out......

linxyz ⋅ 今天 ⋅ 0

十五周二次课

十五周二次课 17.1mysql主从介绍 17.2准备工作 17.3配置主 17.4配置从 17.5测试主从同步 17.1mysql主从介绍 MySQL主从介绍 MySQL主从又叫做Replication、AB复制。简单讲就是A和B两台机器做主...

河图再现 ⋅ 今天 ⋅ 0

docker安装snmp rrdtool环境

以Ubuntu16:04作为基础版本 docker pull ubuntu:16.04 启动一个容器 docker run -d -i -t --name flow_mete ubuntu:16.04 bash 进入容器 docker exec -it flow_mete bash cd ~ 安装基本软件 ......

messud4312 ⋅ 今天 ⋅ 0

OSChina 周一乱弹 —— 快别开心了,你还没有女友呢。

Osc乱弹歌单(2018)请戳(这里) 【今日歌曲】 @莱布妮子 :分享吴彤的单曲《好春光》 《好春光》- 吴彤 手机党少年们想听歌,请使劲儿戳(这里) @clouddyy :小萝莉街上乱跑,误把我认错成...

小小编辑 ⋅ 今天 ⋅ 9

Java 开发者不容错过的 12 种高效工具

Java 开发者常常都会想办法如何更快地编写 Java 代码,让编程变得更加轻松。目前,市面上涌现出越来越多的高效编程工具。所以,以下总结了一系列工具列表,其中包含了大多数开发人员已经使用...

jason_kiss ⋅ 昨天 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部