单例模式：
方式一：
public class Singleton
{
private static Singleton singleton;
private Singleton() //防止从外部 new Singleton();
{}
public static Singleton getInstance()
{
if(singleton == null)
{
singleton = new Singleton();
}
return singleton;
}
}
方式二：
public class Singleton
{
private static Singleton singleton = new Singleton();
private Singleton(){}
public static Singleton getInstance()
{
return singleton;
}
}
简单工厂模式
public class OperationFactory
{
public static Operation createOperation(char op)
{
Operation operation = null;
switch(op)
{
case‘+‘:
operation =new OperationAdd();
break;
case‘-‘:
operation =new OperationSub();
break;
case‘*‘:
operation =new OperationMul();
break;
case‘/‘:
operation =new OperationDiv();
break;
}
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
{
@Override
public LeiFeng CreateLeiFeng()
{
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);
}
@Override
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
{
@Override
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();
@Override
public void Request()
{
adaptee.SpecificRequest();
}
}
桥梁模式：
Abstraction ab = new RefinedAbstraction();
ab.setImplementor(new ConcreteImplementorA());
ab.Operation();
ab.setImplementor(new ConcreteImplementorB());
ab.Operation();
abstract class Abstraction
{
Implementor implementor;
public void setImplementor(Implementor imp)
{
this.implementor = imp;
}
public abstract void Operation();
}
class RefinedAbstraction extends Abstraction
{
@Override
public void Operation()//实现部分被抽象部分调用，用来完成抽象部分的功能
{
implementor.OperationImp();
}
}
//关于Implementor
abstract class Implementor
{
public abstract void OperationImp();
}
class ConcreteImplementorA extends Implementor
{
@Override
public void OperationImp()
{
System.out.println("ConcreteImplementorA_opreration");
}
}
class ConcreteImplementorB extends Implementor
{
@Override
public void OperationImp()
{
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 //枝
{
private List<Component> list = new ArrayList<Component>();
public void add(Component component)
{
list.add(component);
}
public List<Component> getAll()
{
return this.list;
}
@Override
public void doSomething()
{
for(Component component : list)
{
component.doSomething();
}
}
}
public class Leaf implements Component //叶
{
@Override
public void doSomething()
{
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
{
public abstract void Operation();
}
class ConcreteComponent extends Component
{
@Override
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;
}
@Override
public void Operation()
{
if(component != null)
{
component.Operation();
}
}
}
class ConcreteDecoratorA extends Decorator
{
private String addState;
@Override
public void Operation()
{
super.Operation();
addState = "New State";
System.out.println("Operations of ConcreteDecoratorA");
}
}
class ConcreteDecoratorB extends Decorator
{
private void AddedBehavior()
{
}
@Override
public void Operation()
{
super.Operation();
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()");
b.MethodB();
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
{
@Override
public void Request()
{
System.out.println("Real Request...");
}
}
public class Proxy extends Subject
{
RealSubject realSubject;
@Override
public void Request()
{
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
{
@Override
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
{
@Override
public void HandleRequest(int request)
{
if(request >= 10 && request < 20)
{
System.out.printf("%s handle requests %d\n",this.getClass().getName(),request);
}
else if(successor != null)
{
successor.HandleRequest(request);
}
}
}
class ConcreteHandler3 extends Handler
{
@Override
public void HandleRequest(int request)
{
if(request >= 20 && request < 30)
{
System.out.printf("%s handle requests %d\n",this.getClass().getName(),request);
}
else if(successor != null)
{
successor.HandleRequest(request);
}
}
}
命令模式
Command：声明执行操作的接口
ConcreteCommand：将一个接收者对象绑定于一个动作，调用接收者相应的操作，以实现命令角色声明的执行操作的接口
Client：创建一个具体的命令对象，并可以设定它的接收者
Invoker：调用命令对象执行这个请求
Reciver：实施和执行一个请求相关的操作
方式一：
public class Client
{
public static void main(String[] args)
{
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;
}
@Override
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();
}
}
方式二：
public class Client
{
public static void main(String[] args)
{
Reciver reciver = new Reciver();
Command command = new ConcreteCommand(reciver);
Invoker invoker = new Invoker();
invoker.SetCommand(command);
invoker.ExcuteCommand();
}
}
//Command:用来声明执行操作的接口
public abstract class Command
{
protected Reciver reciver;
public Command(Reciver reciver)
{
this.reciver = reciver;
}
abstract public void Execute();
}
/**
* ConcreteCommand类，将一个接收者对象绑定于一个动作
* 调用接收者相应的操作，以实现Execute()方法
* */
public class ConcreteCommand extends Command
{
public ConcreteCommand(Reciver reciver)
{
super(reciver);
}
@Override
public void Execute()
{
reciver.Action();
}
}
/**
* Invoker类，要求该命令执行这个请求
* */
public class Invoker
{
private Command command;
public void SetCommand(Command command)
{
this.command = command;
}
public void ExcuteCommand()
{
command.Execute();
}
}
解释器模式 --很少用到
public class Client
{
public static void main(String[] args)
{
Context context = new Context();
List<AbstractExpression> list = new ArrayList<AbstractExpression>();
list.add(new TerminalExpression());
list.add(new NonterminalExpression());
list.add(new TerminalExpression());
list.add(new TerminalExpression());
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;
}
@Override
public Object first()
{
return aggregate.getItem(0);
}
@Override
public Object next()
{
Object ret = null;
current++;
if(current < aggregate.geCount())
{
ret = aggregate.getItem(current);
}
return ret;
}
@Override
public Boolean isDone()
{
return current >= aggregate.geCount()?true:false;
}
@Override
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;
@Override
public Iterator createIterator()
{
// TODO Auto-generated method stub
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;
}
@Override
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)
{
super(mediator);
}
public void send(String message)
{
mediator.send(message,this);
}
public void msgNotify(String message)
{
System.out.println("ConcreteColleague2 receive message:"+message);
}
}
public class Client
{
public static void main(String[] args)
{
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 String getState()
{
return state;
}
public void setState(String state)
{
this.state = 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;
}
}
public class Client
{
public static void main(String[] args)
{
Originator originator = new Originator();
originator.setState("On");
originator.show();
Caretaker care = new Caretaker();
care.setMemento(originator.CreateMemento());
originator.setState("Off");
originator.show();
originator.setMemento(care.getMemento());
originator.show();
}
}
观察者模式
public class TestObserver
{
public static void main(String[] args)
{
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();
}
}
/**
* 抽象通知者，把所有对观察者对象的引用保存在一个聚集里
* 可以增加或移除观察者
* */
abstract class Subject
{
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.name = name;
this.subject = subject;
}
@Override
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)
{
this.subject = subject;
}
}
策略模式
Context：策略的使用环境，
Strategy：定义所有具体策略角色所需的接口
ConcreteStrategy：实现Strategy
public class TestStrategy
{
public static void main(String[] args)
{
Context context = null;
context = new Context(new ConcreteStrategyA());
context.ContextInterface();
context = new Context(new ConcreteStrategyB());
context.ContextInterface();
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
{
public void AlgorithmInterface()
{
System.out.println("算法B实现");
}
}
class ConcreteStrategyC extends Strategy
{
public void AlgorithmInterface()
{
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)
{
this.state = state;
}
public State getState()
{
System.out.println("Current state is:"+state.getClass().getName());;
return state;
}
public void setState(State state)
{
this.state = state;
}
public void request()
{
state.Handle(this);
this.getState();
}
}
abstract class State
{
public abstract void Handle(Context context);
}
class ConcreteStateA extends State
{
@Override
public void Handle(Context context)
{
context.setState(new ConcreteStateB());
}
}
class ConcreteStateB extends State
{
@Override
public void Handle(Context context)
{
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
{
@Override
public void PrimitiveOperation1()
{
System.out.println("ConcreteClassA_PrimitiveOperation1()");
}
@Override
public void PrimitiveOperation2()
{
System.out.println("ConcreteClassA_PrimitiveOperation2()");
}
}
class ConcreteClassB extends AbstractClass
{
@Override
public void PrimitiveOperation1()
{
System.out.println("ConcreteClassB_PrimitiveOperation1()");
}
@Override
public void PrimitiveOperation2()
{
System.out.println("ConcreteClassB_PrimitiveOperation2()");
}
}
public class TestTemplate
{
public static void main(String[] args)
{
AbstractClass c;
c = new ConcreteClassA();
c.TemplateMethod();
c = new ConcreteClassB();
c.TemplateMethod();
}
}
访问者模式
表示一个作用于某对象结构中的各元素的操作。
可以在不改变各元素的类的前提下，定义作用于这些元素的新操作
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
{
@Override
public void visitConcreteElementA(ConcreteElementA concreteElementA)
{
System.out.printf("%s is visited by %s\n",
concreteElementA.getClass().getName(),this.getClass().getName());
}
@Override
public void visitConcreteElementB(ConcreteElementB concreteElementB)
{
System.out.printf("%s is visited by %s\n",
concreteElementB.getClass().getName(),this.getClass().getName());
}
}
class ConcreteVisitor2 extends Visitor
{
@Override
public void visitConcreteElementA(ConcreteElementA concreteElementA)
{
System.out.printf("%s is visited by %s\n",
concreteElementA.getClass().getName(),this.getClass().getName());
}
@Override
public void visitConcreteElementB(ConcreteElementB concreteElementB)
{
System.out.printf("%s is visited by %s\n",
concreteElementB.getClass().getName(),this.getClass().getName());
}
}
abstract class Element
{
public abstract void accept(Visitor visitor);
}
class ConcreteElementA extends Element
{
@Override
public void accept(Visitor visitor)
{
visitor.visitConcreteElementA(this);
}
public void operationA()
{
}
}
class ConcreteElementB extends Element
{
@Override
public void accept(Visitor visitor)
{
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);
}
public void accept(Visitor visitor)
{
for(Element e : elements)
{
e.accept(visitor);
}
}
}
public class Client
{
public static void main(String[] args)
{
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);
}
}
本文出自 “wmdream” 博客，请务必保留此出处http://wmdream.blog.51cto.com/3773205/1361983
原文：http://wmdream.blog.51cto.com/3773205/1361983