單例模式：
方式一：
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);