`
chenzhaogogogo
  • 浏览: 21206 次
  • 性别: Icon_minigender_1
  • 来自: 武汉
社区版块
存档分类
最新评论

23种设计模式的代码版(Java) ---行为型

阅读更多
//**********行为型模式************* 
   
  //Chain   of   Responsibility  
  //与Decorator的实现形式相类似,  
  //Decorator是在原来的方法之上进行添加功能,而  
  //Chain则是判断信号如果不是当前处理的则转交个下一个节点处理  
  //我可以使用if分支来实现相同的效果,但是不够灵活,链上的每个节点是可以替换增加的,相对  
  //比较灵活,我们可以设计接口实现对节点的增删操作,而实现更方便的效果  
  //这个是一个链状的结构,有没有想过使用环状结构  
   
  interface   Handler   {  
  void   handRequest(int   signal);  
  }  
   
  class   CHandler1   implements   Handler   {  
  private   Handler   handler;  
   
  public   CHandler1(Handler   handler)   {  
  this.handler   =   handler;  
  }  
   
  public   void   handRequest(int   signal)   {  
  if   (signal   ==   1)   {  
  System.out.println("handle   signal   1");  
  }  
  else   {  
  handler.handRequest(signal);  
  }  
  }    
  }  
   
  class   CHandler2   implements   Handler   {  
  private   Handler   handler;  
   
  public   CHandler2(Handler   handler)   {  
  this.handler   =   handler;  
  }  
   
  public   void   handRequest(int   signal)   {  
  if   (signal   ==   2)   {  
  System.out.println("handle   signal   2");  
  }  
  else   {  
  handler.handRequest(signal);  
  }  
  }    
  }  
   
  class   CHandler3   implements   Handler   {  
  public   void   handRequest(int   signal)   {  
  if   (signal   ==   3)   {  
  System.out.println("handle   signal   3");  
  }  
  else   {  
  throw   new   Error("can't   handle   signal");  
  }  
  }    
  }  
   
  class   ChainClient   {  
  public   static   void   main(String[]   args)   {  
  Handler   h3   =   new   CHandler3();  
  Handler   h2   =   new   CHandler2(h3);  
  Handler   h1   =   new   CHandler1(h2);  
   
  h1.handRequest(2);  
  }  
  }  
   
  //Interpreter  
  //感觉跟Composite很类似,只不过他分文终结符和非终结符  
   
  //Template   Method  
   
  abstract   class   TemplateMethod   {  
  abstract   void   amd1();  
   
  abstract   void   amd2();  
   
  //此方法为一个Template   Method方法  
  public   void   tmd()   {  
  amd1();  
  amd2();  
  }  
  }  
   
  //State  
   
  //标准型  
  //状态和操作不应该耦合在一起  
  class   Contexta   {  
  private   State   st;  
   
  public   Contexta(int   nst)   {  
  changeStfromNum(nst);  
  }  
   
  public   void   changeStfromNum(int   nst)   {  
  if   (nst   ==   1)   {  
  st   =   new   CStatea1();  
  }  
  else   if   (nst   ==   2)   {  
  st   =   new   CStatea2();  
  }  
   
  throw   new   Error("bad   state");  
  }  
   
  void   request()   {  
  st.handle(this);  
  }  
  }  
   
  interface   State   {  
  void   handle(Contexta   context);  
  }  
   
  class   CStatea1   implements   State   {  
  public   void   handle(Contexta   context)   {  
  System.out.println("state   1");  
  //也许在一个状态的处理过程中要改变状态,例如打开之后立即关闭这种效果  
  //context.changeStfromNum(2);  
  }  
  }  
   
  class   CStatea2   implements   State   {  
  public   void   handle(Contexta   context)   {  
  System.out.println("state   2");  
  }  
  }  
   
  //工厂型
 
  //根据状态不通生成不同的state  
   
  //class   StateFactory   {  
  // public   static   State   getStateInstance(int   num)   {  
  // State   st   =   null;  
  //  
  // if   (num   ==   1)   {  
  // st   =   new   CStatea1();  
  // }  
  // else   if   (num   ==   2)   {  
  // st   =   new   CStatea2();  
  // }  
  //  
  // return   st;  
  // }  
  //}  
   
  //Strategy 
  //跟Bridge相类似,就是一种多态的表示  
   
  //Visitor  
  //双向引用,使用另外的一个类调用自己的方法,访问自己的数据结构  
  interface   Visitor   {  
  void   visitElement(Elementd   element);  
  }  
   
  class   CVisitor   implements   Visitor   {  
  public   void   visitElement(Elementd   element)   {  
  element.operation();  
  }  
  }  
   
  interface   Elementd   {  
  void   accept(Visitor   visitor);  
   
  void   operation();  
  }  
   
  class   CElementd   implements   Elementd   {  
  public   void   accept(Visitor   visitor)   {  
  visitor.visitElement(this);  
  }  
   
  public   void   operation()   {  
  //实际的操作在这里  
  }  
  }  
   
  class   Clientd   {  
  public   static   void   main()   {  
  Elementd   elm   =   new   CElementd();  
  Visitor   vis   =   new   CVisitor();  
   
  vis.visitElement(elm);  
  }  
  }  
   
  //Iteraotr    
  //使用迭代器对一个类的数据结构进行顺序迭代  
   
  interface   Structure   {  
  interface   Iteratora   {  
  void   first();  
   
  boolean   hasElement();  
   
  Object   next();  
   
  }  
  }  
   
  class   Structure1   implements   Structure   {  
  Object[]   objs   =   new   Object[100];  
   
  //使用内部类是为了对Struture1的数据结构有完全的访问权  
  class   Iteratora1   implements   Iteratora   {  
  int   index   =   0;  
   
  public   void   first()   {  
  index   =   0;  
  }  
   
  public   boolean   hasElement()   {  
  return   index   <   100;  
  }    
   
  public   Object   next()   {  
  Object   obj   =   null;  
   
  if   (hasElement())   {  
  obj   =   objs[index];  
  index++;  
  }  
   
  return   obj;  
  }  
  }  
  }  
   
  //Meditor      
  class   A1   {  
  public   void   operation1()   {}  
  public   void   operation2()   {}  
  }  
   
  class   A2   {  
  public   void   operation1()   {}  
  public   void   operation2()   {}  
  }  
   
  class   Mediator   {  
  A1   a1;  
  A2   a2;  
   
  public   Mediator(A1   a1,   A2   a2)   {  
  this.a1   =   a1;  
  this.a2   =   a2;  
   
  }  
   
  //如果我想实现这个功能我可能会把他放在A1中  
  //但是这样耦合大,我不想在A1中出现A2对象的引用,  
  //所以我使用了Mediator作为中介  
  public   void   mmed1()   {  
  a1.operation1();  
  a2.operation2();  
  }  
   
  public   void   mmed2()   {  
  a2.operation1();  
  a1.operation2();  
  }  
  }  
   
//Command  
  //我认为就是将方法转换成了类  
   
  class   Receiver   {  
  public   void   action1()   {}  
   
  public   void   action2()   {}  
  }  
   
  interface   Command   {  
  void   Execute();  
  }  
   
  class   CCommand1   implements   Command   {  
  private   Receiver   receiver;  
   
  public   CCommand1(Receiver   receiver)   {  
  this.receiver   =   receiver;  
  }  
   
  public   void   Execute()   {  
  receiver.action1();  
  }  
  }  
   
  class   CCommand2   implements   Command   {  
  private   Receiver   receiver;  
   
  public   CCommand2(Receiver   receiver)   {  
  this.receiver   =   receiver;  
  }  
   
  public   void   Execute()   {  
  receiver.action2();  
  }  
  }  
   
  //Observer    
  //在这里看似乎这个模式没有什么用  
  //但是如果我有一个线程监控Subject,如果Subject的状态  
  //发生了变化,则更改Observer的状态,并出发一些操作,这样就有实际的意义了  
  //Observer与Visitor有相似的地方,都存在双向引用  
  //Subject可以注册很多Observer  
   
  interface   Subjectb   {  
  void   attach(Observer   observer);  
   
  void   detach(Observer   observer);  
   
  void   mynotify();  
   
  int   getState();  
   
  void   setState(int   state);  
  }  
   
  class   Subjectb1   implements   Subjectb   {  
  List   observers   =   new   ArrayList();  
  int   state;  
   
  public   void   attach(Observer   observer)   {  
  observers.add(observer);  
  }  
   
  public   void   detach(Observer   observer)   {  
  observers.remove(observer);  
  }  
   
  public   void   mynotify()   {  
  Observer   observer   =   null;  
  Iterator   it   =   observers.iterator();  
   
  while   (it.hasNext())   {  
  observer   =   (Observer)   it.next();  
  observer.Update();  
  }  
  }  
   
  public   int   getState()   {  
  return   state;  
  }  
   
  public   void   setState(int   state)   {  
  this.state   =   state;  
  }  
  }  
   
  interface   Observer   {  
  void   Update();  
  }  
   
  class   Observer1   implements   Observer   {  
  Subjectb   subject;  
  int   state;  
   
  public   Observer1(Subjectb   subject)   {  
  this.subject   =   subject;  
  }  
   
  public   void   Update()   {  
  this.state   =   subject.getState();  
  }  
   
  public   void   operation()   {  
  //一些基于state的操作  
  }  
  }  
   
  //Memento 
  //感觉此模式没有什么大用  
   
  class   Memento   {  
  int   state;  
   
  public   int   getState()   {  
  return   state;  
  }  
   
  public   void   setState(int   state)   {  
  this.state   =   state;  
  }  
  }  
   
  class   Originator   {  
  int   state;  
   
  public   void   setMemento(Memento   memento)   {  
  state   =   memento.getState();  
  }  
   
  public   Memento   createMemento()   {  
  Memento   memento   =   new   Memento();  
  memento.setState(1);  
  return   memento;  
  }  
   
  public   int   getState()   {  
  return   state;  
  }  
   
  public   void   setState(int   state)   {  
  this.state   =   state;  
  }  
  }  
   
  class   careTaker   {  
  Memento   memento;  
   
  public   void   saverMemento(Memento   memento)   {  
  this.memento   =   memento;  
  }  
   
  public   Memento   retrieveMemento()   {  
  return   memento;  
  }  
  }  
   
  //程序最终还是顺序执行的,是由不通部分的操作拼接起来的  
  //将不同类的代码拼接起来是通过引用实现的,有了引用我就  
  //相当于有了一定访问数据结构和方法的能力,这与写在类内部  
  //差不多,例如我想将一个类中的一个方法抽离出去,因为这个方法依赖与此类的数据和其他方法  
  //直接将代码移走是不行的,但如果我们拥有了此类对象的引用,则与写在此类  
  //内部无异,所以我们拥有了引用就可以将此方法移出  
  public   class   tt1   {  
  public   static   void   main(String[]   args)   {  
  }  
  }

分享到:
评论

相关推荐

    java之23种设计模式完整代码

    在Java中,这23种设计模式分为三大类:创建型、结构型和行为型。 1. **创建型设计模式**: - **单例模式**:确保一个类只有一个实例,并提供全局访问点。 - **工厂方法模式**:定义一个用于创建对象的接口,让...

    java-设计模式-状态模式-模拟审批流程-二级审批 完整代码

    状态模式是一种行为设计模式,它允许对象在内部状态改变时改变其行为,对象看起来似乎修改了它的类。在这个示例中,我们关注的是如何使用Java实现一个审批流程,特别是涉及二级审批的场景。这个压缩包文件包含了一个...

    java23种设计模式及其代码

    这篇资料"java23种设计模式及其代码"涵盖了这些模式的详细解释和实际代码实现,对于学习和理解设计模式具有极大的帮助。 1. 创建型模式(5种): - 单例模式:保证一个类只有一个实例,并提供一个全局访问点。 - ...

    2020版23种Java设计模式-图解-附代码.pdf

    本教程详细介绍了23种经典的Java设计模式,包括创建型、结构型和行为型模式。下面将对这三大类模式进行深入解析。 1. **创建型模式**: - **工厂方法模式**:定义一个用于创建对象的接口,让子类决定实例化哪一个...

    java23种设计模式详解+源码(绝对详解)

    在Java编程中,有23种经典的GoF(Gang of Four)设计模式,它们被分为三大类:创建型、结构型和行为型。本资源集合了这些模式的详细解释与源码分析,旨在帮助开发者深入理解和应用设计模式。 1. 创建型模式...

    Java之23种设计模式解析

    这份资料详细介绍了在Java编程中常用的23种设计模式,旨在提升开发者对于软件设计的理解和应用能力,从而写出更加高效、可维护和可扩展的代码。 首先,我们来看一下23种设计模式的分类:它们可以分为三大类,即创建...

    Java设计模式----通俗易懂版

    这23种设计模式可以分为三类:创建型、结构型和行为型。 1. 创建型设计模式: - 单例模式:保证一个类只有一个实例,并提供全局访问点。 - 工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类...

    《Java设计模式》课后答案-刘伟.rar

    本书涵盖了23种经典的GOF(GoF,Gang of Four)设计模式,包括创建型、结构型和行为型三大类。创建型设计模式如单例(Singleton)、工厂方法(Factory Method)、抽象工厂(Abstract Factory)、建造者(Builder)和...

    极客学院java-23种设计模式

    在Java领域,23种设计模式被广泛接受,它们分为三大类:创建型、结构型和行为型。下面,我们将详细探讨这些设计模式以及它们在实际开发中的应用。 1. 创建型设计模式: - 单例模式(Singleton):确保一个类只有一...

    java设计模式---诙谐易懂版

    设计模式一般分为三大类:创建型模式、结构型模式和行为型模式。 3. 根据文件内容,诸葛亮给赵云的三个锦囊妙计可以用策略模式来实现。每个妙计对应一个实现了策略接口的具体策略类。例如,BackDoor类实现了...

    【资源免费下载】Java代码积累丨大话设计模式(Java实现版本)、线程协作

    Java代码积累:并发 设计模式 数据结构 使用容器 实用 类 基础知识 并发性 演示线程的生命周期 生产者-消费者 设计模式参考《大话设计模式》 工厂简单模式 创造型模式 工厂方法模式 抽象工厂模式 原型模式 建造者...

    Java开发中的23种设计模式代码整理

    这个压缩包文件包含了23种经典的Java设计模式,这些模式通常被分为三大类:创建型、结构型和行为型。 1. 创建型设计模式: - 单例模式:确保一个类只有一个实例,并提供全局访问点。 - 工厂方法模式:定义一个...

    Java-设计模式.zip

    这个“Java-设计模式.zip”压缩包很可能是包含一系列关于Java设计模式的教程或者代码示例。其中,“2.Java面对-10-设计模式”可能是一个文档或章节,专门讨论面向对象的设计模式。 设计模式分为三类:创建型、结构...

    java23种设计模式详细讲解

    《java23种设计模式详细讲解》这本书系统地介绍了23种设计模式,并通过具体的例子来阐释每种模式的应用场景和实现方式,旨在帮助程序员提升设计能力,编写更优雅、可维护的代码。书中的内容涵盖了创建型模式、结构型...

    Java23种设计模式可直接运行Demo

    设计模式分为三大类: 创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 ...

    Java设计模式代码

    本资源“Java设计模式代码”提供了一系列具体的Java实现,帮助开发者深入理解并应用这些模式。下面将详细阐述Java设计模式中的主要类别及其重要知识点。 1. 创建型模式: - 单例模式:确保一个类只有一个实例,并...

    Java23种设计模式.pdf

    在Java开发中,设计模式可以分为三类:创建型模式、结构型模式和行为型模式。创建型模式主要关注如何创建对象,结构型模式着重于对象和类的组合,行为型模式则专注于对象间的通信。 创建型模式包括如下几种: - ...

    JAVA的23种设计模式PPT讲解

    首先,23种设计模式按照它们的主要功能可以分为三大类:创建型模式、结构型模式和行为型模式。 1. 创建型模式(Creational Patterns): - 单例模式:确保一个类只有一个实例,并提供全局访问点。 - 工厂方法模式...

Global site tag (gtag.js) - Google Analytics