[软件构造复习] 设计模式2

面向可维护性

Factory 工厂生产方法

产品、工厂都是接口，具体产品、具体工厂实现接口，每个工厂只生产一个产品

public interface Product {
	public void show();
}
public interface Factory {
	public Product newInstance(String str);
}
public class Apple implements Product {
	String str = "";
	public Apple(String str) {
		this.str = str+" apple!";
		System.out.println("Apple Producted!");
	}
	@Override
	public void show() {
		System.out.println(str);
	}
}
public class AppleFactory implements Factory {
	@Override
	public Product newInstance(String str) {
		return new Apple(str);
	}
}
public class Client {
	public static void main(String[] args) {
		Factory f = new AppleFactory();
		Product p = f.newInstance("Good");
		p.show();
	}
}

Abstract Factory 抽象工厂生产方法

抽象工厂和工厂类似，只是一个工厂可以生产一系列配套的组件，比如Windows的窗口、按钮等等，不再赘述

Proxy 代理模式

当加载对象代价较大时，可用代理缓存，避免重复加载；另一方面，也可用作“防火墙”，将内外部数据隔离

public interface Subject {
	public int access(int id);
}
public class Proxy implements Subject{
	Map<Integer,Integer> M = new HashMap<>();
	Sql S = new Sql();
	@Override
	public int access(int id) {
		Integer x = M.get(id);
		if(x==null) {
			x = S.access(id);
			M.put(id, x);
		}
		return x;
	}
}
public class Sql implements Subject{
	@Override
	public int access(int id) {
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			id++;
		}
		System.out.println("Access Sql Once");
		return (id-1)*(id+7);
	}
}
public class Client {
	public static void main(String[] args) {
		Subject S = new Proxy();
		System.out.println(S.access(3));
		System.out.println(S.access(5));
		System.out.println(S.access(3));
	}
}

Observer 观察者模式

类似新闻推送，明星维护观察者队列，将信息推送给观察者

public interface Subject {
	public void attach(Observer o);
	public void detach(Observer o);
	public void pushaway();//推送
}
public interface Observer {
	public void update(String str);
}
public class SubjectA implements Subject{
	Set<Observer> set = new HashSet<>();
	@Override
	public void attach(Observer o) {
		set.add(o);
	}
	@Override
	public void detach(Observer o) {
		set.remove(o);
	}
	@Override
	public void pushaway() {
		for(Observer o:set) {
			o.update("message from A");
		}
	}
}
public class ObserverA implements Observer{
	String name = "";
	public ObserverA(String name) {
		this.name = name;
	}
	@Override
	public void update(String str) {
		System.out.println(name+" :"+str);		
	}
}
public class Client {
	public static void main(String[] args) {
		Observer a = new ObserverA("Oa");
		Observer b = new ObserverA("Ob");
		Subject S = new SubjectA();
		S.attach(a);
		S.attach(b);
		S.pushaway();
		S.detach(b);
		S.pushaway();
	}
}

visitor 访问者模式

将数据与其上处理分离，产品接受(accept)访问,调用访问者的访问方法(visit)以多态形式访问具体产品本身

public interface Product {
	public int accept(Guest g);
	public int getAmount();
}
public interface Guest {
	public int visit(Apple p);//以多态形式对具体类访问
	public int visit(Banana p);
}
public class Apple implements Product{
	int amount=0;
	public Apple(int amount) {
		this.amount = amount;
	}
	@Override
	public int accept(Guest g) {
		return g.visit(this);
	}
	@Override
	public int getAmount() {
		return amount;
	}
}
public class Banana implements Product{
	int amount=0;
	public Banana(int amount) {
		this.amount = amount;
	}
	@Override
	public int accept(Guest g) {
		return g.visit(this);
	}
	@Override
	public int getAmount() {
		return amount;
	}
}
public class Gold implements Guest{
	@Override
	public int visit(Apple p) {
		return p.getAmount() * 4;
	}
	@Override
	public int visit(Banana p) {
		return p.getAmount() * 6;
	}
}
public class Client {
	public static void main(String[] args) {
		Apple a = new Apple(10);
		Banana b = new Banana(7);
		Guest g = new Gold();
		System.out.println(a.accept(g));
		System.out.println(b.accept(g));
	}
}

state 状态模式

将状态转换单独抽出成一个类，以委托形式进行复用。相当于做成状态自动机。

public interface State {
	public State getState();
	public void solve(int a,int b);
	public State reverse();
}
public class Sub implements State{
	private static State instance = new Sub();
	private Sub() {}
	public static State getInstance() {
		return instance;
	}
	@Override
	public State getState() {
		return this;
	}
	@Override
	public void solve(int a, int b) {
		System.out.println(a-b);
	}
	@Override
	public State reverse() {
		return Add.getInstance();
	}
}
public class Add implements State{
	private static State instance = new Add();
	private Add() {}
	public static State getInstance() {
		return instance;
	}
	@Override
	public State getState() {
		return this;
	}
	@Override
	public void solve(int a, int b) {
		System.out.println(a+b);
	}
	@Override
	public State reverse() {
		return Sub.getInstance();
	}
}
public class Client {
	public static void main(String[] args) {
		State S = Add.getInstance();
		S.solve(3, 7);
		S=S.reverse();
		S.solve(6, 9);
	}
}

memento 备忘录模式

将状态等重要信息以备忘录导出，可根据备忘录回滚到之前状态。具体实现略