23种设计模式的代码

package lq.test;

import java.io.*;
import java.util.*;

//*********创建型模式***************

//factory method 1
//1具体的构造算法，和2构造出的具体产品由子类实现	
interface Product {
}

//或者我也提供一个工厂的接口，由这个抽象类来继承它

abstract class Factory {
	abstract public Product fmd();;
	
	//我认为这个方方法的存在是，是对FactoryMethod方法的补充
	//例如可以为生成的对象赋值，计算为生成对象应付何值，前后的日值
	//且这些都是公用的，生成产品的最主要算法还是在FactoryMethod中，
	//这个方法只是起辅助作用，这也是一种思维方法，将具体的算法实现在一个方法中
	//而我不直接调用此方法，而使用另外的一个方法封装它，等到了更灵活的效果，而
	//子类需实现的内容是FactoryMethod
	//此方法是一个TemplateMethod
	public Product creat(); {
		Product pd = null;
		
		System.out.println("before operation");;
		
		pd = fmd();;
		
		System.out.println("end operation");;
	
		return pd;
	}
}

class Product1 implements Product {
}

class Factory1 extends Factory {
	public Product fmd(); {
		Product pd = new Product1();;
		return pd;
	}
}

//FactroyMethod 2
//这种方式简单实用
interface Producta {
}

interface Factorya {
	Producta create();;
}

class Producta1 implements Producta {}

class Factorya1 implements Factorya {
	public Producta create(); {
		Producta pda = null;
		pda = new Producta1();;
		return pda;
	} 
}

//AbstractFactory
//AbstractFactory与FactoryMethod的不同在于AbstractFactory创建多个产品
//感觉此模式没有什么大用

//当然可以还有更多的接口
interface Apda {}

interface Apdb {}

interface Afactory {
	Apda createA();;
	Apdb createB();;
}

class Apda1 implements Apda {}

class Apdb1 implements Apdb {}

//有几个接口就有几个对应的方法
class Afactory1 implements Afactory {
	public Apda createA(); {
		Apda apda = null;
		apda = new Apda1();;
		return apda;
	}
	
	public Apdb createB(); {
		Apdb apdb = null;
		apdb = new Apdb1();;
		return apdb;		
	}
}

//Builder
//一个产品的生成分为生成部件和组装部件，不同的产品每个部件生成的方式不同
//而组装的方式相同，部件的生成抽象成接口方法，而组装的方法使用一个TemplateMethod方法

interface Cpda {}

class Cpda1 implements Cpda {}

interface BuilderI {
	void buildPart1();;
	void buildPart2();;
	
	void initPd();;
	Cpda getPd();;
}

abstract class BuilderA implements BuilderI {
	Cpda cpda;
	
	public Cpda getPd(); {
		initPd();;
		
		//对对象的内容进行设置
		buildPart1();;
		buildPart2();;
		
		return cpda;
	}
}

class Builder extends BuilderA {
	public void buildPart1(); {
		System.out.println(cpda);;
	}
	
	public void buildPart2(); {
		System.out.println(cpda);;
	}
	
	public void initPd(); {
		cpda = new Cpda1();;
	}	
}

//一个简单的生成产品的实现
//1
abstract class Fy {
	public abstract void med1();; 
	
	static class Fy1 extends Fy {
		public void med1(); {
		}
	}
	
	public static Fy getInstance(); {
		Fy fy = new Fy1();;
		return fy;
		
//		Fy fy = new Fy1(); {//这种匿名内部类是静态的！！
//			public void med1(); {
//			}
//		};		
//		return fy;
	}
}

//2
interface Pdd {}

class Pdd1 implements Pdd {}

abstract class Fya {
	public static Pdd getPd(); {
		Pdd pdd = new Pdd1();;
		return pdd;
	}
}

//Prototype 在java中就是clone，又包含深拷贝和浅拷贝
class CloneObja {
	public CloneObja MyClone(); {
		return new CloneObja();;
	}
}

class CloneObjb {
	public CloneObjb MyClone(); throws Throwable {
		CloneObjb cobj = null;
		cobj = (CloneObjb); pcl(this);;
		return cobj;
	}	
	
	//深度拷贝算法
	private Object pcl(Object obj); throws Throwable {
		ByteArrayOutputStream bao = new ByteArrayOutputStream(1000);;
		ObjectOutputStream objo = new ObjectOutputStream(bao);;
		objo.writeObject(obj);;
		
		ByteArrayInputStream bai = new ByteArrayInputStream(bao.toByteArray(););;
		ObjectInputStream obji = new ObjectInputStream(bai);;
		
		Object objr = obji.readObject();;
		return objr;
	} 
}

//Singleton
//一个类只有一个对象，例如一个线程池，一个cache
class Singleton1 {
	public static Singleton1 instance = new Singleton1();;	
	
	private Singleton1(); {		
	}
	
	public static Singleton1 getInstance(); {
		return instance;
	}
}

class Singleton2 {
	public static Singleton2 instance;
	
	private Singleton2(); {
	}
	
//	public static Singleton2 getInstance(); {		
//		if (instance == null); {
//			instance = new Singleton2();;
//		}
//		
//		return instance;
//	}
	
	public static Singleton2 getInstance(); {
		synchronized(Singleton2.class); {
			if (instance == null); {
				instance = new Singleton2();;
			}
		}
		
		return instance;
	}
}

//**********结构型模式**********

//Adapter
//基本方法有两种，一种是使用引用一种使用继承
//将不符合标准的接口转成符合标准的接口，接口的修改主要是参数的增减，
//返回值类型,当然还有方法名
//感觉这就是封装的另一种表示形式，封装有用方法封装(在方法中调用功能方法);，
//用类封装(先传入功能方法所在的类的对象，通过调用此对象的功能方法);

//使用引用的形式
class Adapteea {
	public void kk(); {}
}

interface Targeta {
	String vv(int i, int k);;
}

class Adaptera implements Targeta{
	Adapteea ade;
	
	public Adaptera(Adapteea ade); {
		this.ade = ade;
	}
	
	public String vv(int i, int k); {
		//具体的业务方法实现在Adaptee中，这个方法
		//只起到了接口转换的作用
		//调用此方法是通过引用
		ade.kk();;
		return null;
	}
}

//使用继承形式的
class Adapteeb {
	public void kk(); {}
}

interface Targetb {
	String vv(int i, int k);;
}

class Adapterb extends Adapteeb implements Targetb {
	public String vv(int i, int k); {
		//调用此方法是通过继承
		kk();;
		return null;
	}
}

//Proxy
interface Subject {
	void request();;
} 

class realSubject implements Subject {
	public void request(); {		
		//do the real business
	}
}

class Proxy implements Subject {
	Subject subject;
	
	public Proxy(Subject subject); {
		this.subject = subject;
	}
	
	public void request(); {
		System.out.println("do something");;
		
		subject.request();;
		
		System.out.println("do something");;
	}
}

//Bridge
//感觉就是多态的实现

interface Imp {
	void operation();;
}

class Cimp1 implements Imp {
	public void operation(); {
		System.out.println("1");;
	}
}

class Cimp2 implements Imp {
	public void operation(); {
		System.out.println("2");;
	}
}

class Invoker {
	Imp imp = new Cimp1();;
	
	public void invoke(); {
		imp.operation();;
	}
}

//Composite

interface Component {
	void operation();;
	
	void add(Component component);;
	
	void remove(Component component);;
}

class Leaf implements Component {
	public void operation(); {
		System.out.println("an operation");;
	}
	
	public void add(Component component); {
		throw new UnsupportedOperationException();;
	}
	
	public void remove(Component component); {
		throw new UnsupportedOperationException();;
	}
}

class Composite implements Component {
	List components = new ArrayList();;
	
	public void operation(); {
		Component component = null;
		
		Iterator it = components.iterator();;		
		while (it.hasNext();); {
			//不知道此component对象是leaf还是composite，
			//如果是leaf则直接实现操作，如果是composite则继续递归调用
			component = (Component); it.next();;
			component.operation();;
		}
	}
	
	public void add(Component component); {		
		components.add(component);;
	}
	
	public void remove(Component component); {		
		components.remove(component);;
	}
}

//Decorator
//对一个类的功能进行扩展时，我可以使用继承，但是不够灵活，所以选用了
//另外的一种形式,引用与继承都可活得对对象的一定的使用能力，而使用引用将更灵活
//我们要保证是对原功能的追加而不是修改，否则只能重写方法，或使用新的方法
//注意concrete的可以直接new出来，
//而decorator的则需要用一个另外的decorator对象才能生成对象
//使用对象封装，和公用接口
//Decorator链上可以有多个元素

interface Componenta {
	void operation();;
}

class ConcreteComponent implements Componenta {
	public void operation(); {
		System.out.println("do something");;
	}
}

class Decorator implements Componenta {
	private Componenta component;
	
	public Decorator(Componenta component); {
		this.component = component;
	}
	
	public void operation(); {
		//do something before
		
		component.operation();;
		
		//do something after
	}
}

//Facade
//非常实用的一种设计模式，我可以为外部提供感兴趣的接口

class Obj1 {
	public void ope1(); {}
	public void ope2(); {}
}

class Obj2 {
	public void ope1(); {}
	public void ope2(); {}
}

class Facade {
	//我得到了一个简洁清晰的接口
	public void fdMethod(); {
		Obj1 obj1 = new Obj1();;
		Obj2 obj2 = new Obj2();;
		
		obj1.ope1();;
		obj2.ope2();;
 	}
}

//Flyweight
//空

//**********行为型模式*************

//Chain of Responsibility
//与Decorator的实现形式相类似，
//Decorator是在原来的方法之上进行添加功能，而
//Chain则是判断信号如果不是当前处理的则转交个下一个节点处理
//我可以使用if分支来实现相同的效果，但是不够灵活，链上的每个节点是可以替换增加的，相对
//比较灵活，我们可以设计接口实现对节点的增删操作，而实现更方便的效果
//这个是一个链状的结构，有没有想过使用环状结构

interface Handler {
	void handRequest(int signal);;
}

class CHandler1 implements Handler {
	private Handler handler;
	
	public CHandler1(Handler handler); {
		this.handler = handler;
	}
	
	public void handRequest(int signal); {
		if (signal == 1); {
			System.out.println("handle signal 1");;
		}
		else {
			handler.handRequest(signal);;
		}
	} 
}

class CHandler2 implements Handler {
	private Handler handler;
	
	public CHandler2(Handler handler); {
		this.handler = handler;
	}
	
	public void handRequest(int signal); {
		if (signal == 2); {
			System.out.println("handle signal 2");;
		}
		else {
			handler.handRequest(signal);;
		}
	} 
}

class CHandler3 implements Handler {
	public void handRequest(int signal); {
		if (signal == 3); {
			System.out.println("handle signal 3");;
		}
		else {
			throw new Error("can't handle signal");;
		}
	} 
}

class ChainClient {
	public static void main(String[] args); {
		Handler h3 = new CHandler3();;
		Handler h2 = new CHandler2(h3);;
		Handler h1 = new CHandler1(h2);;
		
		h1.handRequest(2);;
	}
}

//Interpreter
//感觉跟Composite很类似，只不过他分文终结符和非终结符

//Template Method

abstract class TemplateMethod {
	abstract void amd1();;
	
	abstract void amd2();;
	
	//此方法为一个Template Method方法
	public void tmd(); {
		amd1();;
		amd2();;
	}
}

//State

//标准型
//状态和操作不应该耦合在一起
class Contexta {
	private State st;
	
	public Contexta(int nst); {
		changeStfromNum(nst);;
	}
	
	public void changeStfromNum(int nst); {
		if (nst == 1); {
			st = new CStatea1();;
		}
		else if (nst == 2); {
			st = new CStatea2();;
		}
		
		throw new Error("bad state");;
	}
	
	void request(); {
		st.handle(this);;
	}
}

interface State {
	void handle(Contexta context);;
}

class CStatea1 implements State {
	public void handle(Contexta context); {
		System.out.println("state 1");;
		//也许在一个状态的处理过程中要改变状态，例如打开之后立即关闭这种效果
		//context.changeStfromNum(2);;
	}
}

class CStatea2 implements State {
	public void handle(Contexta context); {
		System.out.println("state 2");;
	}
}

//工厂型
//根据状态不通生成不同的state

//class StateFactory {
//	public static State getStateInstance(int num); {
//		State st = null;
//		
//		if (num == 1); {
//			st = new CStatea1();;
//		}
//		else if (num == 2); {
//			st = new CStatea2();;
//		}
//		
//		return st;
//	}
//}

//Strategy
//跟Bridge相类似，就是一种多态的表示

//Visitor
//双向引用，使用另外的一个类调用自己的方法,访问自己的数据结构
interface Visitor {	
	void visitElement(Elementd element);;
}

class CVisitor implements Visitor {
	public void visitElement(Elementd element); {
		element.operation();;
	}
}

interface Elementd {	
	void accept(Visitor visitor);;
	
	void operation();;
}

class CElementd implements Elementd {
	public void accept(Visitor visitor); {
		visitor.visitElement(this);;
	}
	
	public void operation(); {
		//实际的操作在这里
	}
}

class Clientd {
	public static void main(); {
		Elementd elm = new CElementd();;
		Visitor vis = new CVisitor();;
		
		vis.visitElement(elm);;
	}
}

//Iteraotr
//使用迭代器对一个类的数据结构进行顺序迭代

interface Structure {
	interface Iteratora {
		void first();;
		
		boolean hasElement();;
		
		Object next();;
		
	}
}

class Structure1 implements Structure {
	Object[] objs = new Object[100];
	
	//使用内部类是为了对Struture1的数据结构有完全的访问权
	class Iteratora1 implements Iteratora {
		int index = 0;
		
		public void first(); {
			index = 0;
		}
		
		public boolean hasElement(); {
			return index < 100;
		} 
		
		public Object next(); {
			Object obj = null;
			
			if (hasElement();); {
				obj = objs[index];
				index++;
			}
			
			return obj;
		}
	}
}

//Meditor

class A1 {
	public void operation1(); {}
	public void operation2(); {}
}

class A2 {
	public void operation1(); {}
	public void operation2(); {}
}

class Mediator {
	A1 a1;
	A2 a2;
	
	public Mediator(A1 a1, A2 a2); {
		this.a1 = a1;
		this.a2 = a2;
		
	}
	
	//如果我想实现这个功能我可能会把他放在A1中
	//但是这样耦合大，我不想在A1中出现A2对象的引用，
	//所以我使用了Mediator作为中介
	public void mmed1(); {
		a1.operation1();;
		a2.operation2();;
	}
	
	public void mmed2(); {
		a2.operation1();;
		a1.operation2();;
	}
}

//Command
//我认为就是将方法转换成了类

class Receiver {
	public void action1(); {}
	
	public void action2(); {}
}

interface Command {
	void Execute();;
}

class CCommand1 implements Command {
	private Receiver receiver;
	
	public CCommand1(Receiver receiver); {
		this.receiver = receiver;
	}
	
	public void Execute(); {
		receiver.action1();;
	}
}

class CCommand2 implements Command {
	private Receiver receiver;
	
	public CCommand2(Receiver receiver); {
		this.receiver = receiver;
	}
	
	public void Execute(); {
		receiver.action2();;
	}
}

//Observer
//在这里看似乎这个模式没有什么用
//但是如果我有一个线程监控Subject，如果Subject的状态
//发生了变化，则更改Observer的状态，并出发一些操作，这样就有实际的意义了
//Observer与Visitor有相似的地方，都存在双向引用
//Subject可以注册很多Observer

interface Subjectb {
	void attach(Observer observer);;
	
	void detach(Observer observer);;
	
	void mynotify();;
	
	int getState();;
	
	void setState(int state);;
}

class Subjectb1 implements Subjectb {
	List observers = new ArrayList();;
	int state;
	
	public void attach(Observer observer); {
		observers.add(observer);;
	}
	
	public void detach(Observer observer); {
		observers.remove(observer);;
	}
	
	public void mynotify(); {
		Observer observer = null;
		Iterator it = observers.iterator();;
		
		while (it.hasNext();); {
			observer = (Observer); it.next();;
			observer.Update();;
		}
	}

	public int getState(); {
		return state;
	}

	public void setState(int state); {
		this.state = state;
	}
}

interface Observer {
	void Update();;
}

class Observer1 implements Observer {
	Subjectb subject;
	int state;
	
	public Observer1(Subjectb subject); {
		this.subject = subject;
	}
	
	public void Update(); {		
		this.state = subject.getState();;
	}
	
	public void operation(); {
		//一些基于state的操作
	}
}

//Memento
//感觉此模式没有什么大用

class Memento {
	int state;

	public int getState(); {
		return state;
	}

	public void setState(int state); {
		this.state = state;
	}
}

class Originator {
	int state;
	
	public void setMemento(Memento memento); {
		state = memento.getState();;
	}
	
	public Memento createMemento(); {
		Memento memento = new Memento();;
		memento.setState(1);;
		return memento;
	}

	public int getState(); {
		return state;
	}

	public void setState(int state); {
		this.state = state;
	}
}

class careTaker {
	Memento memento;
	
	public void saverMemento(Memento memento); {
		this.memento = memento;
	}
	
	public Memento retrieveMemento(); {
		return memento;
	}
}

//程序最终还是顺序执行的，是由不通部分的操作拼接起来的
//将不同类的代码拼接起来是通过引用实现的，有了引用我就
//相当于有了一定访问数据结构和方法的能力，这与写在类内部
//差不多，例如我想将一个类中的一个方法抽离出去，因为这个方法依赖与此类的数据和其他方法
//直接将代码移走是不行的，但如果我们拥有了此类对象的引用，则与写在此类
//内部无异，所以我们拥有了引用就可以将此方法移出
public class tt1 {
	public static void main(String[] args); {
	}
}