【网摘】Java设计模式

最新推荐文章于 2024-08-08 16:26:50 发布

weixin_30376083

最新推荐文章于 2024-08-08 16:26:50 发布

阅读量61

点赞数

文章标签：设计模式 java 数据库

原文链接：http://www.cnblogs.com/zephyrjung/p/4589213.html

版权

原文地址：
http://www.cnblogs.com/maowang1991/archive/2013/04/15/3023236.html

设计模式六大原则：
1.开闭原则：对扩展开放，对修改关闭。在程序需要进行扩展的时候，不能去修改原有的代码。
2.里氏代换原则：任何基类可以出现的地方，子类一定可以出现。
3.依赖倒转原则：针对接口编程，依赖于抽象而不依赖于具体。
4.接口隔离原则：使用多个隔离的接口，比使用单个接口好。
5.迪米特法则：也叫最少知道原则，即一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
6.合成复用原则：尽量使用合成/聚合的方式，而不是使用继承。
设计模式分类：
创建型模式：
工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
结构型模式：
适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式
行为型模式：
策略模式，模版方法模式，观察这么是，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者模式，中介者模式，解释器模式。
其他：并发型模式，线程池模式。

一、工厂方法模式
1.普通工厂模式

public interface Sender{ 
 public void Send(); 
}

public class MailSender implements Sender{ 
 @Override 
 public void Send(){ 
  System.out.println("This is a mail sender!"); 
 } 
} 

public class SmsSender implements Sender{ 
 @Override 
 public void Send(){ 
  System.out.println("This is a sms sender!"); 
 } 
}

public class SendFactory{ 
 public Sender produce(String type){ 
  if("mail".equals(type)){ 
   return new MailSender(); 
  }else if("sms".equals(type)){ 
   return new SmsSender(); 
  }else{ 
   System.out.println("请输入正确的类型！"); 
   return null; 
  } 
 } 
}

public class FactoryTest{ 
 public static void main(String[] args){ 
  SendFacotry factory=new SendFactory(); 
  Sender sender=factory.produce("sms"); 
  sender.Send(); 
 } 
}

2.多个工厂方法模式

对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象：

3.静态工厂方法模式

将上面的多个工厂方法模式里的方法置为静态，不需要创建实例，直接调用即可。

凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。

-------------------------------------------------------------------

二、抽象工厂模式

工厂方法模式有一个问题，就是类的创建依赖工厂类，如果想要扩展程序，必须对工厂类进行修改。抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

public interface Sender{ 
 public void Send(); 
}

public class MailSender implements Sender{ 
 @Override 
 public void Send(){ 
  System.out.println("This is mail sender!"); 
 } 
}

public class SmsSender implements Sender{ 
 @Override 
 public void Send(){ 
  System.out.println("This is sms sender!"); 
 } 
}

public interface Provider{ 
 public Sender produce(); 
}

public class SendMailFactory implements Provider{ 
 @Override 
 public Sender produce(){ 
  return new MailSender(); 
 } 
}

public class SendSmsFactory implements Provider{ 
 @Override 
 public Sender produce(){ 
  return new SmsSender(); 
 } 
}

public class Test{ 
 public static void main(String[] args){ 
  Provider provider=new SendMailFactory(); 
  Sender sender = provider.produce(); 
  sender.Send(); 
 } 
}

--------------------------------------------------------------

三、单例模式？

在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：
1. 某些类创建比较频繁，对于一些大型的对象，这是一笔很大的开销。
2. 省去了new操作符，降低了系统内存的使用率，减轻GC压力
3. 有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了，好比一个军队不能出现多个司令指挥。
初步实现：

public class Singleton{ 
 /*持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载*/ 
 private static Singleton instance=null; 
 /*私有构造方法，防止被实例化*/ 
 private Singleton(){} 
 /*静态工程方法，创建实例*/ 
 public static Singleton getInstance(){ 
  if(instance==null){ 
   instance=new Singleton(); 
  } 
  return instance; 
 } 
 /*如果该对象被用于序列化，可以保证对象在序列化前后保持一致*/ 
 public Object readResolve(){ 
  return instance; 
 } 
} 
/* 
* 
*/

---------------------------------------------------------------------------------------

四、建造者模式
工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性。

public class Builder{ 
 private List<Sender> list = new ArrayList<Sender>(); 
 public void produceMailSender(int count){ 
  for(int i=0;i<count;i++){ 
   list.add(new MailSender()); 
  } 
 } 
 public void produceSmsSender(int count){ 
  for(int i=0;i<count;i++){ 
   list.add(new SmsSender()); 
  } 
 } 
} 
public class Test{ 
 public static void main(String[] args){ 
  Builder builder=new Builder(); 
  builder.produceMailSender(10); 
 } 
}

-------------------------------------------------------------------

五、原型模式
该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。
浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。
深复制：将一个对象复制后，不论是基本数据类型还是引用类型，都是重新创建的。

public class Prototype implements Cloneable,Serializable{ 
 private static final long serialVersionUID=1L; 
 private String string; 
 private SerializableObject obj; 
 /*浅复制*/ 
 public Object clone() throws CloneNotSupportedException{ 
  Prototype proto=(Prototype)super.clone(); 
  return proto; 
 } 
 /*深复制*/ 
 public Object deepClone() throws IOException, ClassNotFoundException{ 
  /*写入当前对象的二进制流*/ 
  ByteArrayOutputStream bos=new ByteArrayOutputStream(); 
  ObjectOutputStream oos=new ObjectOutputStream(bos); 
  oos.writeObject(this); 
  /*读出二进制流产生的新对象*/ 
  ByteArrayInputStream bis=new ByteArrayInputStream(bos.toByteArray()); 
  ObjectInputStream ois=new ObjectInputStream(bis); 
  return ois.readObject(); 
 } 
 public String getString(){ 
  return string; 
 } 
 public void setString(String string){ 
  this.string=string; 
 } 
 public SerializableObject getObj(){ 
  return obj; 
 } 
 public void setObj(SerializableObject obj){ 
  this.obj=obj; 
 } 
} 
class SerializableObject implements Serializable{ 
 private static final long serialVersionUID=1L; 
}

---------------------------------------------------------------

六、适配器模式？
适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

1. 类的适配器模式

public class Source{ 
 public void method1(){ 
  System.out.println("this is original method!"); 
 } 
} 
public interface Targetable{ 
 /*与原类中的方法相同*/ 
 public void method1(); 
 /*新类的方法*/ 
 public void method2(); 
} 
public class Adapter extends Source implements Targetable{ 
 @Override 
 public void method2(){ 
  System.out.println("this is the targetable method!"); 
 } 
} 
public class AdapterTest{ 
 public static void main(String[] args){ 
  Targetable target=new Adapter(); 
  target.method1(); 
  target.method2(); 
 } 
}

2.对象的适配器模式

修改Adapter类：

public class Wrapper implements Targetable{ 
 private Source source; 
 public Wrapper(Source source){ 
  super(); 
  this.source=source; 
 } 
 @Override 
 public void method2(){ 
  System.out.println("this is the target method!"); 
 } 
 @Override 
 public void method1(){ 
  source.method1(); 
 } 
} 
public class AdapterTest{ 
 public static void main(String[] args){ 
  Source source=new Source(); 
  Targetable target=new Wrapper(source); 
  target.method1(); 
  target.method2(); 
 } 
}

3. 接口的适配器模式

public interface Sourceable{ 
 public void method1(); 
 public void method2(); 
} 
public abstract class Wrapper2 implements Sourceable{ 
 public void method1(){} 
 public void method2(){} 
} 
public class SourceSub1 extends Wrapper2{ 
 public void method1(){ 
  System.out.println("the sourceable interface's first Sub1!"); 
 } 
} 
public class SourceSub2 extends Wrapper2{ 
 public void method2(){ 
  System.out.println("the sourceable interface's second Sub2!"); 
 } 
} 
public class WrappterTest{ 
 public static void main(String[] args){ 
  Sourceable source1=new SourceSub1(); 
  Sourceable source2=new SourceSub2(); 
  source1.method1(); 
  source1.method2(); 
  source2.method1(); 
  source2.method2(); 
 } 
}

三种适配器模式的应用场景：
类适配器：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。
对象适配器：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。
接口适配器：当不希望实现一个接口中的所有方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。

------------------------------------------------------------------------------------------------------

七、装饰模式
装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

public interface Sourceable{ 
 public void method(); 
} 
public class Source implements Sourceable{ 
 @Override 
 public void method(){ 
  System.out.println("the original method!"); 
 } 
} 
public class Decorator implements Sourceable{ 
 private Sourceable source; 
 public Decorator(Sourceable source){ 
  super(); 
  this.source=source; 
 } 
 @Override 
 public void method(){ 
  System.out.println("before decorator!"); 
  source.method(); 
  System.out.println("after decorator!"); 
 } 
} 
public class DecoratorTest{ 
 public static void main(String[] args){ 
  Sourceable source=new Source(); 
  Sourceable obj=new Decorator(source); 
  obj.method(); 
 } 
}

应用场景：
1. 需要扩展一个类的功能。
2. 动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删。）
缺点：产生过多相似的对象，不易排错。
------------------------------------------------------------------------

八、代理模式
代理模式就是多一个代理类出来，替原对象进行一些操作，与装饰者模式很像，但不同的是，代理模式直接在类中实例化出要操作的对象，进行间接使用。而装饰者模式是二者均存在，可以根据需求操作原对象，也可以操作装饰过的对象。

public interface Sourceable{ 
public void method(); 
} 
public class Source implements Sourceable{ 
@Override 
public void method(){ 
  System.out.println("the original method!"); 
} 
} 
public class Proxy implements Sourceable{ 
 private Source source; 
 public Proxy(){ 
  super(); 
  this.source=new Source(); 
 } 
 @Override 
 public void method(){ 
  before(); 
  source.method(); 
  after(); 
 } 
 private void before(){ 
  System.out.println("before proxy!"); 
 } 
 private void after(){ 
  System.out.println("after proxy!"); 
 } 
} 
public class ProxyTest{ 
 public static void main(String[] args){ 
  Sourceable source=new Proxy(); 
  source.method(); 
 } 
}

------------------------------------------------------------------------

九、外观模式

public class CPU{ 
 public void startup(){ 
  System.out.println("cpu startup!"); 
 } 
 public void shutdown(){ 
  System.out.println("cpu shutdown!"); 
 } 
} 
public class Memory{ 
 public void startup(){ 
  System.out.println("memory startup!"); 
 } 
 public void shutdown(){ 
  System.out.println("memory shutdown!"); 
 } 
} 
public class Disk{ 
 public void startup(){ 
  System.out.println("disk startup!"); 
 } 
 public void shutdown(){ 
  System.out.println("disk shutdown!"); 
 } 
} 
public class Computer{ 
 private CPU cpu; 
 private Memory memory; 
 private Disk disk; 
 public Computer(){ 
  cpu=new CPU(); 
  memory=new Memory(); 
  disk=new Disk(); 
 } 
 public void startup(){ 
  System.out.println("start the computer!"); 
  cpu.startup(); 
  memory.startup(); 
  disk.startup(); 
  System.out.println("start computer finished!"); 
 } 
 public void shutdown(){ 
  System.out.println("begin to close the computer!"); 
  cpu.shutdown(); 
  memory.shutdown(); 
  disk.shutdown(); 
  System.out.println("computer closed!"); 
 } 
} 
public class User{ 
 public static void main(String[] args){ 
  Computer computer=new Computer(); 
  computer.startup(); 
  computer.shutdown(); 
 } 
}

-------------------------------------------------------------------------------------

十、桥接模式
把事物和具体实现分开，使他们各自独立的变化。例如JDBC桥DriverManager一样，JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码。

public interface Sourceable{ 
 public void method(); 
} 
public class SourceSub1 implements Sourceable{ 
 @Override 
 public void method(){ 
  System.out.println("This is the first sub!"); 
 } 
} 
public class SourceSub2 implements Sourceable{ 
 @Override 
 public void method(){ 
  System.out.println("This is the second sub!"); 
 } 
} 
public abstract class Bridge{ 
 private Sourceable source; 
 public void method(){ 
  source.method(); 
 } 
 public Sourceable getSource(){ 
  return souce; 
 } 
 public void setSource(Sourceable source){ 
  this.source=source; 
 } 
} 
public class MyBridge extends Bridge{ 
 public void method(){ 
  getSource().method(); 
 } 
} 
public class BridgeTest{ 
 public static void main(String[] args){ 
  Bridge bridge=new MyBridge(); 
  Sourceable source1=new SourceSub1(); 
  bridge.setSource(source1); 
  bridge.method(); 
  Sourceable source2=new SourceSub2(); 
  bridge.setSource(source2); 
  bridge.method(); 
 } 
}

-------------------------------------------------------------------------------

十一、组合模式

又叫部分-整体模式，具体如下代码（不要当成真正的树数据结构）

public class TreeNode{
 private String name;
 private TreeNode parent;
 private Vector<TreeNode> children=new Vector<TreeNode>();
 public TreeNode(String name){
  this.name=name;
 }
 public String getName(){
  return name;
 }
 public void setName(String name){
  this.name=name;
 }
 public TreeNode getParent(){
  return parent;
 }
 public void setParent(TreeNode parent){
  this.parent=parent;
 }
 public void add(TreeNode node){
  children.add(node);
 }
 public void remove(Tree node){
  children.remove(node);
 }
 public Enumeration<TreeNode> getChildren(){
  return children.elements();
 }
}
public class Tree{
 TreeNode root=null;
 public Tree(String name){
  root=new TreeNode(name);
 }
 public static void main(String[] args){
  Tree tree=new Tree("A");
  TreeNode nodeB=new TreeNode("B");
  TreeNOde nodeC=new TreeNode("C");
  nodeB.add(nodeC);
  tree.root.add(nodeB);
  System.out.println("build the tree finished!");
 }
}

----------------------------------------------------------------------------------------------

十二、享元模式

----------------------------------------------------------------------------------------------

十三、策略模式
策略模式定义了一些列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。

public interface ICalculator{
 public int calculate(String exp);
}
public abstract class AbstractCalculator{
 public int[] split(String exp,String opt){
  String array[]=exp.split(opt);
  int arrayInt[]=new int[2];
  arrayInt[0]=Integer.parseInt(array[0]);
  arrayInt[1]=Integer.parseInt(array[1]);
  return arrayInt;
 }
}
public class Plus extends AbstractCalculator implements ICalculator{
 @Override
 public int calculate(String exp){
  int arrayInt[]=split(exp,"\\+");
  return arrayInt[0]+arrayInt[1];
 }
}
public class Minus extends AbstractCalculator implements ICalculator{
 @Override
 public int calculate(String exp){
  int arrayInt[]=split(exp,"-");
  return arrayInt[0]-arrayInt[1];
 }
}
public class Multiply extends AbstractCalculator implements ICalculator{
 @Override
 public int calculate(String exp){
  int arrayInt[]=split(exp,"\\*");
  return arrayInt[0]*arrayInt[1];
 }
}
public class StrategyTest{
 public static void main(String[] args){
  String exp="2+8";
  ICalculator cal=new Plus();
  int result=cal.calculate(exp);
  System.out.println(result);
 }
}

------------------------------------------------------------------------------------------

十四、模板方法模式

public abstract class AbstractCalculator{
 public final int calculate(String exp,String opt){
  int array[]=split(exp,opt);
  return calculate(array[0],array[1]);
 }
 abstract public int calculate(int num1,int num2);
 public int[] split(String exp,String opt){
  String array[]=exp.split(opt);
  int arrayInt[]=new int[2];
  arrayInt[0]=Integer.parseInt(array[0]);
  arrayInt[1]=Integer.parseInt(array[1]);
  return arrayInt;
 }
}
public class Plus extends AbstractCalculator{
 @Override
 public int calculate(int num1,int num2){
  return num1+num2;
 }
}
public class StrategyTest{
 public static void main(String[] args){
  String exp="8+8";
  AbstractCalculator cal=new Plus();
  int result=cal.calculate(exp,"\\+");
  System.out.println(result);
 }
}

-------------------------------------------------------------------------------------

十五、观察者模式

类似于邮件订阅和RSS订阅，当你订阅了该文章，如果后续有更新，会及时通知你。简而言之，当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化。如下图：

MySubject类是我们的主对象，Observer1和Observer2是依赖于MySubject的对象，当MySubject变化时，Observer1和Observer2必然变化。AbstractSubject类中定义着需要监控的对象列表，可以对其进行修改：增加或删除被监控对象，且当MySubject变化时，负责通知在列表内存在的对象。实现代码如下：

//Observer接口 
public interface Observer{ 
 public void update(); 
} 
//两个实现类 
public class Observer1 implements Observer{ 
 @Override 
 public void update(){ 
  System.out.println("ovserver 1 has received!"); 
 } 
} 
 public class Observer2 implements Observer{ 
 @Override 
 public void update(){ 
  System.out.println("observer 2 has received!"); 
 } 
} 
//Subject接口及实现类： 
public interface Subject{ 
 public void add(Observer observer); 
 public void del(Observer observer); 
 public void notifyObservers(); 
 public void operation(); 
} 
public abstract class AbstractSubject implements Subject{ 
 private Vector<Observer> vector=new Vector<Observer>(); 
 @Override 
 public void add(Observer observer){ 
  vector.add(observer); 
 } 
 @Override 
 public void del(Observer observer){ 
  vector.remove(observer); 
 } 
 @Override 
 public void notifyObservers(){ 
  Enumeration<Observer> enumo=vector.elements(); 
  while(enumo.hasMoreElements()){ 
   enumo.nextElement().update(); 
  } 
 } 
} 
public class MySubject extends AbstractSubject{ 
 @Override 
 public  void operation(){ 
  System.out.println("update self!"); 
  notifyObservers(); 
 } 
} 
//测试类 
public class ObserverTest{ 
 public static void main(String[] args){ 
  Subject sub=new MySubject(); 
  sub.add(new Observer1()); 
  sub.add(new Observer2()); 
  sub.operation(); 
 } 
}

--------------------------------------------------------------------------------

十六、迭代器模式

迭代器模式就是顺序访问聚集中的对象。

public interface Collection{
 public Iterator iterator();
 public Object get(int i);
 public int size();
}
public interface Iterator{
 public Object previous();
 public Object next();
 public boolean hasNext();
 public Object first();
}
public class MyCollection implements Collection{
 public String string[]={"A","B","C","D","E"};
 @Override
 public Iterator iterator(){
  return new MyIterator(this);
 }
 @Override
 public Object get(int i){
  return string[i];
 }
 @Override
 public int size(){
  return string.length;
 }
}
public class MyIterator implements Iterator{
 private Collection collection;
 private int pos=-1;
 public MyIterator(Collection collection){
  this.collection=collection;
 }
 @Override
 public Object previous(){
  if(pos>0){
   pos--;
  }
  return collection.get(pos);
 }
 @Override
 public Object next(){
  if(pos<collection.size()-1){
   pos++;
  }
  return collection.get(pos);
 }
 @Override
 public boolean hasNext(){
  if(pos<collection.size()-1){
   return true;
  }else{
   return false;
  }
 }
 @Override
 public Object first(){
  pos=0;
  return collection.get(pos);
 }
}
public class Test{
 public static void main(String[] args){
  Collection collection=new MyCollection();
  Iterator it=collection.iterator();
  while(it.hasNext()){
   System.out.println(it.next());
  }
 }
}

-----------------------------------------------------------------------------------------

十七、责任链模式

public interface Handler{
 public void operator();
}
public abstract class AbstractHandler{
 private Handler handler;
 public Handler getHandler(){
  return handler;
 }
 public void setHandler(Handler handler){
  this.handler=handler;
 }
}
public class MyHandler extends Abstracthandler implements Handler{
 private String name;
 public MyHandler(String name){
  this.name=name;
 }
 @Override
 public void operator(){
  System.out.println(name+"deal!");
  if(getHandler()!=null){
   getHandler().operator();
  }
 }
}
public class Test{
 public static void main(String[] args){
  MyHandler h1=new MyHandler("h1");
  MyHandler h2=new MyHandler("h2");
  MyHandler h3=new MyHandler("h3");
  h1.setHandler(h2);
  h2.setHandler(h3);
  h1.operator();
 }
}

------------------------------------------------------------------------------------

十八、命令模式

命令模式类似于司令员下令让士兵去干事，司令只需要发出命令，口令经过传递到士兵，士兵去执行，三个过程互相解耦。

public interface Command{
 public void exec();
}
public class MyCommand implements Command{
 private Receiver receiver;
 public MyCommand(Receiver receiver){
  this.receiver=receiver;
 }
 @Override
 public void exec(){
  receiver.action();
 }
}
public class Receiver{
 public void action(){
  System.out.println("command received!");
 }
}
public class Invoker{
 private Command command;
 public Invoker(Command command){
  this.command=command;
 }
 public void action(){
  command.exec();
 }
}
public class Test{
 public static void main(String[] args){
  Receiver receiver=new Receiver();
  Command cmd=new MyCommand(receiver);
  Invoker invoker=new Invoker(cmd);
  invoker.action();
 }
}

-----------------------------------------------------------------------------------

十九、备忘录模式

主要目的是保存一个对象的某个状态，以便在适当的时候回复对象，也就是备份。

public class Original{
 private String value;
 public String getValue(){
  return value;
 }
 public void setValue(String value){
  this.value=value;
 }
 public Original(String value){
  this.value=value;
 }
 public Memento createMemento(){
  return new Memento(value);
 }
 public void restoreMemento(Memento memento){
  this.value=memento.getValue();
 }
}
public class Memento{
 private String value;
 public Memento(String value){
  this.value=value;
 }
 public String getValue(){
  return value;
 }
 public void setValue(String value){
  this.value=value;
 }
}
public class Storage{
 private Memento memento;
 public Storage(Memento memento){
  this.memento=memento;
 }
 public Memento getMemento(){
  return memento;
 }
 public void setMemento(Memento memento){
  this.memento=memento;
 }
}
public class Test{
 public static void main(String[] args){
  //创建原始类
  Original origi=new Original("egg');
  //创建备忘录
  Storage storage=new Storage(origi.createMemento());
  //修改原始类的状态
  System.out.println("初始化状态为："+origi.getValue());
  origi.setValue("niu");
  System.out.println("修改后的状态为："+rigi.getValue());
  //回复原始类的状态
  origi.restoreMemento(storage.getMemento());
  System.out.println("恢复后的状态为："+origi.getValue());
 }
}

------------------------------------------------------------------------------------------

二十、状态模式

当对象的状态改变时，同时改变其行为

public class State{
 private String value;
 public String getValue(){
  return value;
 }
 public void setValue(String value){
  this.value=value;
 }
 public void method1(){
  System.out.println("execute the first opt!");
 }
 public void method2(){
  System.out.println("execute the second opt!");
 }
}
public class Context{
 private State state;
 public Context(State state){
  this.state=state;
 }
 public State getState(){
  return state;
 }
 public void setState(State state){
  this.state=state;
 }
 public void method(){
  if(state.getValue().equals("state1")){
   state.method1();
  }else if(state.getValue().equals("state2")){
   state.method2();
  }
 }
}
public class Test{
 public static void main(String[] args){
  State state=new State();
  Context context=new Context(state);
  //设置第一种状态
  state.setValue("state1");
  context.method();
  //设置第二种状态
  state.setValue("state2");
  context.method();
 }
}

也就是设置一个状态类，声明状态值以及各种状态下的方法，再将此类应用到其他类中。（不过更好的方法大概应该是把状态值和方法分开吧？）

-------------------------------------------------------------------------------------------------

二十一、访问者模式？？

下面这段代码看起来很普通，就是写了两个接口及两个接口实现类然后调用一下，不造跟这个访问者模式有什么关系

public interface Visitor{
 public void visit(Subject sub);
}
public class MyVisitor implements Visitor{
 @Override
 public void visit(Subject sub){
  System.out.println("visit the subject: "+sub.getSubject());
 }
}
public interface Subject{
 public void accept(Visitor visitor);
 public String getSubject();
}
public class MySubject implements Subject{
 @Override
 public void accept(Visitor visitor){
  visitor.visit(this);
 }
 @Override
 public String getSubject(){
  return "love";
 }
}
public class Test{
 public static void main(String[] args){
  Visitor visitor=new MyVisitor();
  Subject sub=new MySubject();
  sub.accept(visitor);
 }
}

--------------------------------------------------------------------------------------

二十二、中介者模式？？？

public interface Mediator{
 public void createMediator();
 public void workAll();
}
public class MyMediator implements Mediator{
 private User user1;
 private User user2;
 public User getUser1(){
  return user1;
 }
 public User getUser2(){
  return user2;
 }
 @Override
 public void createMediator(){
  user1=new User1(this);
  user2=new User2(this);
 }
 @Override
 public void workAll(){
  user1.work();
  user2.work();
 }
}
public abstract class User{
 private Mediator mediator;
 public Mediator getMediator(){
  return mediator;
 }
 public User(Mediator mediator){
  this.mediator=mediator;
 }
 public abstract void work();
}
public class User1 extends User{
 public User1(Mediator mediator){
  super(mediator);
 }
 @Override
 public void work(){
  System.out.println("user1 exe!");
 }
}
public class User2 extends User{
 public User2(Mediator mediator){
  super(mediator);
 }
 @Override
 public void work(){
  System.out.println("user2 exe!");
 }
}
public class Test{
 public static void main(String[] args){
  Mediator mediator=new MyMediator();
  mediator.createMediator();
  mediator.workAll();
 }
}

--------------------------------------------------------------------------------------------

二十三、解释器模式？？？

public interface Expression{
 public int interpret(Context context);
}
public class Plus implements Expression{
 @Override
 public int interpret(Context context){
  return context.getNum1()+context.getNum2();
 }
}
public class Minus implements Expression{
 @Override
 public int interpret(Context context){
  return context.getNum1()-context.getNum2();
 }
}
public class Context{
 private int num1;
 private int num2;
 public Context(int num1,int num2){
  this.num1=num1;
  this.num2=num2;
 }
 public int getNum1(){
  return num1;
 }
 public void setNum1(int num1){
  this.num1=num1;
 }
 public getNum2(){
  return num2;
 }
public class Test{
 public static void main(String[] args){
  //计算9+8-2
  int result=new Minus().interpret((new Context(new Plus().interpret(new Context(9,2)),8)));
  System.out.println(result);
 }
}

转载于:https://www.cnblogs.com/zephyrjung/p/4589213.html

weixin_30376083

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【网摘】Java设计模式

原文地址： http://www.cnblogs.com/maowang1991/archive/2013/04/15/3023236.html 设计模式六大原则： 1.开闭原则：对扩展开放，对修改关闭。在程序需要进行扩展的时候，不能去修改原有的代码。 2.里氏代换原则：任何基类可以出现的地方，子类一定可以出现。 3.依赖倒转原则：针...
复制链接

扫一扫