23种java设计模式

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) {

}

}