设计模式的例子
2005-03-12 16:03
225 查看
////////////////////////////////////////////////////////////////////
创建模式
////////////////////////////////////////////////////////////////////
//FactoryMethod模式的例子
package pattern.a.factoryMethod;
interface Product {
void operation();
}
class ConProduct1 implements Product {
//不同的实现可以有不同的产品操作
public void operation() {}
}
class ConProduct2 implements Product {
//不同的实现可以有不同的产品操作
public void operation() {}
}
interface Factory {
Product CreateProduct();
void operation1();
}
class ConFactory1 implements Factory {
//不同的实体场类
在创建产品是可以有不能的创建方法
public Product CreateProduct() {
Product product
= new ConProduct1();
operation1();
return product;
}
public void operation1() {}
public static Factory getFactory() {
return new
ConFactory1();
}
}
class ConFactory2 implements Factory {
//不同的实体场类
在创建产品是可以有不能的创建方法
public Product CreateProduct() {
Product product
= new ConProduct2();
operation1();
return product;
}
public void operation1() {}
//
public static Factory getFactory() {
return new
ConFactory2();
}
}
public class FactoryMethod {
public static void main(String[] args)
{
Factory factory = ConFactory1.getFactory();
Product product
= factory.CreateProduct();
product.operation();
}
}
***********************************************************************
//AbstractoryFa
4000
ctory模式的例子
//我觉得这个模式与FactoryMethod 就是创建产品的数量上有区别
package pattern.a.abstractfactory;
//产品A的接口和实现
interface ProductA {}
class ProductA1 implements ProductA {}
class PorductA2 implements ProductA {}
//产品B的接口和实现
interface ProductB {}
class ProductB1 implements ProductB {}
class ProductB2 implements ProductB {}
//工程和工厂的实现
interface Factory {
ProductA CreateA();
ProductB CreateB();
}
//1工厂产生1系列产品
class ConFactory1 implements Factory {
public
ProductA CreateA() {
return new ProductA1();
}
public ProductB CreateB() {
return new ProductB1();
}
}
//2工厂产生2系列产品
class ConFactory2 implements Factory {
public
ProductA CreateA() {
return new PorductA2();
}
public ProductB CreateB() {
return new ProductB2();
}
}
class ConFactory {}
public class AbstractFactory {
public static void main(String[] args) {
//1工厂产生1类产品
Factory factory1 = new ConFactory1();
ProductA
a1 = factory1.CreateA();
ProductB b1 = factory1.CreateB();
//2工厂产生2类产品
Factory factory2 = new
ConFactory1();
ProductA a2 = factory2.CreateA();
ProductB
b2 = factory2.CreateB();
}
}
***********************************************************************
//Builder模式的例子
// 模式的宗旨是 将部件创建的细节 和部件的组装方法分离!!! 考兄弟悟性要高
package pattern.a.builder;
class director {
//construct 中存放着组装不见的逻辑 注意 逻辑的分离
public Product construct(Builder builder) {
builder.buildPart1();
builder.buildPart2();
operation();
Product product = builder.retrieveProduct();
return product;
}
public void operation() {}
}
class Product {}
interface Builder {
void buildPart1();
void
buildPart2();
Product retrieveProduct();
}
class ConBuilder1 implements Builder {
public void
buildPart1() {}
public void buildPart2() {}
public
Product retrieveProduct() {
return null;
}
}
class ConBuilder2 implements Builder {
public void
buildPart1() {}
public void buildPart2() {}
public
Product retrieveProduct() {
return null;
}
}
public class BuilderPattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Singleton模式例子
package pattern.a.singleton;
// 一种简单的形式
class SingletonExample {
private static
SingletonExample instance;
private SingletonExample()
{}
public static SingletonExample getInstance() {
if
(instance == null) {
instance = new SingletonExample();
}
return
instance;
}
synchronized public static SingletonExample
getInstance1() {
if (instance == null) {
instance = new
SingletonExample();
}
return instance;
}
public
static SingletonExample getInstance2()
{
synchronized(SingletonExample.class) {
if (instance == null)
{
instance = new SingletonExample();
}
}
return
instance;
}
}
//利用类加载时 初始化只产生一次
class SingletonExample2 {
private static
SingletonExample2 instance = new SingletonExample2();
private
SingletonExample2() {}
public static SingletonExample2 getInstance()
{
return instance;
}
}
public class SingletonPattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Prototype模式例子
package pattern.a.prototype;
interface Prototype {
Prototype myclone();
}
class ConPrototype1 implements Prototype{
private String a;
public ConPrototype1(String a) {
this.a = a;
}
public Prototype myclone() {
return new
ConPrototype1(a);
}
}
class ConPrototype2 implements Prototype{
private int b;
public ConPrototype2(int b) {
this.b = b;
}
public Prototype myclone() {
return new
ConPrototype2(b);
}
}
public class PrototypePattern {
public static void main(String[] args)
{
Prototype inst1 = new ConPrototype1("testStr1");
Prototype inst2 = null;
inst2 = inst1.myclone();
}
}
***********************************************************************
////////////////////////////////////////////////////////////////////
结构模式
////////////////////////////////////////////////////////////////////
//Adapter模式的例子
package pattern.b.Adapter;
// 类适配
interface Target1 {
void request();
}
class Adaptee1 {
public void specRequest() {}
}
class Adapter1 extends Adaptee1 implements Target1 {
public void request() {
super.specRequest();
}
}
//对象适配
interface Target2 {
void request();
}
class Adaptee2 {
public void specRequest() {}
}
class Adapter2 implements Target2 {
private Adaptee2 adaptee;
public Adapter2(Adaptee2 adaptee)
{
this.adaptee = adaptee;
}
public void request() {
adaptee.specRequest();
}
}
public class AdapterPattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Proxy模式例子
package pattern.b.proxy;
interface Subject {
void request();
}
//真正处理请求的地方
class RealSubject implements Subject {
public void
request() {
System.out.println("real
access");
}
}
//ProxySubject是与用户交互的类 他是REalSubject的代理
//在处理功能之上的一层 这里可以做前操作 后操作
例如可以验证是否处理请求。
class ProxySubject implements Subject {
private
RealSubject real;
public ProxySubject(RealSubject real)
{
this.real = real;
}
//
public void request()
{
preRequest();
real.request();
afterRequest();
}
private
void preRequest() {}
private void afterRequest() {}
}
//java自身提供代理类使用反射机制
public class ProxyPattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Composite 模式例子
//在用户的角度 并不知道 不见是单独的还是符合的 只要调用接口级方法 operation
package pattern.b.composite;
import java.util.ArrayList;
import java.util.Iterator;
import
java.util.List;
// 安全模式 在接口级只提供部分功能 leaf 和 composite 有不同的功能
interface Component1 {
public void operation();
}
class leaf1 implements Component1 {
public void operation()
{
System.out.println("this is the leaf1");
}
}
class Composite1 implements Component1 {
private List
components;
public Composite1() {
components = new
ArrayList();
}
public void operation() {
Iterator it = components.iterator();
Component1 com =
null;
while (it.hasNext()) {
com = (Component1)
it.next();
com.operation();
}
}
public void addComponent(Component1 com) {
components.add(com);
}
public void removeComponent(int
index) {
components.remove(index);
}
}
// 透明模式 接口定义全部功能 leaf中可能使用空方法或抛出异常 活着写一层 抽象类 写上默认实现方法(极端情况下 是空或异常)
interface Component2 {
public void operation();
public void addComponent(Component2 com);
public void
removeComponent(int index);
}
class leaf2 implements Component2 {
public void operation()
{
System.out.println("this is the leaf1");
}
//这个使用空方法
public void addComponent(Component2 com) {}
//这个使用不支持异常
public void removeComponent(int index){
throw new
UnsupportedOperationException();
}
}
class Composite2 implements Component2 {
private List
components;
public Composite2() {
components = new
ArrayList();
}
public void operation() {
Iterator it = components.iterator();
Component2 com =
null;
while (it.hasNext()) {
com = (Component2)
it.next();
com.operation();
}
}
public void addComponent(Component2 com) {
components.add(com);
}
public void removeComponent(int
index) {
components.remove(index);
}
}
//也可以用一个抽象类
abstract class AbstractComponent implements Component2{
public void
operation() {}
public void addComponent(Component2 com) {}
abstract public void removeComponent(int index);
}
public class CompositePattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Flywight 模式例子
// 将共同的跟不同的属性分离 共享共同属性 而不同属性由外部传入 进行特定操作
package pattern.b.flyweight;
import java.util.HashMap;
import
java.util.Map;
// 1没有办法通过obj.value方式 2没有改变属性的方法 3不能通过继承重置属性 所以这个对象是 immutable 不可变的
final
class State {
private String value = null;
public
State(String value) {
this.value = value;
}
public String getValue() {
return value;
}
}
interface Flyweight {
void operation(String extrinsicState);
}
class ConFlyweight1 implements Flyweight {
//state 表示享元的内部状态
//或者用构造函数传入
private State state = new State("state1");
//out 为外部传给享元的 外部状态
public void operation(String out) {
//使用外部状态和内部状态来执行 operation操作
System.out.println("ConFlyweight1: " +
out + state.getValue());
}
}
// 充数的
class ConFlyweight2 implements Flyweight {
private State
state = new State("state2");
public void operation(String out)
{
System.out.println("ConFlyweight2: " + state.getValue() + out
);
}
}
class FlyweightFactory {
Map flyweights = new HashMap();
public Flyweight getFlyweight(String key) {
if
(flyweights.containsKey(key)) {
return (Flyweight)
flyweights.get(key);
} else {
//
这里就随便写的
Flyweight flyweight = null;
if
(key.charAt(key.length() - 1) == '1') {
flyweight = new
ConFlyweight1();
flyweights.put(key,
flyweight);
} else {
flyweight = new
ConFlyweight2();
flyweights.put(key,
flyweight);
}
return flyweight;
}
}
}
public class FlyweightPattern {
public static void main(String[] args)
{
FlyweightFactory factory = new FlyweightFactory();
Flyweight flyweight1a = factory.getFlyweight("flytest1");
flyweight1a.operation("outparam1");
}
}
***********************************************************************
// Bridge 模式例子
//对一处的操作 改成引用一个对象 具体操作再另一个对象中进行 这样便于功能扩展
package pattern.b.bridge;
interface Implementor {
void realOperation();
}
class ConImplementor1 implements Implementor {
public void
realOperation() {
System.out.println("do the real
operation1");
}
}
class ConImplementor2 implements Implementor {
public void
realOperation() {
System.out.println("do the real
operation2");
}
}
abstract class Abstraction {
protected Implementor imp;
public Abstraction(Implementor imp) {
this.imp = imp;
}
protected void med0() {}
abstract public void
operation();
}
class ConAbstraction extends Abstraction{
public
ConAbstraction(Implementor imp) {
super(imp);
}
public void operation() {
med0();
imp.realOperation(); }
}
public class BridgePattern {
public static void main(String[] args)
{
Implementor imp = new ConImplementor1();
Abstraction abs
= new ConAbstraction(imp);
abs.operation();
}
}
***********************************************************************
//Decorator 模式例子
package pattern.b.decorator;
//源部件和修饰类的共同接口
interface Component {
void operation();
}
class ConComponent implements Component {
public void operation()
{
System.out.println("the begin operation");
}
}
//没有提供给component赋值的方法 所以声明这个类为抽象的 这里并没有抽象的方法就是不像让这个类有实例
abstract class
Decotor implements Component{
private Component component;
public void operation() {
component.operation();
}
}
class ConDecotor1 extends Decotor {
private Component
component;
public ConDecotor1(Component component) {
this.component = component;
}
public void operation()
{
super.operation();
//!!注意这里 这里提供了功能的添加
//
这里就是Decorator的核心部分 不是修改功能而是添加功能 将一个component传入装饰类调用对象的接口
//方法
在此过程添加功能 重新实现接口方法的功能
med0();
}
private void
med0() {
System.out.println("1");
}
}
class ConDecotor2 extends Decotor {
private Component
component;
public ConDecotor2(Component component) {
this.component = component;
}
public void operation()
{
super.operation();
med0();
}
private void med0() {
System.out.println("2");
}
}
//class
public class DecoratorPattern {
public static void main(String[] args)
{
//注意 起点位置是从一个ConComponent开始的!!
Component component = new
ConDecotor2(new ConDecotor1(new ConComponent()));
component.operation();
}
}
***********************************************************************
//Facade 的例子
//在子系统上建立了一层 对外使用感觉比较简单 Facade的方法中封装与子系统交互的逻辑
package pattern.b.facade;
class Exa1 {
public void med0() {}
}
class Exa2 {
public void themed() {}
}
//这就是一个简单的Facade的方法的例子
class Facade {
public void facdeMed()
{
Exa1 exa1 = new Exa1();
exa1.med0();
Exa2 exa2 = new Exa2();
exa2.themed();
}
}
public class FacadePattern {
public static void main(String[] args)
{
}
}
***********************************************************************
////////////////////////////////////////////////////////////////////
行为模式
////////////////////////////////////////////////////////////////////
//Command 模式例子
//感觉将一个类的方法 分散开了 抽象成了接口方法 注意 参数和返回值要一致
//每个Command封装一个命令
也就是一种操作
package pattern.c.command;
//这个是逻辑真正实现的位置
class Receiver {
public void med1() {}
public void med2() {}
}
interface Command {
// 要抽象成统一接口方法 是有局限性的
void
execute();
}
class ConCommand1 implements Command{
private Receiver
receiver;
public ConCommand1(Receiver receiver) {
this.receiver = receiver;
}
public void execute()
{
receiver.med1();
}
}
class ConCommand2 implements Command{
private Receiver
receiver;
public ConCommand2(Receiver receiver) {
this.receiver = receiver;
}
public void execute()
{
receiver.med2();
}
}
class Invoker {
private Command command;
public
Invoker(Command command) {
this.command = command;
}
public void action() {
command.execute();
}
}
public class CommandPattern {
public static void main(String[] args)
{
Receiver receiver = new Receiver();
// 生成一个命令
Command command = new ConCommand1(receiver);
Invoker invoker = new
Invoker(command);
invoker.action();
}
}
***********************************************************************
//Strategy 模式例子
//Strategy中封装了算法
package pattern.c.strategy;
interface Strategy {
void stMed();
}
class Constrategy1 {
public void stMed() {}
}
class constrategy2 {
public void stMed() {}
}
class Context {
private Strategy strategy;
public
Context (Strategy strategy) {
this.strategy = strategy;
}
public void ContextInterface() {
strategy.stMed();
}
}
public class StrategyPattern {
public static void main(String[] args)
{
}
}
***********************************************************************
//State模式例子
//将一种状态和状态的助理封装倒state中
package pattern.c.state;
class Context {
private State state = new CloseState();
public
void changeState(State state) {
this.state = state;
}
public
void ruquest() {
state.handle(this);
}
}
interface State {
void handle(Context context);
}
//表示打开状态
class OpenState implements State{
public void handle(Context
context) {
System.out.println("do something for
open");
context.changeState(new CloseState());
}
}
//表示关闭状态
class CloseState implements State{
public void handle(Context
context) {
System.out.println("do something for
open");
context.changeState(new OpenState());
}
}
public class StatePattern {
public static void main(String[] args)
{
}
}
***********************************************************************
//Visitor模式例子
//双向传入
package pattern.c.visitor;
import java.util.*;
interface Visitor {
void visitConElementA(ConElementA
conElementA);
void visitConElementB(ConElementB conElementB);
}
class ConVisitor1 implements Visitor{
public void
visitConElementA(ConElementA conElementA) {
String value =
conElementA.value;
conElementA.operation();
//do
something
}
public void visitConElementB(ConElementB conElementB)
{
String value =
conElementB.value;
conElementB.operation();
//do
something
}
}
class ConVisitor2 implements Visitor{
public void
visitConElementA(ConElementA conElementA) {
String value =
conElementA.value;
conElementA.operation();
//do
something
}
public void visitConElementB(ConElementB conElementB)
{
String value =
conElementB.value;
conElementB.operation();
//do
something
}
}
interface Element {
void accept(Visitor visitor);
}
class ConElementA implements Element {
String value =
"aa";
public void operation() {}
public void accept(Visitor
visitor) {
visitor.visitConElementA(this);
}
}
class ConElementB implements Element {
String value =
"bb";
public void operation() {}
public void accept(Visitor
visitor) {
visitor.visitConElementB(this);
}
}
class ObjectStructure {
private List Elements = new
ArrayList();
public void action(Visitor visitor) {
Iterator it =
Elements.iterator();
Element element = null;
while (it.hasNext())
{
element = (Element)
it.next();
element.accept(visitor);
}
}
public void
add(Element element) {
Elements.add(element);
}
}
public class VisitorPattern {
public static void main(String[] args)
{
ObjectStructure objs = new ObjectStructure();
objs.add(new
ConElementA());
objs.add(new ConElementA());
objs.add(new
ConElementB());
objs.action(new ConVisitor1());
}
}
***********************************************************************
//Observable模式例子
package pattern.c.observable;
import java.util.*;
class State {}
interface Subject {
void attach(Observer observer);
void
detach(Observer observer);
void myNotify();
State
getState();
void setState(State state);
}
class ConSubject implements Subject {
List observers = new
ArrayList();
State state = new State();
public void attach(Observer
observer) {
observers.add(observer);
}
public void
detach(Observer observer)
{
observers.remove(observer);
}
public void myNotify()
{
Iterator it = observers.iterator();
Observer observer =
null;
while (it.hasNext()) {
observer = (Observer)
it.next();
observer.update();
}
}
public State
getState() {
return state;
}
public void setState(State state)
{
this.state = state;
}
}
interface Observer {
void update();
}
class ConObserver1 implements Observer{
private Subject
subject;
public ConObserver1(Subject subject) {
this.subject =
subject;
}
public void update() {
State state =
subject.getState();
// do something with state
}
}
class ConObserver2 implements Observer{
private Subject
subject;
public ConObserver2(Subject subject) {
this.subject =
subject;
}
public void update() {
State state =
subject.getState();
// do something with state
}
}
public class ObservablePattern {
public static void main(String[] args)
{
}
}
***********************************************************************
//Mediator模式例子
package pattern.c.mediator;
public interface Colleague {
void setState(String
state);
String getState();
void change();
void action();
}
package pattern.c.mediator;
public class ConColleague1 implements Colleague {
private
String state = null;
private Mediator mediator;
public
void change() {
mediator.changeCol1();
}
public
ConColleague1 (Mediator mediator) {
this.mediator = mediator;
}
public void setState(String state) {
this.state =
state;
}
public String getState() {
return
state;
}
public void action() {
System.out.println("this 2 and the state is " + state);
}
}
package pattern.c.mediator;
public class ConColleague2 implements Colleague {
private
String state = null;
private Mediator mediator;
public
ConColleague2 (Mediator mediator) {
this.mediator = mediator;
}
public void change() {
mediator.changeCol2();
}
public void setState(String
state) {
this.state = state;
}
public String
getState() {
return state;
}
public void
action() {
System.out.println("this 1 and the state is " +
state);
}
}
package pattern.c.mediator;
public class ConMediator implements Mediator {
private
ConColleague1 con1;
private ConColleague2 con2;
public
void setCon1(ConColleague1 con1) {
this.con1 = con1;
}
public void setCon2(ConColleague2 con2) {
this.con2 =
con2;
}
public void changeCol1() {
String state
= con1.getState();
con2.setState(state);
con2.action();
}
public void changeCol2() {
String state = con2.getState();
con1.setState(state);
con1.action();
}
}
package pattern.c.mediator;
public interface Mediator {
void setCon1(ConColleague1
con1);
void setCon2(ConColleague2 con2);
void
changeCol1();
void changeCol2();
}
package pattern.c.mediator;
public class MediatorTest {
public static void main(String[]
args) {
Mediator mediator = new ConMediator();
ConColleague1 col1 = new ConColleague1(mediator);
col1.setState("lq
test in the MediatorTest main 18");
ConColleague2 col2 = new
ConColleague2(mediator);
mediator.setCon1(col1);
mediator.setCon2(col2);
col1.change();
}
}
***********************************************************************
//Iterator模式例子
package pattern.c.iterator;
interface Aggregate {
MyIterator Iterator();
}
class ConAggregate {
public MyIterator Iterator() {
return new
ConMyIterator();
}
}
interface MyIterator {
Object First();
Object Last();
boolean
hasNext();
Object Next();
}
class ConMyIterator implements MyIterator{
Object[] objs = new
Object[100];
int index = 0;
public Object First() {
index =
0;
return objs[index];
}
public Object Last() {
index =
objs.length - 1;
return objs[index];
}
public boolean
hasNext() {
return index < objs.length;
}
public Object
Next() {
if (index == objs.length - 1) {
return null;
} else
{
return objs[++index];
}
}
}
public class IteratorPattern {
public static void main(String[] args) {
}
}
***********************************************************************
// Template Method 模式例子
package pattern.c.template_method;
abstract class father {
abstract void med0();
abstract void
med1();
//operation为一个模板方法
public void operation()
{
med0();
med1();
// and other logic
}
}
class child extends father {
public void med0()
{
System.out.println("the med0 method");
}
public void med1()
{
System.out.println("the med1 method");
}
}
public class TemplateMethodPattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Chain of
Responsiblity模式例子
//将请求在链上传递
//如果是当前节点的请求就结束传递处理请求否则向下传递请求
//每个节点有另一个节点的引用
实现链状结构
package pattern.c.chain_of_responsiblity;
interface Handler{
void handleRequest(int key);
}
class ConHandler1 implements Handler {
private Handler
handler;
public ConHandler1(Handler handler) {
this.handler =
handler;
}
public void handleRequest(int key) {
if (key == 1)
{
System.out.println("handle in 1");
//handle something
} else
{
handler.handleRequest(key);
}
}
}
class ConHandler2 implements Handler {
private Handler
handler;
public ConHandler2(Handler handler) {
this.handler =
handler;
}
public void handleRequest(int key) {
if (key == 2)
{
System.out.println("handle in 2");
//handle something
} else
{
handler.handleRequest(key);
}
}
}
class ConHandler3 implements Handler {
private Handler
handler;
public ConHandler3(Handler handler) {
this.handler =
handler;
}
public void handleRequest(int key) {
if (key == 3)
{
System.out.println("handle in 3");
//handle something
} else
{
handler.handleRequest(key);
}
}
}
public class ChainOfResponsiblityPattern {
public static void
main(String[] args) {
Handler handler = new ConHandler2(new ConHandler1(new
ConHandler3(null)));
handler.handleRequest(3);
}
}
***********************************************************************
//Interpreter模式例子
/*
* Variable 表示变量 存储在上下文中
* Constant
终结表达式
* And 与的关系 双目
* Not 反的关系 单目
*/
package pattern.c.interpreter;
import java.util.*;
class Context {
private Map variables = new HashMap();
public boolean lookUp(Variable name) {
Boolean value = (Boolean)
variables.get(name);
if (value == null) {
return
false;
}
return value.booleanValue();
}
public void bind(Variable name, boolean value) {
variables.put(name, new Boolean(value));
}
}
interface Expression {
boolean interpret(Context cont);
}
class Constant implements Expression {
private boolean value;
public Constant(boolean value) {
this.value = value;
}
public boolean interpret(Context cont) {
return
value;
}
}
class Variable implements Expression{
private String name;
public Variable(String name) {
this.name = name;
}
public boolean interpret(Context cont) {
return
cont.lookUp(this);
}
}
class And implements Expression {
private Expression left;
private Expression right;
public And(Expression left, Expression
right) {
this.left = left;
this.right = right;
}
public boolean interpret(Context cont) {
return
left.interpret(cont) && right.interpret(cont);
}
}
class Not implements Expression {
private Expression
expression;
public Not(Expression expression) {
this.expression = expression;
}
public boolean
interpret(Context cont) {
return ! expression.interpret(cont);
}
}
public class InterpreterPattern {
public static void main(String[]
args) {
Context cont = new Context();
Variable variable =
new Variable("parameter1");
cont.bind(variable, true);
Expression and = new And(new Not(new Constant(true)), new And(new
Constant(false), new Variable("parameter1")));
// (!(true))
&& ((false)&&(true))
and.interpret(cont);
}
}
***********************************************************************
//Memento模式例子
package pattern.c.memento;
class Memento {
String value1;
int value2;
public Memento(String value1, int value2) {
this.value1 =
value1;
this.value2 = value2;
}
}
class Originator {
private String value1;
private int
value2;
public Originator(String value1, int value2) {
this.value1 = value1;
this.value2 = value2;
}
public void setMemento(Memento memento) {
value1 =
memento.value1;
value2 = memento.value2;
}
public Memento createMemento() {
Memento memento = new
Memento(value1, value2);
return memento;
}
public
void setValue1(String value1) {
this.value1 = value1;
}
public void setValue2(int value2) {
this.value2 =
value2;
}
}
class CareTaker {
private Memento memento;
public
Memento retrieveMemento() {
return memento;
}
public void saveMemento(Memento memento) {
this.memento =
memento;
}
}
public class MementoPattern {
public static void main(String[] args)
{
Originator originator = new Originator("test1", 1);
CareTaker careTaker = new CareTaker();
//保存状态
careTaker.saveMemento(originator.createMemento());
originator.setValue1("test2");
originator.setValue2(2);
//恢复状态
originator.setMemento(careTaker.retrieveMemento());
}
}
***********************************************************************
创建模式
////////////////////////////////////////////////////////////////////
//FactoryMethod模式的例子
package pattern.a.factoryMethod;
interface Product {
void operation();
}
class ConProduct1 implements Product {
//不同的实现可以有不同的产品操作
public void operation() {}
}
class ConProduct2 implements Product {
//不同的实现可以有不同的产品操作
public void operation() {}
}
interface Factory {
Product CreateProduct();
void operation1();
}
class ConFactory1 implements Factory {
//不同的实体场类
在创建产品是可以有不能的创建方法
public Product CreateProduct() {
Product product
= new ConProduct1();
operation1();
return product;
}
public void operation1() {}
public static Factory getFactory() {
return new
ConFactory1();
}
}
class ConFactory2 implements Factory {
//不同的实体场类
在创建产品是可以有不能的创建方法
public Product CreateProduct() {
Product product
= new ConProduct2();
operation1();
return product;
}
public void operation1() {}
//
public static Factory getFactory() {
return new
ConFactory2();
}
}
public class FactoryMethod {
public static void main(String[] args)
{
Factory factory = ConFactory1.getFactory();
Product product
= factory.CreateProduct();
product.operation();
}
}
***********************************************************************
//AbstractoryFa
4000
ctory模式的例子
//我觉得这个模式与FactoryMethod 就是创建产品的数量上有区别
package pattern.a.abstractfactory;
//产品A的接口和实现
interface ProductA {}
class ProductA1 implements ProductA {}
class PorductA2 implements ProductA {}
//产品B的接口和实现
interface ProductB {}
class ProductB1 implements ProductB {}
class ProductB2 implements ProductB {}
//工程和工厂的实现
interface Factory {
ProductA CreateA();
ProductB CreateB();
}
//1工厂产生1系列产品
class ConFactory1 implements Factory {
public
ProductA CreateA() {
return new ProductA1();
}
public ProductB CreateB() {
return new ProductB1();
}
}
//2工厂产生2系列产品
class ConFactory2 implements Factory {
public
ProductA CreateA() {
return new PorductA2();
}
public ProductB CreateB() {
return new ProductB2();
}
}
class ConFactory {}
public class AbstractFactory {
public static void main(String[] args) {
//1工厂产生1类产品
Factory factory1 = new ConFactory1();
ProductA
a1 = factory1.CreateA();
ProductB b1 = factory1.CreateB();
//2工厂产生2类产品
Factory factory2 = new
ConFactory1();
ProductA a2 = factory2.CreateA();
ProductB
b2 = factory2.CreateB();
}
}
***********************************************************************
//Builder模式的例子
// 模式的宗旨是 将部件创建的细节 和部件的组装方法分离!!! 考兄弟悟性要高
package pattern.a.builder;
class director {
//construct 中存放着组装不见的逻辑 注意 逻辑的分离
public Product construct(Builder builder) {
builder.buildPart1();
builder.buildPart2();
operation();
Product product = builder.retrieveProduct();
return product;
}
public void operation() {}
}
class Product {}
interface Builder {
void buildPart1();
void
buildPart2();
Product retrieveProduct();
}
class ConBuilder1 implements Builder {
public void
buildPart1() {}
public void buildPart2() {}
public
Product retrieveProduct() {
return null;
}
}
class ConBuilder2 implements Builder {
public void
buildPart1() {}
public void buildPart2() {}
public
Product retrieveProduct() {
return null;
}
}
public class BuilderPattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Singleton模式例子
package pattern.a.singleton;
// 一种简单的形式
class SingletonExample {
private static
SingletonExample instance;
private SingletonExample()
{}
public static SingletonExample getInstance() {
if
(instance == null) {
instance = new SingletonExample();
}
return
instance;
}
synchronized public static SingletonExample
getInstance1() {
if (instance == null) {
instance = new
SingletonExample();
}
return instance;
}
public
static SingletonExample getInstance2()
{
synchronized(SingletonExample.class) {
if (instance == null)
{
instance = new SingletonExample();
}
}
return
instance;
}
}
//利用类加载时 初始化只产生一次
class SingletonExample2 {
private static
SingletonExample2 instance = new SingletonExample2();
private
SingletonExample2() {}
public static SingletonExample2 getInstance()
{
return instance;
}
}
public class SingletonPattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Prototype模式例子
package pattern.a.prototype;
interface Prototype {
Prototype myclone();
}
class ConPrototype1 implements Prototype{
private String a;
public ConPrototype1(String a) {
this.a = a;
}
public Prototype myclone() {
return new
ConPrototype1(a);
}
}
class ConPrototype2 implements Prototype{
private int b;
public ConPrototype2(int b) {
this.b = b;
}
public Prototype myclone() {
return new
ConPrototype2(b);
}
}
public class PrototypePattern {
public static void main(String[] args)
{
Prototype inst1 = new ConPrototype1("testStr1");
Prototype inst2 = null;
inst2 = inst1.myclone();
}
}
***********************************************************************
////////////////////////////////////////////////////////////////////
结构模式
////////////////////////////////////////////////////////////////////
//Adapter模式的例子
package pattern.b.Adapter;
// 类适配
interface Target1 {
void request();
}
class Adaptee1 {
public void specRequest() {}
}
class Adapter1 extends Adaptee1 implements Target1 {
public void request() {
super.specRequest();
}
}
//对象适配
interface Target2 {
void request();
}
class Adaptee2 {
public void specRequest() {}
}
class Adapter2 implements Target2 {
private Adaptee2 adaptee;
public Adapter2(Adaptee2 adaptee)
{
this.adaptee = adaptee;
}
public void request() {
adaptee.specRequest();
}
}
public class AdapterPattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Proxy模式例子
package pattern.b.proxy;
interface Subject {
void request();
}
//真正处理请求的地方
class RealSubject implements Subject {
public void
request() {
System.out.println("real
access");
}
}
//ProxySubject是与用户交互的类 他是REalSubject的代理
//在处理功能之上的一层 这里可以做前操作 后操作
例如可以验证是否处理请求。
class ProxySubject implements Subject {
private
RealSubject real;
public ProxySubject(RealSubject real)
{
this.real = real;
}
//
public void request()
{
preRequest();
real.request();
afterRequest();
}
private
void preRequest() {}
private void afterRequest() {}
}
//java自身提供代理类使用反射机制
public class ProxyPattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Composite 模式例子
//在用户的角度 并不知道 不见是单独的还是符合的 只要调用接口级方法 operation
package pattern.b.composite;
import java.util.ArrayList;
import java.util.Iterator;
import
java.util.List;
// 安全模式 在接口级只提供部分功能 leaf 和 composite 有不同的功能
interface Component1 {
public void operation();
}
class leaf1 implements Component1 {
public void operation()
{
System.out.println("this is the leaf1");
}
}
class Composite1 implements Component1 {
private List
components;
public Composite1() {
components = new
ArrayList();
}
public void operation() {
Iterator it = components.iterator();
Component1 com =
null;
while (it.hasNext()) {
com = (Component1)
it.next();
com.operation();
}
}
public void addComponent(Component1 com) {
components.add(com);
}
public void removeComponent(int
index) {
components.remove(index);
}
}
// 透明模式 接口定义全部功能 leaf中可能使用空方法或抛出异常 活着写一层 抽象类 写上默认实现方法(极端情况下 是空或异常)
interface Component2 {
public void operation();
public void addComponent(Component2 com);
public void
removeComponent(int index);
}
class leaf2 implements Component2 {
public void operation()
{
System.out.println("this is the leaf1");
}
//这个使用空方法
public void addComponent(Component2 com) {}
//这个使用不支持异常
public void removeComponent(int index){
throw new
UnsupportedOperationException();
}
}
class Composite2 implements Component2 {
private List
components;
public Composite2() {
components = new
ArrayList();
}
public void operation() {
Iterator it = components.iterator();
Component2 com =
null;
while (it.hasNext()) {
com = (Component2)
it.next();
com.operation();
}
}
public void addComponent(Component2 com) {
components.add(com);
}
public void removeComponent(int
index) {
components.remove(index);
}
}
//也可以用一个抽象类
abstract class AbstractComponent implements Component2{
public void
operation() {}
public void addComponent(Component2 com) {}
abstract public void removeComponent(int index);
}
public class CompositePattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Flywight 模式例子
// 将共同的跟不同的属性分离 共享共同属性 而不同属性由外部传入 进行特定操作
package pattern.b.flyweight;
import java.util.HashMap;
import
java.util.Map;
// 1没有办法通过obj.value方式 2没有改变属性的方法 3不能通过继承重置属性 所以这个对象是 immutable 不可变的
final
class State {
private String value = null;
public
State(String value) {
this.value = value;
}
public String getValue() {
return value;
}
}
interface Flyweight {
void operation(String extrinsicState);
}
class ConFlyweight1 implements Flyweight {
//state 表示享元的内部状态
//或者用构造函数传入
private State state = new State("state1");
//out 为外部传给享元的 外部状态
public void operation(String out) {
//使用外部状态和内部状态来执行 operation操作
System.out.println("ConFlyweight1: " +
out + state.getValue());
}
}
// 充数的
class ConFlyweight2 implements Flyweight {
private State
state = new State("state2");
public void operation(String out)
{
System.out.println("ConFlyweight2: " + state.getValue() + out
);
}
}
class FlyweightFactory {
Map flyweights = new HashMap();
public Flyweight getFlyweight(String key) {
if
(flyweights.containsKey(key)) {
return (Flyweight)
flyweights.get(key);
} else {
//
这里就随便写的
Flyweight flyweight = null;
if
(key.charAt(key.length() - 1) == '1') {
flyweight = new
ConFlyweight1();
flyweights.put(key,
flyweight);
} else {
flyweight = new
ConFlyweight2();
flyweights.put(key,
flyweight);
}
return flyweight;
}
}
}
public class FlyweightPattern {
public static void main(String[] args)
{
FlyweightFactory factory = new FlyweightFactory();
Flyweight flyweight1a = factory.getFlyweight("flytest1");
flyweight1a.operation("outparam1");
}
}
***********************************************************************
// Bridge 模式例子
//对一处的操作 改成引用一个对象 具体操作再另一个对象中进行 这样便于功能扩展
package pattern.b.bridge;
interface Implementor {
void realOperation();
}
class ConImplementor1 implements Implementor {
public void
realOperation() {
System.out.println("do the real
operation1");
}
}
class ConImplementor2 implements Implementor {
public void
realOperation() {
System.out.println("do the real
operation2");
}
}
abstract class Abstraction {
protected Implementor imp;
public Abstraction(Implementor imp) {
this.imp = imp;
}
protected void med0() {}
abstract public void
operation();
}
class ConAbstraction extends Abstraction{
public
ConAbstraction(Implementor imp) {
super(imp);
}
public void operation() {
med0();
imp.realOperation(); }
}
public class BridgePattern {
public static void main(String[] args)
{
Implementor imp = new ConImplementor1();
Abstraction abs
= new ConAbstraction(imp);
abs.operation();
}
}
***********************************************************************
//Decorator 模式例子
package pattern.b.decorator;
//源部件和修饰类的共同接口
interface Component {
void operation();
}
class ConComponent implements Component {
public void operation()
{
System.out.println("the begin operation");
}
}
//没有提供给component赋值的方法 所以声明这个类为抽象的 这里并没有抽象的方法就是不像让这个类有实例
abstract class
Decotor implements Component{
private Component component;
public void operation() {
component.operation();
}
}
class ConDecotor1 extends Decotor {
private Component
component;
public ConDecotor1(Component component) {
this.component = component;
}
public void operation()
{
super.operation();
//!!注意这里 这里提供了功能的添加
//
这里就是Decorator的核心部分 不是修改功能而是添加功能 将一个component传入装饰类调用对象的接口
//方法
在此过程添加功能 重新实现接口方法的功能
med0();
}
private void
med0() {
System.out.println("1");
}
}
class ConDecotor2 extends Decotor {
private Component
component;
public ConDecotor2(Component component) {
this.component = component;
}
public void operation()
{
super.operation();
med0();
}
private void med0() {
System.out.println("2");
}
}
//class
public class DecoratorPattern {
public static void main(String[] args)
{
//注意 起点位置是从一个ConComponent开始的!!
Component component = new
ConDecotor2(new ConDecotor1(new ConComponent()));
component.operation();
}
}
***********************************************************************
//Facade 的例子
//在子系统上建立了一层 对外使用感觉比较简单 Facade的方法中封装与子系统交互的逻辑
package pattern.b.facade;
class Exa1 {
public void med0() {}
}
class Exa2 {
public void themed() {}
}
//这就是一个简单的Facade的方法的例子
class Facade {
public void facdeMed()
{
Exa1 exa1 = new Exa1();
exa1.med0();
Exa2 exa2 = new Exa2();
exa2.themed();
}
}
public class FacadePattern {
public static void main(String[] args)
{
}
}
***********************************************************************
////////////////////////////////////////////////////////////////////
行为模式
////////////////////////////////////////////////////////////////////
//Command 模式例子
//感觉将一个类的方法 分散开了 抽象成了接口方法 注意 参数和返回值要一致
//每个Command封装一个命令
也就是一种操作
package pattern.c.command;
//这个是逻辑真正实现的位置
class Receiver {
public void med1() {}
public void med2() {}
}
interface Command {
// 要抽象成统一接口方法 是有局限性的
void
execute();
}
class ConCommand1 implements Command{
private Receiver
receiver;
public ConCommand1(Receiver receiver) {
this.receiver = receiver;
}
public void execute()
{
receiver.med1();
}
}
class ConCommand2 implements Command{
private Receiver
receiver;
public ConCommand2(Receiver receiver) {
this.receiver = receiver;
}
public void execute()
{
receiver.med2();
}
}
class Invoker {
private Command command;
public
Invoker(Command command) {
this.command = command;
}
public void action() {
command.execute();
}
}
public class CommandPattern {
public static void main(String[] args)
{
Receiver receiver = new Receiver();
// 生成一个命令
Command command = new ConCommand1(receiver);
Invoker invoker = new
Invoker(command);
invoker.action();
}
}
***********************************************************************
//Strategy 模式例子
//Strategy中封装了算法
package pattern.c.strategy;
interface Strategy {
void stMed();
}
class Constrategy1 {
public void stMed() {}
}
class constrategy2 {
public void stMed() {}
}
class Context {
private Strategy strategy;
public
Context (Strategy strategy) {
this.strategy = strategy;
}
public void ContextInterface() {
strategy.stMed();
}
}
public class StrategyPattern {
public static void main(String[] args)
{
}
}
***********************************************************************
//State模式例子
//将一种状态和状态的助理封装倒state中
package pattern.c.state;
class Context {
private State state = new CloseState();
public
void changeState(State state) {
this.state = state;
}
public
void ruquest() {
state.handle(this);
}
}
interface State {
void handle(Context context);
}
//表示打开状态
class OpenState implements State{
public void handle(Context
context) {
System.out.println("do something for
open");
context.changeState(new CloseState());
}
}
//表示关闭状态
class CloseState implements State{
public void handle(Context
context) {
System.out.println("do something for
open");
context.changeState(new OpenState());
}
}
public class StatePattern {
public static void main(String[] args)
{
}
}
***********************************************************************
//Visitor模式例子
//双向传入
package pattern.c.visitor;
import java.util.*;
interface Visitor {
void visitConElementA(ConElementA
conElementA);
void visitConElementB(ConElementB conElementB);
}
class ConVisitor1 implements Visitor{
public void
visitConElementA(ConElementA conElementA) {
String value =
conElementA.value;
conElementA.operation();
//do
something
}
public void visitConElementB(ConElementB conElementB)
{
String value =
conElementB.value;
conElementB.operation();
//do
something
}
}
class ConVisitor2 implements Visitor{
public void
visitConElementA(ConElementA conElementA) {
String value =
conElementA.value;
conElementA.operation();
//do
something
}
public void visitConElementB(ConElementB conElementB)
{
String value =
conElementB.value;
conElementB.operation();
//do
something
}
}
interface Element {
void accept(Visitor visitor);
}
class ConElementA implements Element {
String value =
"aa";
public void operation() {}
public void accept(Visitor
visitor) {
visitor.visitConElementA(this);
}
}
class ConElementB implements Element {
String value =
"bb";
public void operation() {}
public void accept(Visitor
visitor) {
visitor.visitConElementB(this);
}
}
class ObjectStructure {
private List Elements = new
ArrayList();
public void action(Visitor visitor) {
Iterator it =
Elements.iterator();
Element element = null;
while (it.hasNext())
{
element = (Element)
it.next();
element.accept(visitor);
}
}
public void
add(Element element) {
Elements.add(element);
}
}
public class VisitorPattern {
public static void main(String[] args)
{
ObjectStructure objs = new ObjectStructure();
objs.add(new
ConElementA());
objs.add(new ConElementA());
objs.add(new
ConElementB());
objs.action(new ConVisitor1());
}
}
***********************************************************************
//Observable模式例子
package pattern.c.observable;
import java.util.*;
class State {}
interface Subject {
void attach(Observer observer);
void
detach(Observer observer);
void myNotify();
State
getState();
void setState(State state);
}
class ConSubject implements Subject {
List observers = new
ArrayList();
State state = new State();
public void attach(Observer
observer) {
observers.add(observer);
}
public void
detach(Observer observer)
{
observers.remove(observer);
}
public void myNotify()
{
Iterator it = observers.iterator();
Observer observer =
null;
while (it.hasNext()) {
observer = (Observer)
it.next();
observer.update();
}
}
public State
getState() {
return state;
}
public void setState(State state)
{
this.state = state;
}
}
interface Observer {
void update();
}
class ConObserver1 implements Observer{
private Subject
subject;
public ConObserver1(Subject subject) {
this.subject =
subject;
}
public void update() {
State state =
subject.getState();
// do something with state
}
}
class ConObserver2 implements Observer{
private Subject
subject;
public ConObserver2(Subject subject) {
this.subject =
subject;
}
public void update() {
State state =
subject.getState();
// do something with state
}
}
public class ObservablePattern {
public static void main(String[] args)
{
}
}
***********************************************************************
//Mediator模式例子
package pattern.c.mediator;
public interface Colleague {
void setState(String
state);
String getState();
void change();
void action();
}
package pattern.c.mediator;
public class ConColleague1 implements Colleague {
private
String state = null;
private Mediator mediator;
public
void change() {
mediator.changeCol1();
}
public
ConColleague1 (Mediator mediator) {
this.mediator = mediator;
}
public void setState(String state) {
this.state =
state;
}
public String getState() {
return
state;
}
public void action() {
System.out.println("this 2 and the state is " + state);
}
}
package pattern.c.mediator;
public class ConColleague2 implements Colleague {
private
String state = null;
private Mediator mediator;
public
ConColleague2 (Mediator mediator) {
this.mediator = mediator;
}
public void change() {
mediator.changeCol2();
}
public void setState(String
state) {
this.state = state;
}
public String
getState() {
return state;
}
public void
action() {
System.out.println("this 1 and the state is " +
state);
}
}
package pattern.c.mediator;
public class ConMediator implements Mediator {
private
ConColleague1 con1;
private ConColleague2 con2;
public
void setCon1(ConColleague1 con1) {
this.con1 = con1;
}
public void setCon2(ConColleague2 con2) {
this.con2 =
con2;
}
public void changeCol1() {
String state
= con1.getState();
con2.setState(state);
con2.action();
}
public void changeCol2() {
String state = con2.getState();
con1.setState(state);
con1.action();
}
}
package pattern.c.mediator;
public interface Mediator {
void setCon1(ConColleague1
con1);
void setCon2(ConColleague2 con2);
void
changeCol1();
void changeCol2();
}
package pattern.c.mediator;
public class MediatorTest {
public static void main(String[]
args) {
Mediator mediator = new ConMediator();
ConColleague1 col1 = new ConColleague1(mediator);
col1.setState("lq
test in the MediatorTest main 18");
ConColleague2 col2 = new
ConColleague2(mediator);
mediator.setCon1(col1);
mediator.setCon2(col2);
col1.change();
}
}
***********************************************************************
//Iterator模式例子
package pattern.c.iterator;
interface Aggregate {
MyIterator Iterator();
}
class ConAggregate {
public MyIterator Iterator() {
return new
ConMyIterator();
}
}
interface MyIterator {
Object First();
Object Last();
boolean
hasNext();
Object Next();
}
class ConMyIterator implements MyIterator{
Object[] objs = new
Object[100];
int index = 0;
public Object First() {
index =
0;
return objs[index];
}
public Object Last() {
index =
objs.length - 1;
return objs[index];
}
public boolean
hasNext() {
return index < objs.length;
}
public Object
Next() {
if (index == objs.length - 1) {
return null;
} else
{
return objs[++index];
}
}
}
public class IteratorPattern {
public static void main(String[] args) {
}
}
***********************************************************************
// Template Method 模式例子
package pattern.c.template_method;
abstract class father {
abstract void med0();
abstract void
med1();
//operation为一个模板方法
public void operation()
{
med0();
med1();
// and other logic
}
}
class child extends father {
public void med0()
{
System.out.println("the med0 method");
}
public void med1()
{
System.out.println("the med1 method");
}
}
public class TemplateMethodPattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Chain of
Responsiblity模式例子
//将请求在链上传递
//如果是当前节点的请求就结束传递处理请求否则向下传递请求
//每个节点有另一个节点的引用
实现链状结构
package pattern.c.chain_of_responsiblity;
interface Handler{
void handleRequest(int key);
}
class ConHandler1 implements Handler {
private Handler
handler;
public ConHandler1(Handler handler) {
this.handler =
handler;
}
public void handleRequest(int key) {
if (key == 1)
{
System.out.println("handle in 1");
//handle something
} else
{
handler.handleRequest(key);
}
}
}
class ConHandler2 implements Handler {
private Handler
handler;
public ConHandler2(Handler handler) {
this.handler =
handler;
}
public void handleRequest(int key) {
if (key == 2)
{
System.out.println("handle in 2");
//handle something
} else
{
handler.handleRequest(key);
}
}
}
class ConHandler3 implements Handler {
private Handler
handler;
public ConHandler3(Handler handler) {
this.handler =
handler;
}
public void handleRequest(int key) {
if (key == 3)
{
System.out.println("handle in 3");
//handle something
} else
{
handler.handleRequest(key);
}
}
}
public class ChainOfResponsiblityPattern {
public static void
main(String[] args) {
Handler handler = new ConHandler2(new ConHandler1(new
ConHandler3(null)));
handler.handleRequest(3);
}
}
***********************************************************************
//Interpreter模式例子
/*
* Variable 表示变量 存储在上下文中
* Constant
终结表达式
* And 与的关系 双目
* Not 反的关系 单目
*/
package pattern.c.interpreter;
import java.util.*;
class Context {
private Map variables = new HashMap();
public boolean lookUp(Variable name) {
Boolean value = (Boolean)
variables.get(name);
if (value == null) {
return
false;
}
return value.booleanValue();
}
public void bind(Variable name, boolean value) {
variables.put(name, new Boolean(value));
}
}
interface Expression {
boolean interpret(Context cont);
}
class Constant implements Expression {
private boolean value;
public Constant(boolean value) {
this.value = value;
}
public boolean interpret(Context cont) {
return
value;
}
}
class Variable implements Expression{
private String name;
public Variable(String name) {
this.name = name;
}
public boolean interpret(Context cont) {
return
cont.lookUp(this);
}
}
class And implements Expression {
private Expression left;
private Expression right;
public And(Expression left, Expression
right) {
this.left = left;
this.right = right;
}
public boolean interpret(Context cont) {
return
left.interpret(cont) && right.interpret(cont);
}
}
class Not implements Expression {
private Expression
expression;
public Not(Expression expression) {
this.expression = expression;
}
public boolean
interpret(Context cont) {
return ! expression.interpret(cont);
}
}
public class InterpreterPattern {
public static void main(String[]
args) {
Context cont = new Context();
Variable variable =
new Variable("parameter1");
cont.bind(variable, true);
Expression and = new And(new Not(new Constant(true)), new And(new
Constant(false), new Variable("parameter1")));
// (!(true))
&& ((false)&&(true))
and.interpret(cont);
}
}
***********************************************************************
//Memento模式例子
package pattern.c.memento;
class Memento {
String value1;
int value2;
public Memento(String value1, int value2) {
this.value1 =
value1;
this.value2 = value2;
}
}
class Originator {
private String value1;
private int
value2;
public Originator(String value1, int value2) {
this.value1 = value1;
this.value2 = value2;
}
public void setMemento(Memento memento) {
value1 =
memento.value1;
value2 = memento.value2;
}
public Memento createMemento() {
Memento memento = new
Memento(value1, value2);
return memento;
}
public
void setValue1(String value1) {
this.value1 = value1;
}
public void setValue2(int value2) {
this.value2 =
value2;
}
}
class CareTaker {
private Memento memento;
public
Memento retrieveMemento() {
return memento;
}
public void saveMemento(Memento memento) {
this.memento =
memento;
}
}
public class MementoPattern {
public static void main(String[] args)
{
Originator originator = new Originator("test1", 1);
CareTaker careTaker = new CareTaker();
//保存状态
careTaker.saveMemento(originator.createMemento());
originator.setValue1("test2");
originator.setValue2(2);
//恢复状态
originator.setMemento(careTaker.retrieveMemento());
}
}
***********************************************************************
相关文章推荐
- 23种设计模式概要及易懂的例子
- 常用的设计模式及例子(三)
- java 23种设计模式及具体例子
- 最经典的java 23种设计模式及具体例子
- 设计模式 之 单例模式简单例子(Java)
- 设计模式---生活例子
- [设计模式]_[中级]_[观察者模式在项目中实际使用例子]
- 桥接设计模式例子
- 委托和事件(五)--例子--涵盖了观察者设计模式
- 设计模式:一个体现Java接口及工厂模式优点的例子
- 《Head First 设计模式》例子的C++实现(1 策略模式)
- 通过例子学设计模式之--建造者模式以及使用场景说明(C++实现)
- 仅仅一个工厂设计模式的例子
- 通过例子学设计模式之--抽象工厂模式以及使用场景说明(C++实现)
- DAO设计模式例子
- 用例子说明MVC 设计模式(以Objective-C 实现)
- 设计模式之Future模式例子
- 设计模式六大原则例子(五)-- 最少知识原则(LKP)/ 迪米特法则(LOD)例子
- 【设计模式】Java服务开发应用策略模式的一个例子
- 在JDK源码中搜索设计模式的例子