单例模式：
方式一：
public class Singleton
{
private static Singleton singleton;
private Singleton() //防止从外部 new Singleton();
{}
public static Singleton getInstance()
{
if(singleton == null)
{
singleton = new Singleton();
}
return singleton;
}
}
方式二：
private static Singleton singleton = new Singleton();
private Singleton(){}
简单工厂模式
public class OperationFactory
public static Operation createOperation(char op)
Operation operation = null;
switch(op)
case'+':
operation =new OperationAdd();
break;
case'-':
operation =new OperationSub();
case'*':
operation =new OperationMul();
case'/':
operation =new OperationDiv();
return operation;
工厂方法模式
IFactory factory = new UndergraduateFactory();
LeiFeng stu = factory.CreateLeiFeng();
public interface IFactory
LeiFeng CreateLeiFeng();
class UndergraduateFactory implements IFactory
@Override
public LeiFeng CreateLeiFeng()
return new Undergraduate();
//Undergraduate ex
class VolunteerFactory implements IFactory
return new Volunteer();
class LeiFeng{....}
class Undergraduate extends LeiFeng
// String name = "student1";
class Volunteer extends LeiFeng
//
Creator creator = new ConcreteCreator();
Product product = creator.createProduct(ConcreteProduct1.class);
public abstract class Creator
public abstract Product createProduct(Class<? extends Product> c);
抽象工厂模式
建造者模式
public class Director
public void Construct(Builder builder)
builder.BuildPartA();
builder.BuildPartB();
abstract class Builder
public abstract void BuildPartA();
public abstract void BuildPartB();
public abstract Product GetResult();
Director director = new Director();
Builder b1 = new ConcreteBuilder1();
Builder b2 = new ConcreteBuilder2();
director.Construct(b1);
Product p1 = b1.GetResult();
p1.Show();
director.Construct(b2);
Product p2 = b2.GetResult();
p2.Show();
原型模式 ---较少使用，clone()方法有风险
abstract class Prototype
private String id;
public Prototype(String id)
this.id = id;
public String getId()
return id;
//抽象类关键就是这样一个Clone方法
public abstract Prototype Clone();
class ConcretePrototype1 extends Prototype
public ConcretePrototype1(String id)
super(id);
public Prototype Clone()
// TODO Auto-generated method stub
return (Prototype)this;
ConcretePrototype1 c1 = new ConcretePrototype1("wangmeng");
ConcretePrototype1 c2 = (ConcretePrototype1)c1.Clone();
Prototype c1 = new ConcretePrototype1("wangmeng");
Prototype c2 = (ConcretePrototype1)c1.Clone();
适配器模式
public interface Target //目标接口
public void Request();
public class Adaptee //被适配者
public void SpecificRequest() //原有方法
System.out.println("目标方法");
//采用继承方式，
public class Adapter extends Adaptee implements Target
public void Request() //将原有方法的调用转换为目标方法的调用
this.SpecificRequest();
class Target
public void Request()
{
System.out.println("Common request...");
}
/**采取对象组合的的方式(推荐)*/
public class Adapter extends Target
private Adaptee adaptee = new Adaptee();
public void Request()
adaptee.SpecificRequest();
桥梁模式：
Abstraction ab = new RefinedAbstraction();
ab.setImplementor(new ConcreteImplementorA());
ab.Operation();
ab.setImplementor(new ConcreteImplementorB());
abstract class Abstraction
Implementor implementor;
public void setImplementor(Implementor imp)
this.implementor = imp;
public abstract void Operation();
class RefinedAbstraction extends Abstraction
public void Operation()//实现部分被抽象部分调用，用来完成抽象部分的功能
implementor.OperationImp();
//关于Implementor
abstract class Implementor
public abstract void OperationImp();
class ConcreteImplementorA extends Implementor
public void OperationImp()
System.out.println("ConcreteImplementorA_opreration");
}
class ConcreteImplementorB extends Implementor
System.out.println("ConcreteImplementorB_opreration");
组合模式：
Composite root = new Composite("root");
root.Add(new Leaf("Leaf A"));
root.Add(new Leaf("Leaf B"));
Composite comp1 = new Composite("comp1");
comp1.Add(new Leaf("comp1_Leaf A"));
comp1.Add(new Leaf("comp1_Leaf B"));
root.Add(comp1);
Composite comp2 = new Composite("comp2");
comp2.Add(new Leaf("comp2_Leaf A"));
comp2.Add(new Leaf("comp2_Leaf B"));
root.Add(comp2);
root.Add(new Leaf("Leaf C"));
Leaf leaf = new Leaf("Leaf D");
root.Add(leaf);
//root.Remove(leaf);
root.Display(1);
方式一：Component接口的最大化，达到枝与叶没有区别，但安全性低
/**
* Component类：是组合中的对象声明接口
* 在适当情况下，实现所有类共有接口的默认行为。
* 声明一个接口，用于访问和管理Component的子部件
* */
abstract class Component //也可以定义成接口，提供对子对象的管理方法(添加、删除等)
protected String name;
public Component(String name)
this.name = name;
public abstract void Add(Component comp);
public abstract void Remove(Component comp);
public abstract void Display(int depth);
public class Composite implements Component
private List<Component> list = new ArrayList<Component>();
...
public class Leaf implements Component
方式二：只在Composite中声明管理子类的方法
public interface Component //根
void doSomething();
public class Composite implements Component //枝
public void add(Component component)
list.add(component);
public List<Component> getAll()
return this.list;
public void doSomething()
for(Component component : list)
component.doSomething();
public class Leaf implements Component //叶
System.out.println("Execute method...");
装饰模式
动态地给一个对象添加一些额外的职责。
优点：把类中的装饰功能从类中搬移出去，这样可以简化原有的类。
有效地把类的核心功能和装饰功能区分开了。
ConcreteComponent c = new ConcreteComponent();
ConcreteDecoratorA d1 = new ConcreteDecoratorA();
ConcreteDecoratorB d2 = new ConcreteDecoratorB();
d1.SetComponent(c);
d1.Operation();
d2.SetComponent(c);
d2.Operation();
Component定义了一个对象接口，可以给这些对象动态地添加职责。
ComcreteComponent定了一个具体的对象，也可以给这个具体的对象添加职责。
Decorator抽象装饰类，继承了Component对象接口，从外类扩展Component类的功能，但对于Component来说，是无需知道Decorator的存在。
ConcreteDecoratorA具体的装饰对象，起到给Component添加职责的功能。
ConcreteDecoratorB具体的装饰对象，起到给Component添加职责的功能。
abstract class Component
class ConcreteComponent extends Component
public void Operation()
System.out.println("Concrete Object Operation.");
abstract class Decorator extends Component
protected Component component;
public void SetComponent(Component component)
this.component = component;
if(component != null)
component.Operation();
}
class ConcreteDecoratorA extends Decorator
private String addState;
super.Operation();
addState = "New State";
System.out.println("Operations of ConcreteDecoratorA");
class ConcreteDecoratorB extends Decorator
{
private void AddedBehavior()
{
AddedBehavior();
System.out.println("Operations of ConcreteDecoratorB");
门面模式(外观模式)
为子系统中的一组接口，提供一个一致的界面
门面(Facade)角色：被客户端调用。此角色知晓相关的(一个或者多个)子系统的功能和责任，内部根据客户角色已有需求预定义了几种功能的组合
子系统(subsystem)角色：子系统并不知道门面的存在
Facade facade = new Facade();
facade.Method1();
facade.Method2();
//由于Facade的作用，客户端可以根本不知道四个子系统的存在
public class Facade
SubSystemA a;
SubSystemB b;
SubSystemC c;
SubSystemD d;
public Facade()
a = new SubSystemA();
b = new SubSystemB();
c = new SubSystemC();
d = new SubSystemD();
public void Method1()
System.out.println("Method1()");
a.MethodA();
b.MethodB();
c.MethodC();
public void Method2()
System.out.println("Method2()");
d.MethodD();
class SubSystemA
public void MethodA()
System.out.println("SubSystemA_MethodA");
class SubSystemB
public void MethodB()
System.out.println("SubSystemB_MethodB");
class SubSystemC
public void MethodC()
System.out.println("SubSystemC_MethodC");
class SubSystemD
public void MethodD()
System.out.println("SubSystemD_MethodD");
享元模式 //?
采用一个共享类来避免大量拥有相同内容的"小类"的开销
享元对象的优点：减少对象数量，节省内存空间。
享元模式的缺点：维护共享对象，需要额外的开销（用一个线程来维护垃圾回收）。
享元模式的本质：分离与共享。
何时使用享元对象：
● 如果一个应用程序使用了大量的细粒度对象，可以使用享元模式来减少对象数量。
● 如果使用大量的对象，造成很大的存储开销，可以使用享元模式来减少对象数量，并节约内存。
● 如果对象的大多数状态都可以转变为外部状态，可以使用享元对象来实现外部状态与内部状态的分离。
◆ Flyweight ：享元接口，通过这个接口可以接受并作用于外部状态。通过这个接口传入外部的状态。
◆ ConcreteFlyweight ：具体的享元实现对象，必须是可共享的，需要封装享元对象的内部状态。
◆ UnsharedConcreteFlyweight ：非共享的享元实现对象，并不是所有的享元对象都可以共享，非共享的享元对象通常是享元对象的组合对象。
◆ FlyweightFactory ：享元工厂，主要用来创建并管理共享的享元对象，并对外提供访问共享享元的接口。通常实现为单例
代理模式
Proxy proxy = new Proxy();
proxy.Request(); //实际执行的是RealSubject的Request()
abstract class Subject
public abstract void Request();
public class RealSubject extends Subject
System.out.println("Real Request...");
public class Proxy extends Subject
RealSubject realSubject;
if(realSubject == null)
realSubject = new RealSubject();
realSubject.Request();
职责链模式
使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系
将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止
public class Client
public static void main(String[] args)
Handler h1 = new ConcreteHandler1();
Handler h2 = new ConcreteHandler2();
Handler h3 = new ConcreteHandler3();
h1.setSuccessor(h2);
h2.setSuccessor(h3);
int[] requests = {2, 5, 14, 22 ,18};
for(int req : requests)
{
h1.HandleRequest(req);
}
abstract class Handler
protected Handler successor;
public void setSuccessor(Handler successor)
this.successor = successor;
public abstract void HandleRequest(int request);
class ConcreteHandler1 extends Handler
public void HandleRequest(int request)
if(request >= 0 && request < 10)
System.out.printf("%s handle requests %d\n",this.getClass().getName(),request);
else if(successor != null)
successor.HandleRequest(request);
class ConcreteHandler2 extends Handler
if(request >= 10 && request < 20)
class ConcreteHandler3 extends Handler
if(request >= 20 && request < 30)
命令模式
Command：声明执行操作的接口
ConcreteCommand：将一个接收者对象绑定于一个动作，调用接收者相应的操作，以实现命令角色声明的执行操作的接口
Client：创建一个具体的命令对象，并可以设定它的接收者
Invoker：调用命令对象执行这个请求
Reciver：实施和执行一个请求相关的操作
Reciver reciver = new Reciver();
Command command = new ConcreteCommand(reciver);
Invoker invoker = new Invoker(command);
invoker.doInvokerAction();
public interface Command
void execute();//public is default
public class ConcreteCommand implements Command
private Reciver reciver;
public ConcreteCommand(Reciver reciver)
this.reciver = reciver;
public void execute()
reciver.doAction();
public class Reciver
public void doAction()
System.out.println("Execute Action.");
//请求者
public class Invoker
private Command command;
public Invoker(Command command)
this.command = command;
public void doInvokerAction()
command.execute();
Reciver reciver = new Reciver();
Invoker invoker = new Invoker();
invoker.SetCommand(command);
invoker.ExcuteCommand();
//Command:用来声明执行操作的接口
public abstract class Command
protected Reciver reciver;
public Command(Reciver reciver)
abstract public void Execute();
* ConcreteCommand类，将一个接收者对象绑定于一个动作
* 调用接收者相应的操作，以实现Execute()方法
public class ConcreteCommand extends Command
super(reciver);
public void Execute()
reciver.Action();
* Invoker类，要求该命令执行这个请求
public void SetCommand(Command command)
public void ExcuteCommand()
command.Execute();
解释器模式 --很少用到
Context context = new Context();
List<AbstractExpression> list = new ArrayList<AbstractExpression>();
list.add(new TerminalExpression());
list.add(new NonterminalExpression());
for(AbstractExpression exp : list)
exp.interpret(context);
迭代器模式：
提供一种方法访问一个容器(container)对象中各个元素，而又不需要暴露该对象的内部细节
Iterator
ConcreteIterator
Aggregate
ConcreteAggregate
* 定义开始对象、下一个对象、
* 判断是否到达结尾、当前对象等方法
abstract class Iterator
public abstract Object first();
public abstract Object next();
public abstract Boolean isDone();
public abstract Object currentItem();
public class ConcreteIterator extends Iterator
private ConcreteAggregate aggregate;
private int current = 0; //记录遍历的当前位置
public ConcreteIterator(ConcreteAggregate aggregate)
this.aggregate = aggregate;
public Object first()
return aggregate.getItem(0);
public Object next()
Object ret = null;
current++;
if(current < aggregate.geCount())
ret = aggregate.getItem(current);
return ret;
public Boolean isDone()
return current >= aggregate.geCount()?true:false;
public Object currentItem()
return aggregate.getItem(current);
abstract class Aggregate
public abstract Iterator createIterator();
public class ConcreteAggregate extends Aggregate
private List<Object> items = new ArrayList<Object>();
private Object item;
public Iterator createIterator()
return new ConcreteIterator(this);
public int geCount()
return items.size();
public Object getItem(int index)
return items.get(index);
public void addItem(Object item,int index)
items.add(index,item);
调停者模式(中介者模式 或 传递器模式)
abstract class Mediator
public abstract void send(String message,Colleague colleague);
class ConcreteMediator extends Mediator
private ConcreteColleague1 colleague1;
private ConcreteColleague2 colleague2;
public void setColleague1(ConcreteColleague1 colleague1)
this.colleague1 = colleague1;
public void setColleague2(ConcreteColleague2 colleague2)
this.colleague2 = colleague2;
public void send(String message, Colleague colleague)
if(colleague1 == colleague)
colleague2.msgNotify(message);
else
colleague1.msgNotify(message);
abstract class Colleague
protected Mediator mediator;
public Colleague(Mediator mediator)
this.mediator = mediator;
class ConcreteColleague1 extends Colleague
public ConcreteColleague1(Mediator mediator)
super(mediator);
public void send(String message)
mediator.send(message,this);
public void msgNotify(String message)
System.out.println("ConcreteColleague1 receive message:"+message);
class ConcreteColleague2 extends Colleague
public ConcreteColleague2(Mediator mediator)
System.out.println("ConcreteColleague2 receive message:"+message);
ConcreteMediator m = new ConcreteMediator();
ConcreteColleague1 c1 = new ConcreteColleague1(m);
ConcreteColleague2 c2 = new ConcreteColleague2(m);
m.setColleague1(c1);
m.setColleague2(c2);
c1.send("Have you eat?");
c2.send("Not yet! Your treat?");
备忘录模式
在不破坏封装性的前提下，捕获一个对象的内部状态。并在该对象之外保存这个状态，这样以后就可将该对象恢复到原先保存的状态
Memento：存储一个Originator的内部状态
Originator：创建一个备忘录，用来记录当前时刻它的内部状态，在需要时使用备忘录恢复内部状态
Caretaker：负责保存好备忘录，不能对备忘录的内部进行操作
public class Memento
private String state;
public Memento(String state)
this.state = state;
public String getState()
return state;
public class Originator
private String state;//the attribute you need to save.maybe more than one.
public void setState(String state)
public Memento CreateMemento()//import the attribute and instance a Memento Object
return new Memento(state);
public void setMemento(Memento memento)//recovery the Memento,recovery relative data(attributes)
state = memento.getState();
public void show()
System.out.println("state : " + state);
public class Caretaker
private Memento memento;
public Memento getMemento()
return memento;
public void setMemento(Memento memento)
this.memento = memento;
Originator originator = new Originator();
originator.setState("On");
originator.show();
Caretaker care = new Caretaker();
care.setMemento(originator.CreateMemento());
originator.setState("Off");
originator.setMemento(care.getMemento());
观察者模式
public class TestObserver
ConcreteSubject s = new ConcreteSubject();
ConcreteObserver x = new ConcreteObserver(s,"x");
ConcreteObserver y = new ConcreteObserver(s,"y");
ConcreteObserver z = new ConcreteObserver(s,"z");
s.attach(x);
s.attach(y);
s.attach(z);
s.setSubjectState("ABC");
s.notifyObservers();
s.detach(y);
s.setSubjectState("dislike y");
s.notifyObservers();
* 抽象通知者，把所有对观察者对象的引用保存在一个聚集里
* 可以增加或移除观察者
private List<Observer> observers = new ArrayList<Observer>();
public void attach(Observer observer)
observers.add(observer);
public void detach(Observer observer)
observers.remove(observer);
public void notifyObservers()
for(Observer observer : observers)
observer.update();
public class ConcreteSubject extends Subject
private String subjectState; //目标类的状态
public String getSubjectState()
return subjectState;
public void setSubjectState(String subjectState)
this.subjectState = subjectState;
* Observer类，抽象观察者，在得到主题的通知时更新自己
*
abstract class Observer
public abstract void update();
public class ConcreteObserver extends Observer
private String name; //观察者的名称
private String observerState; //观察到的目标的状态，（作为自己的状态）
private ConcreteSubject subject; //所观察的目标对象
public ConcreteObserver(ConcreteSubject subject,String name)
this.subject = subject;
public void update()
observerState = subject.getSubjectState();
System.out.println("The new state of Observer "+name+" observed is "+observerState);
public ConcreteSubject getSubject()
return subject;
public void setSubject(ConcreteSubject subject)
策略模式
Context：策略的使用环境，
Strategy：定义所有具体策略角色所需的接口
ConcreteStrategy：实现Strategy
public class TestStrategy
Context context = null;
context = new Context(new ConcreteStrategyA());
context.ContextInterface();
context = new Context(new ConcreteStrategyB());
context = new Context(new ConcreteStrategyC());
context.ContextInterface();
* Strategy类，定义了所有支持的算法的公共接口
//抽象算法类
abstract class Strategy
//算法方法
public abstract void AlgorithmInterface();
class ConcreteStrategyA extends Strategy
public void AlgorithmInterface()
System.out.println("算法A实现");
class ConcreteStrategyB extends Strategy
System.out.println("算法B实现");
class ConcreteStrategyC extends Strategy
System.out.println("算法C实现");
class Context
Strategy strategy;
public Context(Strategy strategy)
this.strategy = strategy;
public void ContextInterface()
this.strategy.AlgorithmInterface();
状态模式 --与策略模式类似
可以有效地替换充满在程序中的if else语句
Context：定义一个客户程序需要的接口，并定义一个状态实例，表示当前的状态
State：封装一个与环境角色特定状态相关的行为
ConcreteState：实现State
public class Context
private State state;
public Context(State state)
public State getState()
System.out.println("Current state is:"+state.getClass().getName());;
public void setState(State state)
public void request()
state.Handle(this);
this.getState();
abstract class State
public abstract void Handle(Context context);
class ConcreteStateA extends State
public void Handle(Context context)
context.setState(new ConcreteStateB());
class ConcreteStateB extends State
context.setState(new ConcreteStateA());
模板模式(模板方法模式)
定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，这样子类也可以不改变算法骨架而重定义某些步骤
abstract class AbstractClass
public abstract void PrimitiveOperation1();
public abstract void PrimitiveOperation2();
public void TemplateMethod()
PrimitiveOperation1();
PrimitiveOperation2();
System.out.println();
class ConcreteClassA extends AbstractClass
public void PrimitiveOperation1()
System.out.println("ConcreteClassA_PrimitiveOperation1()");
public void PrimitiveOperation2()
System.out.println("ConcreteClassA_PrimitiveOperation2()");
class ConcreteClassB extends AbstractClass
System.out.println("ConcreteClassB_PrimitiveOperation1()");
System.out.println("ConcreteClassB_PrimitiveOperation2()");
public class TestTemplate
AbstractClass c;
c = new ConcreteClassA();
c.TemplateMethod();
c = new ConcreteClassB();
访问者模式
表示一个作用于某对象结构中的各元素的操作。
可以在不改变各元素的类的前提下，定义作用于这些元素的新操作
1) 访问者角色（Visitor）：为该对象结构中具体元素角色声明一个访问操作接口。该操作接口的名字和参数标识了发送访问请求给具体访问者的具体元素角色。这样访问者就可以通过该元素角色的特定接口直接访问它。
2) 具体访问者角色（Concrete Visitor）：实现每个由访问者角色（Visitor）声明的操作。
3) 元素角色（Element）：定义一个Accept操作，它以一个访问者为参数。
4) 具体元素角色（Concrete Element）：实现由元素角色提供的Accept操作。
5) 对象结构角色（Object Structure）：这是使用访问者模式必备的角色。它要具备以下特征：能枚举它的元素；可以提供一个高层的接口以允许该访问者访问它的元素；可以是一个复合（组合模式）或是一个集合，如一个列表或一个无序集合。
abstract class Visitor
public abstract void visitConcreteElementA(ConcreteElementA concreteElementA);
public abstract void visitConcreteElementB(ConcreteElementB concreteElementB);
class ConcreteVisitor1 extends Visitor
public void visitConcreteElementA(ConcreteElementA concreteElementA)
System.out.printf("%s is visited by %s\n",
concreteElementA.getClass().getName(),this.getClass().getName());
public void visitConcreteElementB(ConcreteElementB concreteElementB)
concreteElementB.getClass().getName(),this.getClass().getName());
class ConcreteVisitor2 extends Visitor
concreteElementB.getClass().getName(),this.getClass().getName());
abstract class Element
public abstract void accept(Visitor visitor);
class ConcreteElementA extends Element
public void accept(Visitor visitor)
visitor.visitConcreteElementA(this);
public void operationA()
class ConcreteElementB extends Element
visitor.visitConcreteElementB(this);
public void operationB()
class ObjectStructure
private List<Element> elements = new ArrayList<Element>();
public void attach(Element element)
elements.add(element);
public void detach(Element element)
elements.remove(element);
for(Element e : elements)
e.accept(visitor);
ObjectStructure o = new ObjectStructure();
o.attach(new ConcreteElementA());
o.attach(new ConcreteElementB());
ConcreteVisitor1 v1 = new ConcreteVisitor1();
ConcreteVisitor2 v2 = new ConcreteVisitor2();
o.accept(v1);
o.accept(v2);