设计模式(3)
设计模式(3)
jit-hakase 发表于4个月前
设计模式(3)
  • 发表于 4个月前
  • 阅读 1
  • 收藏 0
  • 点赞 0
  • 评论 0
摘要: 行为型(1)

设计模式

行为型模式

解释器模式

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();
	}
}
标签: 设计模式 java
  • 点赞
  • 收藏
  • 分享
粉丝 0
博文 23
码字总数 29680