文档章节

设计模式(3)

jit-hakase
 jit-hakase
发布于 2017/08/25 14:15
字数 845
阅读 1
收藏 0

设计模式

行为型模式

解释器模式

Context是一个上下文环境类, PlusMinus分别是用来计算的实现. 解释器模式可以用在复杂的计算方式, 适合于开发编译器和解释器.

interface Expression {
	int interpret(Context context);  
}

class Context {
	
	private int numOne, numTwo;
	
	public Context(int numOne, int numTwo) {
		this.numOne = numOne;
		this.numTwo = numTwo;
	}
	
	public int getNumOne() { return numOne; }
	public void setNumOne(int numOne) { this.numOne = numOne; }
	public int getNumTwo() { return numTwo; }
	public void setNumTwo(int numTwo) { this.numTwo = numTwo; }
}

class Minus implements Expression {
	@Override
	public int interpret(Context context) {
		return context.getNumOne() - context.getNumTwo();
	}
}

class Plus implements Expression {
	@Override
	public int interpret(Context context) {
		return context.getNumOne() + context.getNumTwo();
	}
}

public class Main {
	
	public static void main(String[] args) {
		
		Context context = new Context(10, 5);
		
		int result = new Plus().interpret(
				new Context(new Minus().interpret(context), 
						new Plus().interpret(context)));
		
		System.out.println(result);
	}
}

命令模式

将调用者, 接收者, 命令三者互相解除类间的耦合度.

interface Command {
	void exec();
}

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

class MySQLReceiver implements Receiver {
	@Override
	public void startup() {
		System.out.println("MySQL startup...");
	}
	@Override
	public void shutdown() {
		System.out.println("MySQL shutdown...");
	}
}

class OracleReceiver implements Receiver {
	@Override
	public void startup() {
		System.out.println("Oracle startup...");
	}
	@Override
	public void shutdown() {
		System.out.println("Oracle shutdown...");
	}
}

class CommandStartup implements Command {
	
	private Receiver receiver;
	
	public CommandStartup(Receiver receiver) {
		this.receiver = receiver;
	}
	@Override
	public void exec() {
		receiver.startup();
	}
}

class CommandShutdown implements Command {
	
	private Receiver receiver;
	
	public CommandShutdown(Receiver receiver) {
		this.receiver = receiver;
	}
	@Override
	public void exec() {
		receiver.shutdown();
	}
}

class Invoker {
	private Command command;
	
	public void setCommand(Command command) {
		this.command = command;
	}
	
	public void invoke() {
		command.exec();
	}
}

public class Main {
	
	public static void main(String[] args) {

		Receiver receiver = new MySQLReceiver();
		Command cmdStartup = new CommandStartup(receiver);
		Command cmdShutdown = new CommandShutdown(receiver);
		
		Invoker invoker = new Invoker();
		invoker.setCommand(cmdStartup);
		invoker.invoke();
		
		invoker.setCommand(cmdShutdown);
		invoker.invoke();
	}
}

迭代器模式

java集合类中使用的模式, 即使用迭代器对象来迭代容器对象.

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

interface Fruit {
	String getName();
}

class Apple implements Fruit {
	@Override
	public String getName() {
		return "apple";
	}
}

class Banana implements Fruit {
	@Override
	public String getName() {
		return "banana";
	}
}

class FruitColletion {
	
	private List<Fruit> fruitList = new ArrayList<>();
	
	public FruitIterator iterator() {
		return new FruitIterator(this);
	}
	
	public void add(Fruit fruit) {
		fruitList.add(fruit);
	}
	
	public void remove(Fruit fruit) {
		fruitList.remove(fruit);
	}
	
	public List<Fruit> getList() {
		return fruitList;
	}
}

class FruitIterator {
	
	private List<Fruit> fruitList;
	private int pos;
	
	public FruitIterator(FruitColletion collection) {
		fruitList = collection.getList();
	}

	public Fruit prev() {
		if (pos > 0) {
			--pos;
			return fruitList.get(pos);
		}
		return null;
	}

	public Fruit next() {
		if (pos < fruitList.size()-1) {
			++pos;
			return fruitList.get(pos);
		}
		return null;
	}

	public Fruit first() {
		pos = 0;
		return fruitList.get(pos);
	}

	public boolean hasNext() {
		if (pos >= fruitList.size()-1) {
			return false;
		}
		return true;
	}
}

public class Main {
	
	public static void main(String[] args) {
		
		Fruit appleOne = new Apple();
		Fruit bananaOne = new Banana();
		Fruit appleTwo = new Apple();
		Fruit bananaTwo = new Banana();
		
		FruitColletion collection = new FruitColletion();
		collection.add(appleOne);
		collection.add(bananaOne);
		collection.add(bananaTwo);
		collection.add(appleTwo);
		
		FruitIterator iter = collection.iterator();
		Fruit firstFruit = iter.first();
		System.out.println(firstFruit.getName());
		
		while (iter.hasNext()) {
			Fruit fruit = iter.next();
			System.out.println(fruit.getName());
		}
	}
}

备忘录模式

备份状态 - 恢复状态, 常用于保存游戏, 加载存档等.

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

class Computer {
	
	private String stat = "shutdown";
	
	public Computer(String stat) {
		this.stat = stat;
	}
	
	public Memento createMemento() {
		return new Memento(stat);
	}
	
	public void restoreMemento(Memento memento) {
		this.stat = memento.getStat();
	}
	
	public String getStat() { return stat; }
	public void setStat(String stat) { this.stat = stat; }
}

class Memento {
	
	private String stat;
	
	public Memento(String stat) {
		this.stat = stat;
	}

	public String getStat() { return stat; }
}

class Storage {
	
	private List<Memento> mementos = new ArrayList<>();
	
	public void addMemento(Memento memento) {
		mementos.add(memento);
	}
	
	public void removeMemento(Memento memento) {
		mementos.remove(memento);
	}
	
	public Memento getMemento(int history) {
		
		if (history >= 0 || history < -mementos.size()+1) {
			history = 0;
		}
		int pos = mementos.size()-1 + history;
		
		return mementos.get(pos);
	}
}

public class Main {
	
	public static void main(String[] args) {
		
		Computer computer = new Computer("startup");
		Memento mementoStartup = computer.createMemento();
		computer.setStat("running");
		Memento mementoRunning = computer.createMemento();
		computer.setStat("shutdown");
		Memento mementoShutdown = computer.createMemento();
		
		Storage storage = new Storage();
		storage.addMemento(mementoStartup);
		storage.addMemento(mementoRunning);
		storage.addMemento(mementoShutdown);
		
		computer.restoreMemento(storage.getMemento(0));
		System.out.println(computer.getStat());
		computer.restoreMemento(storage.getMemento(-1));
		System.out.println(computer.getStat());
		computer.restoreMemento(storage.getMemento(-2));
		System.out.println(computer.getStat());
		computer.restoreMemento(storage.getMemento(-3));
		System.out.println(computer.getStat());
	}
}

状态模式

当对象的状态改变时, 同时改变其行为.

class State {
	
	private String name;
	
	public State(String name) {
		this.name = name;
	}
	
	public void open() {
		System.out.println("open...");
	}
	public void running() {
		System.out.println("running...");
	}
	public void close() {
		System.out.println("close...");
	}
	
	public String getName() { return name; }
	public void setName(String name) { this.name = name; }
}

class Context {
	private State stat = new State("close");
	
	public void exec() {
		
		String statName = stat.getName();
		
		if (statName.equals("close")) {
			stat.setName("open");
			stat.open();
		} else if (statName.equals("open")) {
			stat.setName("running");
			stat.running();
		} else if (statName.equals("running")) {
			stat.setName("close");
			stat.close();
		}
	}

	public State getStat() { return stat; }
	public void setStat(State stat) { this.stat = stat; }
}

public class Main {
	
	public static void main(String[] args) {
		
		Context context = new Context();
		context.exec();
		context.exec();
		
		context.setStat(new State("close"));
		context.exec();
	}
}

© 著作权归作者所有

jit-hakase
粉丝 0
博文 26
码字总数 30408
作品 0
南京
程序员
java设计模式-- 单例模式

在很久之前,也就是在大二暑假的时候,那时候看马士兵的视频教程中有提到很多的设计模式。 java的设计模式大致可以分为3大类,23种设计模式。 其中,创建型模式有5种:单例模式、建造者模式、...

爱学习的逃课君
2014/11/27
0
0
设计模式-工厂模式/委派模式/代理模式/单例模式

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

森火
09/11
0
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

没有更多内容

加载失败,请刷新页面

加载更多

白话SpringCloud | 第五章:服务容错保护(Hystrix)

前言 前一章节,我们知道了如何利用RestTemplate+Ribbon和Feign的方式进行服务的调用。在微服务架构中,一个服务可能会调用很多的其他微服务应用,虽然做了多集群部署,但可能还会存在诸如网...

oKong
16分钟前
0
0
【解惑】领略Java内部类的“内部”

内部类有两种情况: (1) 在类中定义一个类(私有内部类,静态内部类) (2) 在方法中定义一个类(局部内部类,匿名内部类) 1、私有内部类 —— 在方法之间定义的内部类,非静态 我们首先看看类中...

偶尔诗文
58分钟前
1
0
sqlserver 2008 r2 直接下载地址(百度云)

之前下载的sqlserver2008发现不能附加,就卸载了,重新找到了sqlserver2008R2的百度云资源 卸载sqlserver2008还是有点麻烦,不过就是需要删除注册表中的信息 自己来回卸载了3次终于重装sqlse...

dillonxiao
今天
1
0
[Java]JVM调优总结 -Xms -Xmx -Xmn -Xss

JVM调优总结 -Xms -Xmx -Xmn -Xss 博客分类: Java General JVM应用服务器电信CMS算法 堆大小设置 JVM 中最大堆大小有三方面限制:相关操作系统的数据模型(32-bt还是64-bit)限制;系统的可...

morpheusWB
今天
2
0
C++ std::function 和 std::bind

C++11提供了std::function和std::bind两个工具,用于引用可调用对象。这些可调用对象包括 普通函数,Lambda表达式,类的静态成员函数,非静态成员函数以及仿函数等。引用可调用对象,可以用于...

yepanl
今天
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部