• 1. 封面 Java设计模式 Java设计模式Java设计模式 耿祥义 张跃平 著 10/19/20181清华大学出版社
  • 2. 第一章 设计模式简介 1.1 什么是设计模式 Java设计模式 Java设计模式10/19/20182 每一个设计模式描述一个在我们周围不断重复发生的问题,以及该问题的解决方案的核心。这样,你就能一次一次地使用该方案而不必做重复劳动。
  • 3. 1.2 设计模式的起源 Java设计模式 Java设计模式10/19/20183 软件领域的设计模式起源于建筑学。 1977年,建筑大师Alexander出版了《A Pattern Language:Towns, Building, Construction》一书。受Alexander著作的影响 ,Kent Beck和Ward Cunningham在1987年举行的一次面向对象的会议上发表了论文:《在面向对象编程中使用模式》。
  • 4. 1.3 GOF之著作 Java设计模式 Java设计模式10/19/20184 目前,被公认在设计模式领域最具影响力的著作是Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides在1994年合作出版的著作:《Design Patterns:Elements of Reusable Object-Oriented Software》(中译本《设计模式:可复用的面向对象软件的基本原理》 或《设计模式》),该书被广大喜爱者昵称为GOF(Gang of Four)之书,被认为是学习设计模式的必读著作,GOF之书已经被公认为是设计模式领域的奠基之作。
  • 5. 1.4 学习设计模式的重要性 Java设计模式 Java设计模式10/19/20185 学习设计模式不仅可以使我们使用好这些成功的模式,更重要的是可以使我们更加深刻地理解面向对象的设计思想,非常有利于我们更好地使用面向对象语言解决设计中的问题。
  • 6. 1.5 合理使用模式 Java设计模式 Java设计模式10/19/20186 1.正确使用 2.避免教条 3.模式挖掘 4. 避免乱用 5.了解反模式
  • 7. 第二章 面向对象的几个基本原则 2.1 面向抽象原则 Java设计模式 Java设计模式10/19/20187 设计一个类时,不让该类面向具体的类,而是面向抽象类或接口 。
  • 8. 2.2 开-闭原则 Java设计模式 Java设计模式10/19/20188 设计应当对扩展开放,对修改关闭。 如果您的设计遵守了“开-闭原则”,那么这个设计一定是易维护的,因为在设计中增加新的模块时,不必去修改设计中的核心模块。
  • 9. 2.3 多用组合少用继承原则 Java设计模式 Java设计模式10/19/20189 设计中避开类继承的缺点,充分使用对象组合的优点。
  • 10. 2.4 高内聚-低耦合原则 Java设计模式 Java设计模式10/19/201810 如果类中的方法是一组相关的行为,则称该类是高内聚的,反之称为低内聚的。 所谓低耦合就是尽量不要让一个类含有太多的其它类的实例的引用,以避免修改系统的其中一部分会影响到其它部分。
  • 11. 第三章 UML类图简介 3.1 类(Class)_1 Java设计模式 Java设计模式10/19/201811 在UML中,使用一个长方形描述一个类的主要构成,将长方形垂直地分为三层 。 第1层是名字层,类名字是常规字形,表明该类是具体类,类名字是斜体字形,表明该类是抽象类。 第2层是变量层,也称属性层,列出类的成员变量及类型,格式是“变量名字:类型”。 第3层是方法层,也称操作层,列出类的方法及返回类型,格式是“方法名字(参数列表):类型”。
  • 12. 3.1 类(Class)_2 Java设计模式 Java设计模式10/19/201812Student+name:String #age:int -money:double+setName(String):void #printMess():void +getAge():int setAge(int):void -getMoney();名字层 变量层 方法层 +#--protected的private的友好的的public的变量或方法的访问权限是名字前加
  • 13. 3.2 接口(Interface)_1 Java设计模式 Java设计模式10/19/201813 表示接口的UML图和表示类的UML图类似,使用一个长方形描述一个接口的主要构成,将长方形垂直地分为三层 。 第1层是名字层,接口的名字必须是斜体字形,而且需要用<>修饰名字,并且该修饰和名字分列在2行。 第2层是常量层,列出接口中的常量及类型,格式是“常量名字:类型”。 第3层是方法层,也称操作层,列出接口中的方法及返回类型,格式是“方法名字(参数列表):类型”。
  • 14. 3.2 接口(Interface)_2 Java设计模式 Java设计模式10/19/201814<> Creator +MAX:int +factoryMethod():Product 名字层 常量层 方法层 +public的常量或方法的访问权限是名字前加
  • 15. 3.3 泛化关系(Generalization) Java设计模式 Java设计模式10/19/201815 对于面向对象语言,UML中所说的泛化关系就是指类的继承关系。如果一个类是另一个类的子类,那么UML通过使用一个实线连接两个类的UML图来表示二者之间的继承关系,实线的起始端是子类的UML图,终点端是父类的UML图,但终点端使用一个空心的三角形表示实线的结束 。
  • 16. 3.4 关联关系(Association) Java设计模式 Java设计模式10/19/201816 如果A类中成员变量是用B类(接口)来声明的变量,那么A和B的关系是关联关系,称A关联于B。那么UML通过使用一个实线连A和B的UML图,实线的起始端是A的UML图,终点端是B的UML图,但终点端使用一个指向B的UML图的方向箭头表示实线的结束 。
  • 17. 3.5 依赖关系(Dependency) Java设计模式 Java设计模式10/19/201817 如果A类中某个方法的参数用B类(接口)来声明的变量或某个方法返回的数据类型是B类型的,那么A和B的关系是依赖关系,称A依赖于B。那么UML通过使用一个虚线连A和B的UML图,虚线的起始端是A的UML图,终点端是B的UML图,但终点端使用一个指向B的UML图的方向箭头表示虚线的结束。
  • 18. 3.6 实现关系(Realization) Java设计模式 Java设计模式10/19/201818 如果一个类实现了一个接口,那么类和接口的关系是实现关系,称类实现接口。UML通过使用虚线连接类和它所实现的接口,虚线起始端是类,虚线的终点端是它实现的接口,但终点端使用一个空心的三角形表示虚线的结束 。
  • 19. 3.7 注释(Annotation) Java设计模式 Java设计模式10/19/201819 UML使用注释为类图提供附加的说明。UML在一个带卷角的长方形中显示给出的注释,并使用虚线将这个带卷角的长方形和所它所注释的实体连接起来 。
  • 20. 第四章 命令模式 Java设计模式 Java设计模式10/19/201820 命令模式(别名:动作,事务) 将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤消的操作。 Command Pattern(Another Name: Action, Transaction) Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.
  • 21. 一 、 概述 Java设计模式 Java设计模式10/19/201821 在许多设计中,经常涉及到一个对象请求另一个对象调用其方法到达某种目的。如果请求者不希望或无法直接和被请求者打交道,即不希望或无法含有被请求者的引用,那么就可以使用命令模式。
  • 22. 二、命令模式的结构与使用 Java设计模式 Java设计模式10/19/201822模式的结构中包括四种角色: 接收者(Receiver) 命令(Command)接口 具体命令(ConcreteCommand) 请求者(Invoker)
  • 23. Java设计模式 Java设计模式10/19/201823模式的UML类图
  • 24. Java设计模式 Java设计模式10/19/201824模式的结构的描述与使用 1.接收者(Receiver) : CompanyArmy.java public class CompanyArmy{ public void sneakAttack(){ System.out.println("我们知道如何偷袭敌人,保证完成任务"); } }
  • 25. Java设计模式 Java设计模式10/19/201825模式的结构的描述与使用 2.命令(Command)接口 : Command.java public interface Command { public abstract void execute(); }
  • 26. Java设计模式 Java设计模式10/19/201826模式的结构的描述与使用 3.具体命令(ConcreteCommand) ConcreteCommand.java public class ConcreteCommand implements Command{ CompanyArmy army; //含有接收者的引用 ConcreteCommand(CompanyArmy army){ this.army=army; } public void execute(){ //封装着指挥官的请求 army.sneakAttack(); //偷袭敌人 } }
  • 27. Java设计模式 Java设计模式10/19/201827模式的结构的描述与使用 4.请求者(Invoker) ArmySuperior.java public class ArmySuperior{ Command command; //用来存放具体命令的引用 public void setCommand(Command command){ this.command=command; } public void startExecuteCommand(){ //让具体命令执行execute()方法 command.execute(); } }
  • 28. Java设计模式 Java设计模式10/19/201828模式的结构的描述与使用 5.应用 Application.java public class Application{ public static void main(String args[]){ CompanyArmy 三连=new CompanyArmy(); Command command=new ConcreteCommand(三连); ArmySuperior 指挥官=new ArmySuperior(); 指挥官.setCommand(command); 指挥官.startExecuteCommand(); } }
  • 29. 三、命令模式的优点 Java设计模式 Java设计模式10/19/201829 在命令模式中,请求者(Invoker)不直接与接收者(Receiver)交互,即请求者(Invoker)不包含接收者(Receiver)的引用,因此彻底消除了彼此之间的耦合。 命令模式满足“开-闭原则”。如果增加新的具体命令和该命令的接受者,不必修改调用者的代码,调用者就可以使用新的命令对象;反之,如果增加新的调用者,不必修改现有的具体命令和接受者,新增加的调用者就可以使用已有的具体命令。 由于请求者的请求被封装到了具体命令中,那么就可以将具体命令保存到持久化的媒介中,在需要的时候,重新执行这个具体命令。因此,使用命令模式可以记录日志。 使用命令模式可以对请求者的“请求”进行排队。每个请求都各自对应一个具体命令,因此可以按一定顺序执行这些具体命令。
  • 30. 第五章 观察者模式 Java设计模式 Java设计模式10/19/201830 观察者模式(别名:依赖,发布-订阅) 定义对象间的一种一对多的依赖关系,当一个对象的状态发生变化时,所有依赖于它的对象都得到通知并被自动更新。 Observer Pattern(Another Name: Dependents, Publish-Subscribe) Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically..
  • 31. 一 、 概述 Java设计模式 Java设计模式10/19/201831 在许多设计中,经常涉及到多个对象都对一个特殊对象中的数据变化感兴趣,而且这多个对象都希望跟踪那个特殊对象中的数据变化。
  • 32. 二、 模式的结构与使用 Java设计模式 Java设计模式10/19/201832观察者模式的结构中包括四种角色: 主题(Subject) 观察者(Observer) 具体主题(ConcreteSubject) 具体观察者(ConcreteObserver)
  • 33. Java设计模式 Java设计模式10/19/201833模式的UML类图
  • 34. Java设计模式 Java设计模式10/19/201834模式的结构的描述与使用 1.主题 : Subject.java public interface Subject{ public void addObserver(Observer o); public void deleteObserver(Observer o); public void notifyObservers(); }
  • 35. Java设计模式 Java设计模式10/19/201835模式的结构的描述与使用 2.观察者 : Obsever.java public interface Observer{ public void hearTelephone(String heardMess); }
  • 36. Java设计模式 Java设计模式10/19/201836模式的结构的描述与使用 3.具体主题 SeekJobCenter.java_1 import java.util.ArrayList; public class SeekJobCenter implements Subject{ String mess; boolean changed; ArrayList personList; SeekJobCenter(){ personList=new ArrayList(); mess=""; changed=false; } public void addObserver(Observer o){ if(!(personList.contains(o))) personList.add(o); } public void deleteObserver(Observer o){ if(personList.contains(o)) personList.remove(o); }
  • 37. Java设计模式 Java设计模式10/19/201837模式的结构的描述与使用 3.具体主题 SeekJobCenter.java_2 public void notifyObservers(){ if(changed){for(int i=0;i
  • 38. Java设计模式 Java设计模式10/19/201838模式的结构的描述与使用 4.具体观察者_1 UniversityStudent.java import java.io.*; public class UniverStudent implements Observer{ Subject subject; File myFile; UniverStudent(Subject subject,String fileName){ this.subject=subject; subject.addObserver(this); //使当前实例成为subject所引用的具体主题的观察者 myFile=new File(fileName); } public void hearTelephone(String heardMess){ try{ RandomAccessFile out=new RandomAccessFile(myFile,"rw"); out.seek(out.length()); byte [] b=heardMess.getBytes(); out.write(b); //更新文件中的内容 System.out.print("我是一个大学生,"); System.out.println("我向文件"+myFile.getName()+"写入如下内容:"); System.out.println(heardMess); } catch(IOException exp){ System.out.println(exp.toString()); } } }
  • 39. Java设计模式 Java设计模式10/19/201839模式的结构的描述与使用 4.具体观察者_2 HaiGui.java import java.io.*; import java.util.regex.*; public class HaiGui implements Observer{ Subject subject; File myFile; HaiGui(Subject subject,String fileName){ this.subject=subject; subject.addObserver(this); //使当前实例成为subject所引用的具体主题的观察者 myFile=new File(fileName); } public void hearTelephone(String heardMess){ try{ boolean boo=heardMess.contains("java程序员")||heardMess.contains("软件"); if(boo){ RandomAccessFile out=new RandomAccessFile(myFile,"rw"); out.seek(out.length()); byte [] b=heardMess.getBytes(); out.write(b); System.out.print("我是一个海归,"); System.out.println("我向文件"+myFile.getName()+"写入如下内容:"); System.out.println(heardMess); } else{ System.out.println("我是海归,这次的信息中没有我需要的信息"); } } catch(IOException exp){ System.out.println(exp.toString()); } } }
  • 40. Java设计模式 Java设计模式10/19/201840模式的结构的描述与使用 5.应用 Application.java public class Application{ public static void main(String args[]){ SeekJobCenter center=new SeekJobCenter(); UniverStudent zhangLin=new UniverStudent(center,"A.txt"); HaiGui wangHao=new HaiGui(center,"B.txt"); center.giveNewMess("腾辉公司需要10个java程序员。"); center.notifyObservers(); center.giveNewMess("海景公司需要8个动画设计师。"); center.notifyObservers(); center.giveNewMess("仁海公司需要9个电工。"); center.notifyObservers(); center.giveNewMess("仁海公司需要9个电工。"); center.notifyObservers(); }
  • 41. 三、观察者模式的优点 Java设计模式 Java设计模式10/19/201841具体主题和具体观察者是松耦合关系。由于主题(Subject)接口仅仅依赖于观察者(Observer)接口,因此具体主题只是知道它的观察者是实现观察者(Observer)接口的某个类的实例,但不需要知道具体是哪个类。同样,由于观察者仅仅依赖于主题(Subject)接口,因此具体观察者只是知道它依赖的主题是实现主题(subject)接口的某个类的实例,但不需要知道具体是哪个类。 观察模式满足“开-闭原则”。主题(Subject)接口仅仅依赖于观察者(Observer)接口,这样,我们就可以让创建具体主题的类也仅仅是依赖于观察者(Observer)接口,因此如果增加新的实现观察者(Observer)接口的类,不必修改创建具体主题的类的代码。同样,创建具体观察者的类仅仅依赖于主题(Observer)接口,如果增加新的实现主题(Subject)接口的类,也不必修改创建具体观察者类的代码。
  • 42. 第六章 装饰模式 Java设计模式 Java设计模式10/19/201842 装饰模式(别名:包装器) 动态地给对象添加一些额外的职责。就功能来说装饰模式相比生成子类更为灵活。 Decorator Pattern(Another Name: Wrapper) Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.
  • 43. 一 、 概述 Java设计模式 Java设计模式10/19/201843 装饰模式是动态地扩展一个对象的功能,而不需要改变原始类代码的一种成熟模式。在装饰模式中,“具体组件”类和“具体装饰”类是该模式中的最重要的两个角色。
  • 44. 二、装饰模式模式的结构与使用 Java设计模式 Java设计模式10/19/201844装饰模式的结构中包括四种角色: 抽象组件(Component) 具体组件(ConcreteComponent) 装饰(Decorator) 具体装饰(ConcreteDecotator)
  • 45. Java设计模式 Java设计模式10/19/201845装饰模式的UML类图
  • 46. Java设计模式 Java设计模式10/19/201846装饰模式的结构的描述与使用 1.抽象组件 : Bird.java public abstract class Bird{ public abstract int fly(); }
  • 47. Java设计模式 Java设计模式10/19/201847装饰模式的结构的描述与使用 2.具体组件 : Sparrow.java public class Sparrow extends Bird{ public final int DISTANCE=100; public int fly(){ return DISTANCE; } }
  • 48. Java设计模式 Java设计模式10/19/201848装饰模式的结构的描述与使用 3.装饰 (Decorator): Decorator.java public abstract class Decorator extends Bird{ protected Bird bird; public Decorator(){ } public Decorator(Bird bird){ this.bird=bird; } }
  • 49. Java设计模式 Java设计模式10/19/201849装饰模式的结构的描述与使用 4.具体装饰(ConcreteDecotator): SparrowDecorator.java public class SparrowDecorator extends Decorator{ public final int DISTANCE=50; //eleFly方法能飞50米 SparrowDecorator(Bird bird){ super(bird); } public int fly(){ int distance=0; distance=bird.fly()+eleFly(); return distance; } private int eleFly(){ //装饰者新添加的方法 return DISTANCE; } }
  • 50. Java设计模式 Java设计模式10/19/201850装饰模式的结构的描述与使用 5.应用 Application.java public class Application{ public void needBird(Bird bird){ int flyDistance=bird.fly(); System.out.println("这只鸟能飞行"+flyDistance +"米"); } public static void main(String args[]){ Application client=new Application (); Bird sparrow=new Sparrow(); Bird sparrowDecorator1= new SparrowDecorator(sparrow); Bird sparrowDecorator2= new SparrowDecorator(sparrowDecorator1); client.needBird(sparrowDecorator1); client.needBird(sparrowDecorator2); } }
  • 51. 三、装饰模式的优点 Java设计模式 Java设计模式10/19/201851 被装饰者和装饰者是松耦合关系。由于装饰(Decorator)仅仅依赖于抽象组件(Component),因此具体装饰只知道它要装饰的对象是抽象组件的某一个子类的实例,但不需要知道是哪一个具体子类。 装饰模式满足“开-闭原则”。不必修改具体组件,就可以增加新的针对该具体组件的具体装饰。 可以使用多个具体装饰来装饰具体组件的实例。
  • 52. 第七章 策略模式 Java设计模式 Java设计模式10/19/201852 策略模式(别名:政策) 定义一系列算法,把它们一个个封装起来,并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。 Strategy Pattern(Another Name: Policy) Define a family of algorithms, encapsulate each one, and make them inter changeable. Strategy lets the algorithm vary independently from clients that use it.
  • 53. 一 、 概述 Java设计模式 Java设计模式10/19/201853 策略模式是处理算法的不同变体的一种成熟模式,策略模式通过接口或抽象类封装算法的标识,即在接口中定义一个抽象方法,实现该接口的类将实现接口中的抽象方法。 在策略模式中,封装算法标识的接口称作策略,实现该接口的类称作具体策略。
  • 54. 二、策略模式的结构与使用 Java设计模式 Java设计模式10/19/201854策略模式的结构中包括三种角色: 策略(Strategy) 具体策略(ConcreteStrategy) 上下文(Context)
  • 55. Java设计模式 Java设计模式10/19/201855策略模式的UML类图
  • 56. Java设计模式 Java设计模式10/19/201856策略模式的结构的描述与使用 1.策略(Strategy) : Computable.java public interface ComputableStrategy{ public abstract double computeScore(double [] a); }
  • 57. Java设计模式 Java设计模式10/19/201857策略模式的结构的描述与使用 2.具体策略(ConcreteStrategy): StrategyOne.java public class StrategyOne implements ComputableStrategy{ public double computeScore(double [] a){ double score=0,sum=0; for(int i=0;i
  • 58. Java设计模式 Java设计模式10/19/201858策略模式的结构的描述与使用 2.具体策略(ConcreteStrategy): StrategyTwo.java public class StrategyTwo implements ComputableStrategy{ public double computeScore(double [] a){ double score=0,multi=1; int n=a.length; for(int i=0;i
  • 59. Java设计模式 Java设计模式10/19/201859策略模式的结构的描述与使用 2.具体策略(ConcreteStrategy): StrategyThree.java import java.util.Arrays; public class StrategyThree implements ComputableStrategy{ public double computeScore(double [] a){ if(a.length<=2) return 0; double score=0,sum=0; Arrays.sort(a); for(int i=1;i
  • 60. Java设计模式 Java设计模式10/19/201860策略模式的结构的描述与使用 3.上下文: GymnasticsGame.java public class GymnasticsGame{ ComputableStrategy strategy; public void setStrategy(ComputableStrategy strategy){ this.strategy=strategy; } public double getPersonScore(double [] a){ if(strategy!=null) return strategy.computeScore(a); else return 0; } }
  • 61. Java设计模式 Java设计模式10/19/201861策略模式的结构的描述与使用 4.应用: Application.java_1 public class Application{ public static void main(String args[]){ GymnasticsGame game=new GymnasticsGame(); game.setStrategy(new StrategyOne()); Person zhang=new Person(); zhang.setName("张三"); double [] a={9.12,9.25,8.87,9.99,6.99,7.88}; Person li=new Person(); li.setName("李四"); double [] b={9.15,9.26,8.97,9.89,6.97,7.89}; zhang.setScore(game.getPersonScore(a)); li.setScore(game.getPersonScore(b)); System.out.println("使用算术平均值方案:"); System.out.printf("%s最后得分:%5.3f%n",zhang.getName(),zhang.getScore()); System.out.printf("%s最后得分:%5.3f%n",li.getName(),li.getScore()); game.setStrategy(new StrategyTwo()); zhang.setScore(game.getPersonScore(a)); li.setScore(game.getPersonScore(b)); System.out.println("使用几何平均值方案:"); System.out.printf("%s最后得分:%5.3f%n",zhang.getName(),zhang.getScore()); System.out.printf("%s最后得分:%5.3f%n",li.getName(),li.getScore());
  • 62. Java设计模式 Java设计模式10/19/201862策略模式的结构的描述与使用 4.应用: Application.java_2 game.setStrategy(new StrategyThree()); zhang.setScore(game.getPersonScore(a)); li.setScore(game.getPersonScore(b)); System.out.println("使用(去掉最高、最底)算术平均值方案:"); System.out.printf("%s最后得分:%5.3f%n",zhang.getName(),zhang.getScore()); System.out.printf("%s最后得分:%5.3f%n",li.getName(),li.getScore()); } } class Person{ String name; double score; public void setScore(double t){ score=t; } public void setName(String s){ name=s; } public double getScore(){ return score; } public String getName(){ return name; } }
  • 63. 三、策略模式的优点 Java设计模式 Java设计模式10/19/201863 上下文(Context)和具体策略(ConcreteStrategy)是松耦合关系。因此上下文只知道它要使用某一个实现Strategy接口类的实例,但不需要知道具体是哪一个类。 策略模式满足“开-闭原则”。当增加新的具体策略时,不需要修改上下文类的代码,上下文就可以引用新的具体策略的实例。
  • 64. 第八章 适配器模式 Java设计模式 Java设计模式10/19/201864 适配器模式(别名:包装器) 将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 Adapter Pattern(Another Name: Wrapper) Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.
  • 65. 一 、 概述 Java设计模式 Java设计模式10/19/201865 适配器模式是将一个类的接口(被适配者)转换成客户希望的另外一个接口(目标)的成熟模式,该模式中涉及有目标、被适配者和适配器。适配器模式的关键是建立一个适配器,这个适配器实现了目标接口并包含有被适配者的引用。
  • 66. 二、适配器模式的结构与使用 Java设计模式 Java设计模式10/19/201866模式的结构中包括三种角色: 目标(Target) 被适配者(Adaptee) 适配器(Adapter)
  • 67. Java设计模式 Java设计模式10/19/201867模式的UML类图
  • 68. Java设计模式 Java设计模式10/19/201868模式的结构的描述与使用 1.目标(Target) : ThreeElectricOutlet.java public interface ThreeElectricOutlet{ public abstract void connectElectricCurrent(); }
  • 69. Java设计模式 Java设计模式10/19/201869模式的结构的描述与使用 2.被适配者(Adaptee): TwoElectricOutlet.java public interface TwoElectricOutlet{ public abstract void connectElectricCurrent(); }
  • 70. Java设计模式 Java设计模式10/19/201870模式的结构的描述与使用 3.适配器(Adapter) TreeElectricAdapter.java public class TreeElectricAdapter implements ThreeElectricOutlet{ TwoElectricOutlet outlet; TreeElectricAdapter(TwoElectricOutlet outlet){ this.outlet=outlet; } public void connectElectricCurrent(){ outlet.connectElectricCurrent(); } }
  • 71. Java设计模式 Java设计模式10/19/201871模式的结构的描述与使用 4.应用 Application.java_1 public class Application{ public static void main(String args[]){ ThreeElectricOutlet outlet; Wash wash=new Wash(); outlet=wash; System.out.println("使用三相插座接通电流:"); outlet.connectElectricCurrent(); TV tv=new TV(); TreeElectricAdapter adapter=new TreeElectricAdapter(tv); outlet=adapter; System.out.println("使用三相插座接通电流:"); outlet.connectElectricCurrent(); } }
  • 72. Java设计模式 Java设计模式10/19/201872模式的结构的描述与使用 4.应用 Application.java_2 class Wash implements ThreeElectricOutlet{ String name; Wash(){ name="黄河洗衣机"; } Wash(String s){ name=s; } public void connectElectricCurrent(){ turnOn(); } public void turnOn(){ System.out.println(name+"开始洗衣物。"); } }
  • 73. Java设计模式 Java设计模式10/19/201873模式的结构的描述与使用 4.应用 Application.java_3 class TV implements TwoElectricOutlet{ String name; TV(){ name="长江电视机"; } TV(String s){ name=s; } public void connectElectricCurrent(){ turnOn(); } public void turnOn(){ System.out.println(name+"开始播放节目。"); } }
  • 74. 三、适配器模式的优点 Java设计模式 Java设计模式10/19/201874目标(Target)和被适配者(Adaptee)是完全解耦的关系。 适配器模式满足“开-闭原则”。当添加一个实现Adaptee接口的新类时,不必修改Adapter,Adapter就能对这个新类的实例进行适配。
  • 75. 第九章 责任链模式 Java设计模式 Java设计模式10/19/201875 责任链模式 使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。 Chain of Responsibility Pattern Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.
  • 76. 一 、 概述 Java设计模式 Java设计模式10/19/201876 责任链模式是使用多个对象处理用户请求的成熟模式,责任链模式的关键是将用户的请求分派给许多对象,这些对象被组织成一个责任链,即每个对象含有后继对象的引用,并要求责任链上的每个对象,如果能处理用户的请求,就做出处理,不再将用户的请求传递给责任链上的下一个对象;如果不能处理用户的请求,就必须将用户的请求传递给责任链上的下一个对象。
  • 77. 二、责任链模式的结构与使用 Java设计模式 Java设计模式10/19/201877模式的结构中包括两种角色: 处理者(Handler) 具体处理者(ConcreteHandler)
  • 78. Java设计模式 Java设计模式10/19/201878模式的UML类图
  • 79. Java设计模式 Java设计模式10/19/201879模式的结构的描述与使用 1.处理者(Handler): Handler.java public interface Handler{ public abstract void handleRequest(String number); public abstract void setNextHandler(Handler handler); }
  • 80. Java设计模式 Java设计模式10/19/201880模式的结构的描述与使用 2.具体处理者(ConcreteHandler)_1: Beijing.java import java.util.*; public class Beijing implements Handler{ private Handler handler; private ArrayList numberList; Beijing(){ numberList=new ArrayList(); numberList.add("11129812340930034"); numberList.add("10120810340930632"); numberList.add("22029812340930034"); numberList.add("32620810340930632"); } public void handleRequest(String number){ if(numberList.contains(number)) System.out.println("该人在北京居住"); else{ System.out.println("该人不在北京居住"); if(handler!=null) handler.handleRequest(number); } } public void setNextHandler(Handler handler){ this.handler=handler; } }
  • 81. Java设计模式 Java设计模式10/19/201881模式的结构的描述与使用 2.具体处理者(ConcreteHandler)_2: Shanghai.java import java.util.*; public class Shanghai implements Handler{ private Handler handler; private ArrayList numberList; Shanghai(){ numberList=new ArrayList(); numberList.add("34529812340930034"); numberList.add("98720810340430632"); numberList.add("36529812340930034"); numberList.add("77720810340930632"); } public void handleRequest(String number){ if(numberList.contains(number)) System.out.println("该人在上海居住"); else{ System.out.println("该人不在上海居住"); if(handler!=null) handler.handleRequest(number); } } public void setNextHandler(Handler handler){ this.handler=handler; } }
  • 82. Java设计模式 Java设计模式10/19/201882模式的结构的描述与使用 2.具体处理者(ConcreteHandler)_3: Tianjin.java import java.util.*; public class Tianjin implements Handler{ private Handler handler; private ArrayList numberList; Tianjin(){ numberList=new ArrayList(); numberList.add("10029812340930034"); numberList.add("20020810340430632"); numberList.add("30029812340930034"); numberList.add("50020810340930632"); } public void handleRequest(String number){ if(numberList.contains(number)) System.out.println("该人在天津居住"); else{ System.out.println("该人不在天津居住"); if(handler!=null) handler.handleRequest(number); } } public void setNextHandler(Handler handler){ this.handler=handler; } }
  • 83. Java设计模式 Java设计模式10/19/201883模式的结构的描述与使用 3.应用 Application.java public class Application{ private Handler beijing,shanghai,tianjin; public void createChain(){ beijing=new Beijing(); shanghai=new Shanghai(); tianjin=new Tianjin(); beijing.setNextHandler(shanghai); shanghai.setNextHandler(tianjin); } public void reponseClient(String number){ beijing.handleRequest(number); } public static void main(String args[]){ Application application=new Application(); application.createChain(); application.reponseClient("77720810340930632");; } }
  • 84. 三、责任链模式的优点 Java设计模式 Java设计模式10/19/201884责任链中的对象只和自己的后继是低耦合关系,和其他对象毫无关联,这使得编写处理者对象以及创建责任链变得非常容易。 当在处理者中分配职责时,责任链给应用程序更多的灵活性。 应用程序可以动态地增加、删除处理者或重新指派处理者的职责。 应用程序可以动态地改变处理者之间的先后顺序。 使用责任链的用户不必知道处理者的信息,用户不会知道到底是哪个对象处理了它的请求。
  • 85. 第十章 外观模式 Java设计模式 Java设计模式10/19/201885 外观模式 为系统中的一组接口提供一个一致的界面,Façade模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。 Chain of Responsibility Pattern Provide a unified interface to a set of interfaces in a subsystem.Facade defines a higher-level interface that makes the subsystem easier to use.
  • 86. 一 、 概述 Java设计模式 Java设计模式10/19/201886 外观模式是简化用户和子系统进行交互的成熟模式,外观模式的关键是为子系统提供一个称作外观的类,该外观类的实例负责和子系统中类的实例打交道。当用户想要和子系统中的若干个类的实例打交道时,可以代替地和子系统的外观类的实例打交道。
  • 87. 二、外观模式的结构与使用 Java设计模式 Java设计模式10/19/201887模式的结构中包括两种角色: 子系统(Subsystem) 外观(Facade)
  • 88. Java设计模式 Java设计模式10/19/201888模式的UML类图
  • 89. Java设计模式 Java设计模式10/19/201889模式的结构的描述与使用 1.子系统(Subsystem)_1 : CheckWord.java public class CheckWord{ public final int basicAmount=85; String advertisement; int amount; public CheckWord(String advertisement){ this.advertisement=advertisement; } public void setChargeAmount(){ amount=advertisement.length()+basicAmount; //计算出计费字符数目 } public int getAmount(){ return amount; } }
  • 90. Java设计模式 Java设计模式10/19/201890模式的结构的描述与使用 1.子系统(Subsystem)_2 : Charge.java public class Charge{ public final int basicCharge=12; CheckWord checkWord; Charge(CheckWord checkWord){ this.checkWord=checkWord; } public void giveCharge(){ int charge=checkWord.getAmount()*basicCharge; System.out.println("广告费用:"+charge+"元"); } }
  • 91. Java设计模式 Java设计模式10/19/201891模式的结构的描述与使用 1.子系统(Subsystem)_3 :TypeSeting.java public class TypeSeting{ String advertisement; public TypeSeting(String advertisement){ this.advertisement=advertisement; } public void typeSeting(){ System.out.println("广告排版格式:"); System.out.println("********"); System.out.println(advertisement); System.out.println("********"); } }
  • 92. Java设计模式 Java设计模式10/19/201892模式的结构的描述与使用 2.外观(Facade): ClientServerFacade.java public class ClientServerFacade{ private CheckWord checkWord; private Charge charge; private TypeSeting typeSeting; String advertisement; public ClientServerFacade(String advertisement){ this.advertisement=advertisement; checkWord=new CheckWord(advertisement); charge=new Charge(checkWord); typeSeting=new TypeSeting(advertisement); } public void doAdvertisement(){ checkWord.setChargeAmount(); charge.giveCharge(); typeSeting.typeSeting(); } }
  • 93. Java设计模式 Java设计模式10/19/201893模式的结构的描述与使用 3.应用 Application.java public class Application{ public static void main(String args[]){ ClientServerFacade clientFacade; String clientAdvertisement="鹿花牌洗衣机,价格2356元,联系电话:1234567"; clientFacade=new ClientServerFacade(clientAdvertisement); clientFacade.doAdvertisement(); } }
  • 94. 三、外观模式的优点 Java设计模式 Java设计模式10/19/201894使客户和子系统中的类无耦合,并且使得子系统使用起来更加方便。 外观只是提供了一个更加简洁的界面,并不影响用户直接使用子系统中的类。 子系统中任何类对其方法的内容进行修改,不影响外观的代码。
  • 95. 第十一章 迭代器模式 Java设计模式 Java设计模式10/19/201895 迭代器模式(别名:游标) 提供一种方法顺序访问一个聚合对象中的各个元素,而又不需要暴露该对象的内部表示。 Iterator Pattern (Another Name: Cursor) Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
  • 96. 一 、 概述 Java设计模式 Java设计模式10/19/201896 迭代器模式是遍历集合的成熟模式,迭代器模式的关键是将遍历集合的任务交给一个称作迭代器的对象。
  • 97. 二、迭代器模式的结构与使用 Java设计模式 Java设计模式10/19/201897模式的结构中包括四种角色: 集合(Aggregate): 具体集合(ConcreteAggregate) 迭代器(Iterator) 具体迭代器(ConcreteIterator)
  • 98. Java设计模式 Java设计模式10/19/201898模式的UML类图
  • 99. Java设计模式 Java设计模式10/19/201899模式的结构的描述与使用 1.集合(Aggregate) : 在这里我们使用java.util包中的Collection接口作为模式中的集合角色。Java所有的集合都实现了该接口。
  • 100. Java设计模式 Java设计模式10/19/2018100模式的结构的描述与使用 2.具体集合(ConcreteAggregate) : 在这里我们使用java.util包中的HashSet类的实例作为模式中的具体集合角色。
  • 101. Java设计模式 Java设计模式10/19/2018101模式的结构的描述与使用 3.迭代器(Iterator) : 在本问题中,我们使用的迭代器是java.util包中的Itertator接口 。
  • 102. Java设计模式 Java设计模式10/19/2018102模式的结构的描述与使用 4.具体迭代器(ConcreteIterator) HashSet创建的集合可以使用iterator ()方法返回一个实现Iterator接口类的实例,即一个具体迭代器。
  • 103. Java设计模式 Java设计模式10/19/2018103模式的结构的描述与使用 5.应用 Application.java_1 import java.util.*; public class Application{ public static void main(String args[]){ int n=20; int sum=0; Collection set=new HashSet(); for(int i=1;i<=n;i++){ if(i==n/2||i==n/5||i==n/6) set.add(new RenMinMony(100,false)); else set.add(new RenMinMony(100,true)); } Iterator iterator=set.iterator(); int jia=1,zhen=1; System.out.println("保险箱共有"+set.size()+"张人民币"); int k=0; while(iterator.hasNext()){ RenMinMony money=iterator.next(); k++; if(money.getIsTrue()==false){ System.out.println("第"+k+"张是假币,被销毁"); iterator.remove(); k++; } } System.out.println("保险箱现有真人民币"+set.size()+"张,总价值是:"); iterator=set.iterator(); while(iterator.hasNext()){ RenMinMony money=iterator.next(); sum=sum+money.getValue(); } System.out.println(sum+"元"); } }
  • 104. Java设计模式 Java设计模式10/19/2018104模式的结构的描述与使用 5.应用 Application.java_2 class RenMinMony{ int value; private boolean isTrue; RenMinMony(int value,boolean b){ this.value=value; isTrue=b; } public boolean getIsTrue(){ return isTrue; } public int getValue(){ return value; } }
  • 105. 三、迭代器模式的优点 Java设计模式 Java设计模式10/19/2018105用户使用迭代器访问集合中的对象,而不需要知道这些对象在集合中是如何表示及存储的。 用户可以同时使用多个迭代器遍历一个集合。
  • 106. 第十二章 中介者模式 Java设计模式 Java设计模式10/19/2018106中介者模式 用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。 Mediator Pattern Define an object that encapsulates how a set of objects interact.Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.
  • 107. 一 、 概述 Java设计模式 Java设计模式10/19/2018107 中介者模式是封装一系列的对象交互的成熟模式,其关键是将对象之间的交互封装在称作中介者的对象中,中介者使各对象不需要显示地相互引用,这些对象只包含中介者的引用。当系统中某个对象需要和系统中另外一个对象交互时,只需将自己的请求通知中介者即可。
  • 108. 二、中介者模式的结构与使用 Java设计模式 Java设计模式10/19/2018108模式的结构中包括四种角色: 中介者(Mediator) 具体中介者(ConcreteMediator) 同事(Colleague) 具体同事(ConcreteColleague)
  • 109. Java设计模式 Java设计模式10/19/2018109模式的UML类图
  • 110. Java设计模式 Java设计模式10/19/2018110模式的结构的描述与使用 1.同事(Colleague) : Colleague.java public interface Colleague{ public void giveMess(String [] mess); public void receiverMess(String mess); public void setName(String name); public String getName(); } 注:本问题中,只需要一个具体中介者,我们并不需要一个中介者(Mediator)接口 。
  • 111. Java设计模式 Java设计模式10/19/2018111模式的结构的描述与使用 2.具体中介者(Mediator) : ConcreteMediator.java public class ConcreteMediator{ ColleagueA colleagueA; ColleagueB colleagueB; ColleagueC colleagueC; public void registerColleagueA(ColleagueA colleagueA){ this.colleagueA=colleagueA; } public void registerColleagueB(ColleagueB colleagueB){ this.colleagueB=colleagueB; } public void registerColleagueC(ColleagueC colleagueC){ this.colleagueC=colleagueC; } public void deliverMess(Colleague colleague,String [] mess){ if(colleague==colleagueA){ if(mess.length>=2){ colleagueB.receiverMess(colleague.getName()+mess[0]); colleagueC.receiverMess(colleague.getName()+mess[1]); } } else if(colleague==colleagueB){ if(mess.length>=2){ colleagueA.receiverMess(colleague.getName()+mess[0]); colleagueC.receiverMess(colleague.getName()+mess[1]); } } else if(colleague==colleagueC){ if(mess.length>=2){ colleagueA.receiverMess(colleague.getName()+mess[0]); colleagueB.receiverMess(colleague.getName()+mess[1]); } } } }
  • 112. Java设计模式 Java设计模式10/19/2018112模式的结构的描述与使用 3.具体同事(ConcreteColleague)_1: ColleagueA.java public class ColleagueA implements Colleague{ ConcreteMediator mediator; String name; ColleagueA(ConcreteMediator mediator){ this.mediator=mediator; mediator.registerColleagueA(this); } public void setName(String name){ this.name=name; } public String getName(){ return name; } public void giveMess(String [] mess){ mediator.deliverMess(this,mess); } public void receiverMess(String mess){ System.out.println(name+"收到的信息:"); System.out.println("\t"+mess); } }
  • 113. Java设计模式 Java设计模式10/19/2018113模式的结构的描述与使用 3.具体同事(ConcreteColleague)_2: ColleagueB.java public class ColleagueB implements Colleague{ ConcreteMediator mediator; String name; ColleagueB(ConcreteMediator mediator){ this.mediator=mediator; mediator.registerColleagueB(this); } public void setName(String name){ this.name=name; } public String getName(){ return name; } public void giveMess(String [] mess){ mediator.deliverMess(this,mess); } public void receiverMess(String mess){ System.out.println(name+"收到的信息:"); System.out.println("\t"+mess); } }
  • 114. Java设计模式 Java设计模式10/19/2018114模式的结构的描述与使用 3.具体同事(ConcreteColleague)_3: ColleagueC.java public class ColleagueC implements Colleague{ ConcreteMediator mediator; String name; ColleagueC(ConcreteMediator mediator){ this.mediator=mediator; mediator.registerColleagueC(this); } public void setName(String name){ this.name=name; } public String getName(){ return name; } public void giveMess(String [] mess){ mediator.deliverMess(this,mess); } public void receiverMess(String mess){ System.out.println(name+"收到的信息:"); System.out.println("\t"+mess); } }
  • 115. Java设计模式 Java设计模式10/19/2018115模式的结构的描述与使用 4.应用 Application.java public class Application{ public static void main(String args[]){ ConcreteMediator mediator=new ConcreteMediator(); ColleagueA colleagueA=new ColleagueA(mediator); ColleagueB colleagueB=new ColleagueB(mediator); ColleagueC colleagueC=new ColleagueC(mediator); colleagueA.setName("A国"); colleagueB.setName("B国"); colleagueC.setName("C国"); String [] messA={"要求归还曾抢夺的100斤土豆","要求归还曾抢夺的20头牛"}; colleagueA.giveMess(messA); String [] messB={"要求归还曾抢夺的10只公鸡","要求归还曾抢夺的15匹马"}; colleagueB.giveMess(messB); String [] messC={"要求归还曾抢夺的300斤小麦","要求归还曾抢夺的50头驴"}; colleagueC.giveMess(messC); } }
  • 116. 三、中介者模式的优点 Java设计模式 Java设计模式10/19/2018116可以避免许多的对象为了之间的通信而相互显示引用,不仅系统难于维护,而且也使其他系统难以复用这些对象。 可以通过中介者将原本分布于多个对象之间的交互行为集中在一起。当这些对象之间需要改变之间的通信行为时,只需使用一个具体中介者即可,不必修改各个具体同事的代码,即这些同事可被重用。 具体中介者使得各个具体同事完全解耦,修改任何一个具体同事的代码不会影响到其他同事。 具体中介者集中了同事之间是如何交互的细节,使得系统比较清楚地知道整个系统中的同事是如何交互的。 当一些对象想互相通信,但又无法相互包含对方的引用,那么使用中介者模式就可以使得这些对象互相通信。
  • 117. 第十三章 工厂方法模式 Java设计模式 Java设计模式10/19/2018117 工厂方法模式(别名:虚拟构造) 定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。 Mediator Pattern(Another Name: Virtual Constructor) Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
  • 118. 一 、 概述 Java设计模式 Java设计模式10/19/2018118 当系统准备为用户提供某个类的子类的实例,又不想让用户代码和该子类形成耦合时,就可以使用工厂方法模式来设计系统。工厂方法模式的关键是在一个接口或抽象类中定义一个抽象方法,该方法返回某个类的子类的实例,该抽象类或接口让其子类或实现该接口的类通过重写这个抽象方法返回某个子类的实例。
  • 119. 二、工厂方法模式的结构与使用 Java设计模式 Java设计模式10/19/2018119模式的结构中包括四种角色: 抽象产品(Product) 具体产品(ConcreteProduct) 构造者(Creator) 具体构造者(ConcreteCreator)
  • 120. Java设计模式 Java设计模式10/19/2018120模式的UML类图
  • 121. Java设计模式 Java设计模式10/19/2018121模式的结构的描述与使用 1.抽象产品(Product) : PenCore.java public abstract class PenCore{ String color; public abstract void writeWord(String s); }
  • 122. Java设计模式 Java设计模式10/19/2018122模式的结构的描述与使用 2.具体产品(ConcreteProduct)_1 : RedPenCore.java public class RedPenCore extends PenCore{ RedPenCore(){ color="红色"; } public void writeWord(String s){ System.out.println("写出"+color+"的字:"+s); } }
  • 123. Java设计模式 Java设计模式10/19/2018123模式的结构的描述与使用 2.具体产品(ConcreteProduct)_2 : BluePenCore.java public class BluePenCore extends PenCore{ BluePenCore(){ color="蓝色"; } public void writeWord(String s){ System.out.println("写出"+color+"的字:"+s); } }
  • 124. Java设计模式 Java设计模式10/19/2018124模式的结构的描述与使用 2.具体产品(ConcreteProduct)_3: BlackPenCore.java public class BlackPenCore extends PenCore{ BlackPenCore(){ color="黑色"; } public void writeWord(String s){ System.out.println("写出"+color+"的字:"+s); } }
  • 125. Java设计模式 Java设计模式10/19/2018125模式的结构的描述与使用 3.构造者(Creator):BallPen.java public abstract class BallPen{ BallPen(){ System.out.println("生产了一只装有"+getPenCore().color+"笔芯的圆珠笔"); } public abstract PenCore getPenCore(); //工厂方法 }
  • 126. Java设计模式 Java设计模式10/19/2018126模式的结构的描述与使用 4.具体构造者(ConcreteCreator): RedBallPen.java public class RedBallPen extends BallPen{ public PenCore getPenCore(){ return new RedPenCore(); } } BlueBallPen.java public class BlueBallPen extends BallPen{ public PenCore getPenCore(){ return new BluePenCore(); } } BlackBallPen.java public class BlackBallPen extends BallPen{ public PenCore getPenCore(){ return new BlackPenCore(); } }
  • 127. Java设计模式 Java设计模式10/19/2018127模式的结构的描述与使用 5.应用 Application.java public class Application{ public static void main(String args[]){ PenCore penCore; BallPen ballPen=new BlueBallPen(); penCore=ballPen.getPenCore(); penCore.writeWord("你好,很高兴认识你"); ballPen=new RedBallPen(); penCore=ballPen.getPenCore(); penCore.writeWord("How are you"); ballPen=new BlackBallPen(); penCore=ballPen.getPenCore(); penCore.writeWord("nice to meet you"); } }
  • 128. 三、工厂方法模式的优点 Java设计模式 Java设计模式10/19/2018128使用工厂方法可以让用户的代码和某个特定类的子类的代码解耦。 工厂方法使用户不必知道它所使用的对象是怎样被创建的,只需知道该对象有哪些方法即可。
  • 129. 第十四章 抽象工厂模式 Java设计模式 Java设计模式10/19/2018129 抽象工厂模式(别名:配套) 提供一个创建一系列或相互依赖对象的接口,而无需指定它们具体的类。 Abstract Factory Pattern(Another Name:Kit) Provide an interface for creating families of related or dependent objects without specifying their concrete classes.
  • 130. 一 、 概述 Java设计模式 Java设计模式10/19/2018130 当系统准备为用户提供一系列相关的对象,又不想让用户代码和创建这些对象的类形成耦合时,就可以使用抽象工厂方法模式来设计系统。抽象工厂模式的关键是在一个抽象类或接口中定义若干个抽象方法,这些抽象方法分别返回某个类的实例,该抽象类或接口让其子类或实现该接口的类重写这些抽象方法为用户提供一系列相关的对象。
  • 131. 二、抽象工厂模式的结构与使用 Java设计模式 Java设计模式10/19/2018131模式的结构中包括四种角色: 抽象产品(Prodcut) 具体产品(ConcreteProduct) 抽象工厂(AbstractFactory) 具体构造者(ConcreteFactory)
  • 132. Java设计模式 Java设计模式10/19/2018132模式的UML类图
  • 133. Java设计模式 Java设计模式10/19/2018133模式的结构的描述与使用 1.抽象产品(Product) : UpperClothes.java public abstract class UpperClothes{ public abstract int getChestSize(); public abstract int getHeight(); public abstract String getName(); } Trousers.java public abstract class Trousers{ public abstract int getWaistSize(); public abstract int getHeight(); public abstract String getName(); }
  • 134. Java设计模式 Java设计模式10/19/2018134模式的结构的描述与使用 2.具体产品(ConcreteProduct)_1: WesternUpperClothes.java public class WesternUpperClothes extends UpperClothes{ private int chestSize; private int height; private String name; WesternUpperClothes(String name,int chestSize,int height){ this.name=name; this.chestSize=chestSize; this.height=height; } public int getChestSize(){ return chestSize; } public int getHeight(){ return height; } public String getName(){ return name; } }
  • 135. Java设计模式 Java设计模式10/19/2018135模式的结构的描述与使用 2.具体产品(ConcreteProduct)_2: CowboyUpperClothes.java public class CowboyUpperClothes extends UpperClothes{ private int chestSize; private int height; private String name; CowboyUpperClothes(String name,int chestSize,int height){ this.name=name; this.chestSize=chestSize; this.height=height; } public int getChestSize(){ return chestSize; } public int getHeight(){ return height; } public String getName(){ return name; } }
  • 136. Java设计模式 Java设计模式10/19/2018136模式的结构的描述与使用 2.具体产品(ConcreteProduct)_3: WesternTrousers.java public class WesternTrousers extends Trousers{ private int waistSize; private int height; private String name; WesternTrousers(String name,int waistSize,int height){ this.name=name; this.waistSize=waistSize; this.height=height; } public int getWaistSize(){ return waistSize; } public int getHeight(){ return height; } public String getName(){ return name; } }
  • 137. Java设计模式 Java设计模式10/19/2018137模式的结构的描述与使用 2.具体产品(ConcreteProduct)_4: CowboyTrousers.java public class CowboyTrousers extends Trousers{ private int waistSize; private int height; private String name; CowboyTrousers(String name,int waistSize,int height){ this.name=name; this.waistSize=waistSize; this.height=height; } public int getWaistSize(){ return waistSize; } public int getHeight(){ return height; } public String getName(){ return name; } }
  • 138. Java设计模式 Java设计模式10/19/2018138模式的结构的描述与使用 3.抽象工厂(AbstractFactory):ClothesFactory.java public abstract class ClothesFactory{ public abstract UpperClothes createUpperClothes(int chestSize,int height); public abstract Trousers createTrousers(int waistSize,int height); }
  • 139. Java设计模式 Java设计模式10/19/2018139模式的结构的描述与使用 4.具体工厂(ConcreteFactory): BeijingClothesFactory.java public class BeijingClothesFactory extends ClothesFactory { public UpperClothes createUpperClothes(int chestSize,int height){ return new WesternUpperClothes("北京牌西服上衣",chestSize,height); } public Trousers createTrousers(int waistSize,int height){ return new WesternTrousers("北京牌西服裤子",waistSize,height); } } ShanghaiClothesFactory.java public class ShanghaiClothesFactory extends ClothesFactory { public UpperClothes createUpperClothes(int chestSize,int height){ return new WesternUpperClothes("上海牌牛仔上衣",chestSize,height); } public Trousers createTrousers(int waistSize,int height){ return new WesternTrousers("上海牌牛仔裤",waistSize,height); } }
  • 140. Java设计模式 Java设计模式10/19/2018140模式的结构的描述与使用 5.应用_1: Shop.java public class Shop{ UpperClothes cloth; Trousers trouser; public void giveSuit(ClothesFactory factory,int chestSize,int waistSize,int height){ cloth=factory.createUpperClothes(chestSize,height); trouser=factory.createTrousers(waistSize,height); showMess(); } private void showMess(){ System.out.println("<套装信息>"); System.out.println(cloth.getName()+":"); System.out.print("胸围:"+cloth.getChestSize()); System.out.println("身高:"+cloth.getHeight()); System.out.println(trouser.getName()+":"); System.out.print("腰围:"+trouser.getWaistSize()); System.out.println("身高:"+trouser.getHeight()); } }
  • 141. Java设计模式 Java设计模式10/19/2018141模式的结构的描述与使用 5.应用_2: Application.java public class Application{ public static void main(String args[]){ Shop shop=new Shop(); ClothesFactory factory=new BeijingClothesFactory(); shop.giveSuit(factory,110,82,170); factory=new ShanghaiClothesFactory(); shop.giveSuit(factory,120,88,180); } }
  • 142. 三、抽象工厂模式的优点 Java设计模式 Java设计模式10/19/2018142抽象工厂模式可以为用户创建一系列相关的对象,使得用户和创建这些对象的类脱耦。 使用抽象工厂模式可以方便的为用户配置一系列对象。用户使用不同的具体工厂就能得到一组相关的对象,同时也能避免用户混用不同系列中的对象。 在抽象工厂模式中,可以随时增加“具体工厂”为用户提供一组相关的对象。
  • 143. 第十五章 生成器模式 Java设计模式 Java设计模式10/19/2018143 生成器模式 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 Builder Pattern Separate the construction of a complex object from its representation so that the same construction process can create different representations.
  • 144. 一 、 概述 Java设计模式 Java设计模式10/19/2018144 当系统准备为用户提供一个内部结构复杂的对象时,就可以使用生成器模式,使用该模式可以逐步地构造对象,使得对象的创建更具弹性。生成器模式的关键是将一个包含有多个组件对象的创建分成若干个步骤,并将这些步骤封装在一个称作生成器的接口中。
  • 145. 二、生成器模式的结构与使用 Java设计模式 Java设计模式10/19/2018145模式的结构中包括四种角色: 产品(Product) 抽象生成器(Builder) 具体生成器(ConcreteBuilder) 指挥者(Director)
  • 146. Java设计模式 Java设计模式10/19/2018146模式的UML类图
  • 147. Java设计模式 Java设计模式10/19/2018147模式的结构的描述与使用 1.产品(Product): PanelProduct.java import javax.swing.*; public class PanelProduct extends JPanel{ JButton button; JLabel label; JTextField textField; }
  • 148. Java设计模式 Java设计模式10/19/2018148模式的结构的描述与使用 2.抽象生成器(Builder): Builer.java import.javax.swing.*; public interface Builder{ public abstract void buildButton(); public abstract void buildLabel(); public abstract void buildTextField(); public abstract JPanel getPanel(); }
  • 149. Java设计模式 Java设计模式10/19/2018149模式的结构的描述与使用 3.具体生成器(ConcreteBuilder)_1:ConcreteBuilderOne.java import javax.swing.*; public class ConcreteBuilderOne implements Builder{ private PanelProduct panel; ConcreteBuilderOne(){ panel=new PanelProduct(); } public void buildButton(){ panel.button=new JButton("按钮"); } public void buildLabel(){ panel.label=new JLabel("标签"); } public void buildTextField(){ panel.textField=new JTextField("文本框"); } public JPanel getPanel(){ panel.add(panel.button); panel.add(panel.label); panel.add(panel.textField); return panel; } }
  • 150. Java设计模式 Java设计模式10/19/2018150模式的结构的描述与使用 3.具体生成器(ConcreteBuilder)_2:ConcreteBuilderTwo.java import javax.swing.*; public class ConcreteBuilderTwo implements Builder{ private PanelProduct panel; ConcreteBuilderTwo(){ panel=new PanelProduct(); } public void buildButton(){ panel.button=new JButton("button"); } public void buildLabel(){ panel.label=new JLabel("label"); } public void buildTextField(){ panel.textField=new JTextField("textField"); } public JPanel getPanel(){ panel.add(panel.textField); panel.add(panel.label); panel.add(panel.button); return panel; } }
  • 151. Java设计模式 Java设计模式10/19/2018151模式的结构的描述与使用 4.指挥者(Director):Director.java import javax.swing.*; public class Director{ private Builder builder; Director(Builder builder){ this.builder=builder; } public JPanel constructProduct(){ builder.buildButton(); builder.buildLabel(); builder.buildTextField(); JPanel product=builder.getPanel(); return product; } }
  • 152. Java设计模式 Java设计模式10/19/2018152模式的结构的描述与使用 5.应用 Application.java import javax.swing.*; public class Application{ public static void main(String args[]){ Builder builder=new ConcreteBuilderOne(); Director director=new Director(builder); JPanel panel=director.constructProduct(); JFrame frameOne=new JFrame(); frameOne.add(panel); frameOne.setBounds(12,12,200,120); frameOne.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); frameOne.setVisible(true); builder=new ConcreteBuilderTwo(); director=new Director(builder); panel=director.constructProduct(); JFrame frameTwo=new JFrame(); frameTwo.add(panel); frameTwo.setBounds(212,12,200,120); frameTwo.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); frameTwo.setVisible(true); } }
  • 153. 三、生成器模式的优点 Java设计模式 Java设计模式10/19/2018153生成器模式将对象的构造过程封装在具体生成器中,用户使用不同的具体生成器就可以得到该对象的不同表示。 生成器模式将对象的构造过程从创建该对象的类中分离出来,使得用户无须了解该对象的具体组件。 可以更加精细有效地控制对象的构造过程。生成器将对象的构造过程分解成若干步骤,这就使得程序可以更加精细,有效地控制整个对象的构造。 生成器模式将对象的构造过程与创建该对象类解耦,使得对象的创建更加灵活有弹性。 当增加新的具体生成器时,不必修改指挥者的代码,即该模式满足开-闭原则。
  • 154. 第十六章 原型模式 Java设计模式 Java设计模式10/19/2018154 原型模式 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。 Prototype Pattern Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.
  • 155. 一 、 概述 Java设计模式 Java设计模式10/19/2018155 原型模式是从一个对象出发得到一个和自己有相同状态的新对象的成熟模式,该模式的关键是将一个对象定义为原型,并为其提供复制自己的方法。
  • 156. 二、原型模式的结构与使用 Java设计模式 Java设计模式10/19/2018156模式的结构中包括两种角色: 抽象原型(Prototype) 具体原型(Concrete Prototype)
  • 157. Java设计模式 Java设计模式10/19/2018157模式的UML类图
  • 158. Java设计模式 Java设计模式10/19/2018158模式的结构的描述与使用 1.抽象原型(Prototype): Prototype.java public interface Prototype { public Object cloneMe() throws CloneNotSupportedException,; }
  • 159. Java设计模式 Java设计模式10/19/2018159模式的结构的描述与使用 2.具体原型(Concrete Prototype)_1: Cubic.java public class Cubic implements Prototype, Cloneable{ double length,width,height; Cubic(double a,double b,double c){ length=a; width=b; height=c; } public Object cloneMe() throws CloneNotSupportedException{ Cubic object=(Cubic)clone(); return object; } }
  • 160. Java设计模式 Java设计模式10/19/2018160模式的结构的描述与使用 2.具体原型(Concrete Prototype)_2: Goat.java import java.io.*; public class Goat implements Prototype,Serializable{ StringBuffer color; public void setColor(StringBuffer c){ color=c; } public StringBuffer getColor(){ return color; } public Object cloneMe() throws CloneNotSupportedException{ Object object=null; try{ ByteArrayOutputStream outOne=new ByteArrayOutputStream(); ObjectOutputStream outTwo=new ObjectOutputStream(outOne); outTwo.writeObject(this); ByteArrayInputStream inOne= new ByteArrayInputStream(outOne.toByteArray()); ObjectInputStream inTwo=new ObjectInputStream(inOne); object=inTwo.readObject(); } catch(Exception event){ System.out.println(event); } return object; } }
  • 161. Java设计模式 Java设计模式10/19/2018161模式的结构的描述与使用 3.应用 Application.java public class Application{ public static void main(String args[]){ Cubic cubic=new Cubic(12,20,66); System.out.println("cubic的长、宽和高:"); System.out.println(cubic.length+","+cubic.width+","+cubic.height); try{ Cubic cubicCopy=(Cubic)cubic.cloneMe(); System.out.println("cubicCopy的长、宽和高:"); System.out.println(cubicCopy.length+","+cubicCopy.width+"," +cubicCopy.height); } catch(CloneNotSupportedException exp){} Goat goat=new Goat(); goat.setColor(new StringBuffer("白颜色的山羊")); System.out.println("goat是"+goat.getColor()); try{ Goat goatCopy=(Goat)goat.cloneMe(); System.out.println("goatCopy是"+goatCopy.getColor()); System.out.println("goatCopy将自己的颜色改变成黑色"); goatCopy.setColor(new StringBuffer("黑颜色的山羊")); System.out.println("goat仍然是"+goat.getColor()); System.out.println("goatCopy是"+goatCopy.getColor()); } catch(CloneNotSupportedException exp){} } }
  • 162. 三、原型模式的优点 Java设计模式 Java设计模式10/19/2018162当创建类的新实例的代价更大时,使用原型模式复制一个已有的实例可以提高创建新实例的效率。 可以动态地保存当前对象的状态。在运行时刻,可以随时使用对象流保存当前对象的一个复制品。 可以在运行时创建新的对象,而无须创建一系列类和继承结构。 可以动态地添加、删除原型的复制品。
  • 163. 第十七章 单件模式 Java设计模式 Java设计模式10/19/2018163 单件模式 保证一个类仅有一个实例,并提供一个访问它的全局访问点。 Prototype Pattern Ensure a class only has one instance, and provide a global point of access to it.
  • 164. 一 、 概述 Java设计模式 Java设计模式10/19/2018164 单件模式是关于怎样设计一个类,并使得该类只有一个实例的成熟模式,该模式的关键是将类的构造方法设置为private权限,并提供一个返回它的唯一实例的类方法。
  • 165. 二、单件模式的结构与使用 Java设计模式 Java设计模式10/19/2018165模式的结构中只包括一个角色: 单件类(Singleton)
  • 166. Java设计模式 Java设计模式10/19/2018166模式的UML类图
  • 167. Java设计模式 Java设计模式10/19/2018167模式的结构的描述与使用 1.单件类(Singleton): Moon.java public class Moon{ private static Moon uniqueMoon; double radius; double distanceToEarth; private Moon(){ uniqueMoon=this; radius=1738; distanceToEarth=363300; } public static synchronized Moon getMoon(){ if(uniqueMoon==null){ uniqueMoon=new Moon(); } return uniqueMoon; } public String show(){ String s="月亮的半径是"+radius+"km,距地球是"+distanceToEarth+"km"; return s; } }
  • 168. Java设计模式 Java设计模式10/19/2018168模式的结构的描述与使用 2.应用 Application.java import javax.swing.*; import java.awt.*; public class Application{ public static void main(String args[]){ MyFrame f1=new MyFrame("张三看月亮"); MyFrame f2=new MyFrame( "李四看月亮"); f1.setBounds(10,10,360,150); f2.setBounds(370,10,360,150); f1.validate(); f2.validate(); } } class MyFrame extends JFrame{ String str; MyFrame(String title){ setTitle(title); Moon moon=Moon.getMoon(); str=moon.show(); setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); setVisible(true); repaint(); } public void paint(Graphics g){ super.paint(g); g.setFont(new Font("宋体",Font.BOLD,14)); g.drawString(str,5,100); } }
  • 169. 三、单件模式的优点 Java设计模式 Java设计模式10/19/2018169单件类的唯一实例由单件类本身来控制,所以可以很好地控制用户何时访问它。
  • 170. 第十八章 组合模式 Java设计模式 Java设计模式10/19/2018170 组合模式 将对象组合成数形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。 Composite Pattern Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.
  • 171. 一 、 概述 Java设计模式 Java设计模式10/19/2018171 组合模式是关于怎样将对象形成树形结构来表现整体和部分的层次结构的成熟模式。使用组合模式,可以让用户以一致的方式处理个体对象和组合对象,组合模式的关键在于无论是个体对象还是组合对象都实现了相同的接口或都是同一个抽象类的子类。
  • 172. 二、组合模式的结构与使用 Java设计模式 Java设计模式10/19/2018172模式的结构中包括三种角色: 抽象组件(Component) Composite节点(Composite Node) Leaf节点(Leaf Node)
  • 173. Java设计模式 Java设计模式10/19/2018173模式的UML类图
  • 174. Java设计模式 Java设计模式10/19/2018174模式的结构的描述与使用 1.抽象组件(Component) : MilitaryPerson.java import java.util.*; public interface MilitaryPerson{ public void add(MilitaryPerson person) ; public void remove(MilitaryPerson person) ; public MilitaryPerson getChild(int index); public Iterator getAllChildren() ; public boolean isLeaf(); public double getSalary(); public void setSalary(double salary); }
  • 175. Java设计模式 Java设计模式10/19/2018175模式的结构的描述与使用 2. Composite节点(Composite Node): MilitaryOfficer.java import java.util.*; public class MilitaryOfficer implements MilitaryPerson{ LinkedList list; String name; double salary; MilitaryOfficer(String name,double salary){ this.name=name; this.salary=salary; list=new LinkedList(); } public void add(MilitaryPerson person) { list.add(person); } public void remove(MilitaryPerson person){ list.remove(person); } public MilitaryPerson getChild(int index) { return list.get(index); } public Iterator getAllChildren() { return list.iterator(); } public boolean isLeaf(){ return false; } public double getSalary(){ return salary; } public void setSalary(double salary){ this.salary=salary; } }
  • 176. Java设计模式 Java设计模式10/19/2018176模式的结构的描述与使用 3.Leaf节点(Leaf Node):MilitarySoldier.java import java.util.*; public class MilitarySoldier implements MilitaryPerson{ double salary; String name; MilitarySoldier(String name,double salary){ this.name=name; this.salary=salary; } public void add(MilitaryPerson person) {} public void remove (MilitaryPerson person){} public MilitaryPerson getChild(int index) { return null; } public Iterator getAllChildren() { return null; } public boolean isLeaf(){ return true; } public double getSalary(){ return salary; } public void setSalary(double salary){ this.salary=salary; } }
  • 177. Java设计模式 Java设计模式10/19/2018177模式的结构的描述与使用 4.应用_1:ComputerSalary.java import java.util.*; public class ComputerSalary{ public static double computerSalary(MilitaryPerson person){ double sum=0; if(person.isLeaf()==true){ sum=sum+person.getSalary(); } if(person.isLeaf()==false){ sum=sum+person.getSalary(); Iterator iterator=person.getAllChildren(); while(iterator.hasNext()){ MilitaryPerson p= iterator.next(); sum=sum+computerSalary(p);; } } return sum; } }
  • 178. Java设计模式 Java设计模式10/19/2018178模式的结构的描述与使用 4.应用_2: Application.java public class Application{ public static void main(String args[]) { MilitaryPerson 连长=new MilitaryOfficer("连长",5000); MilitaryPerson 排长1=new MilitaryOfficer("一排长",4000); MilitaryPerson 排长2=new MilitaryOfficer("二排长",4000); MilitaryPerson 班长11=new MilitaryOfficer("一班长",2000); MilitaryPerson 班长12=new MilitaryOfficer("二班长",2000); MilitaryPerson 班长13=new MilitaryOfficer("三班长",2000); MilitaryPerson 班长21=new MilitaryOfficer("一班长",2000); MilitaryPerson 班长22=new MilitaryOfficer("二班长",2000); MilitaryPerson 班长23=new MilitaryOfficer("三班长",2000); MilitaryPerson 班长31=new MilitaryOfficer("一班长",2000); MilitaryPerson 班长32=new MilitaryOfficer("二班长",2000); MilitaryPerson 班长33=new MilitaryOfficer("三班长",2000); MilitaryPerson []士兵=new MilitarySoldier[60]; for(int i=0;i<士兵.length;i++){ 士兵[i]=new MilitarySoldier("小兵",1000); } 连长.add(排长1); 连长.add(排长2); 排长1.add(班长11); 排长1.add(班长12); 排长1.add(班长13); 排长2.add(班长21); 排长2.add(班长22); 排长2.add(班长23); for(int i=0;i<=9;i++){ 班长11.add(士兵[i]); 班长12.add(士兵[i+10]); 班长13.add(士兵[i+20]); 班长21.add(士兵[i+30]); 班长22.add(士兵[i+40]); 班长23.add(士兵[i+50]); 班长31.add(士兵[i+60]); 班长32.add(士兵[i+70]); 班长33.add(士兵[i+80]); } System.out.println("一排的军饷:"+ComputerSalary.computerSalary(排长1)); System.out.println("一班的军饷:"+ComputerSalary.computerSalary(班长11)); System.out.println("全连的军饷:"+ComputerSalary.computerSalary(连长)); } }
  • 179. 三、组合模式的优点 Java设计模式 Java设计模式10/19/2018179组合模式中包含有个体对象和组合对象,并形成树形结构,使用户可以方便地处理个体对象和组合对象。 组合对象和个体对象实现了相同的接口,用户一般不需区分个体对象和组合对象。 当增加新的Composite节点和Leaf节点时,用户的重要代码不需要作出修改。
  • 180. 第十九章 桥接模式 Java设计模式 Java设计模式10/19/2018180 桥接模式(别名:柄体模式) 将抽象部分与它的实现部分分离,使得它们都可以独立地变化。 Bridge Pattern(Another Name: Handle-Body) Decouple an abstraction from its implementation so that the two can vary independently.
  • 181. 一 、 概述 Java设计模式 Java设计模式10/19/2018181 桥接模式是关于怎样将抽象部分与它的实现部分分离,使得它们都可以独立地变化的成熟模式。
  • 182. 二、桥接模式的结构与使用 Java设计模式 Java设计模式10/19/2018182模式的结构中包括四种角色: 抽象(Abstraction) 实现者(Implementor) 细化抽象(Refined Abstraction) 具体实现者(Concrete Implementor)
  • 183. Java设计模式 Java设计模式10/19/2018183模式的UML类图
  • 184. Java设计模式 Java设计模式10/19/2018184模式的结构的描述与使用 1.抽象(Abstraction): ArchitectureCose.java public abstract class ArchitectureCost{ BuildingDesign design; double unitPrice; public abstract double giveCost() ; }
  • 185. Java设计模式 Java设计模式10/19/2018185模式的结构的描述与使用 2.实现者(Implementor) : BuildingDesign.java public interface BuildingDesign{ public double computerArea(); }
  • 186. Java设计模式 Java设计模式10/19/2018186模式的结构的描述与使用 3.细化抽象(Refined Abstraction):BuildingCose.java public class BuildingCost extends ArchitectureCost{ BuildingCost(BuildingDesign design,double unitPrice){ this.design=design; this.unitPrice=unitPrice; } public double giveCost() { double area=design.computerArea(); return area*unitPrice; } }
  • 187. Java设计模式 Java设计模式10/19/2018187模式的结构的描述与使用 4.具体实现者(Concrete Implementor):HouseDesign.java public class HouseDesign implements BuildingDesign{ double width,length; int floorNumber; HouseDesign(double width,double length,int floorNumber){ this.width=width; this.length=length; this.floorNumber=floorNumber; } public double computerArea(){ return width*length*floorNumber; } }
  • 188. Java设计模式 Java设计模式10/19/2018188模式的结构的描述与使用 5.应用 Application.java public class Application{ public static void main(String args[]) { double width=63,height=30; int floorNumber=8; double unitPrice=6867.38; BuildingDesign design=new HouseDesign(width,height,floorNumber); System.out.println("宽"+width+"米,高"+height+"米,层数为"+floorNumber); ArchitectureCost cost=new BuildingCost(design,unitPrice); double price=cost.giveCost(); System.out.printf("每平米造价:"+unitPrice+"元的商业楼的建设成本:%.2f元\n",price); width=52; height=28; floorNumber=6; unitPrice=2687.88; design=new HouseDesign(width,height,floorNumber); System.out.println("宽"+width+"米,高"+height+"米,层数为"+floorNumber); cost=new BuildingCost(design,unitPrice); price=cost.giveCost(); System.out.printf("每平米造价:"+unitPrice+"元的住宅楼的建设成本:%.2f元\n",price); } }
  • 189. 三、桥接模式的优点 Java设计模式 Java设计模式10/19/2018189桥接模式分离实现与抽象,使得抽象和实现可以独立的扩展。当修改实现的代码时,不影响抽象的代码,反之也一样。比如,对于19.2.2中的例子,如果具体实现者HouseDesign类决定将面积的计算加上一个额外的值,即修改了computerArea()方法,那么并不影响到细化抽象者的代码,反之,如果抽象者决定增加一个参与计算的参数:adjust,即细化抽象者修改代码,在计算成本时通过设置该参数的值来计算成本,那么并不影响实现着者的代码。 满足开闭-原则。抽象和实现者处于同层次,使得系统可独立地扩展这两个层次。增加新的具体实现者,不需要修改细化抽象,反之增加新的细化抽象也不需要修改具体实现。
  • 190. 第二十章 状态模式 Java设计模式 Java设计模式10/19/2018190 状态模式(别名:状态对象) 允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。 State Pattern(Another Name: Objects for States) Allow an object to alter its behavior when its internal state changes. The object will appear to change its class.
  • 191. 一 、 概述 Java设计模式 Java设计模式10/19/2018191 一个对象的状态依赖于它的变量的取值情况,对象在不同的运行环境中,可能具有不同的状态。在许多情况下,对象调用方法所产生的行为效果依赖于它当时的状态。 状态模式的关键是将对象的状态封装成为独立的类,对象调用方法时,可以委托当前对象所具有的状态调用相应的方法,使得当前对象看起来好像修改了它的类。
  • 192. 二、状态模式的结构与使用 Java设计模式 Java设计模式10/19/2018192模式的结构中包括三种角色: 环境(Context) 抽象状态(State) 具体状态(Concrete State)
  • 193. Java设计模式 Java设计模式10/19/2018193模式的UML类图
  • 194. Java设计模式 Java设计模式10/19/2018194模式的结构的描述与使用 1.环境(Context): Thermometer.java public class Thermometer{ TemperatureState state; public void showMessage(){ System.out.println("***********"); state.showTemperature(); System.out.println("***********"); } public void setState(TemperatureState state){ this.state=state; } }
  • 195. Java设计模式 Java设计模式10/19/2018195模式的结构的描述与使用 2.抽象状态(State): TemperatureState.java public interface TemperatureState{ public void showTemperature(); }
  • 196. Java设计模式 Java设计模式10/19/2018196模式的结构的描述与使用 3.具体状态(Concrete State)_1:LowState.java public class LowState implements TemperatureState{ double n=0; LowState(double n){ if(n<=0) this.n=n; } public void showTemperature(){ System.out.println("现在温度是"+n+"属于低温度"); } }
  • 197. Java设计模式 Java设计模式10/19/2018197模式的结构的描述与使用 3.具体状态(Concrete State)_2:MiddleState.java public class MiddleState implements TemperatureState{ double n=15; MiddleState(int n){ if(n>0&&n<26) this.n=n; } public void showTemperature(){ System.out.println("现在温度是"+n+"属于正常温度"); } }
  • 198. Java设计模式 Java设计模式10/19/2018198模式的结构的描述与使用 3.具体状态(Concrete State)_3:HeightState.java public class HeightState implements TemperatureState{ double n=39; HeightState(int n){ if(n>=39) this.n=n; } public void showTemperature(){ System.out.println("现在温度是"+n+"属于高温度"); } }
  • 199. Java设计模式 Java设计模式10/19/2018199模式的结构的描述与使用 4.应用 Application.java public class Application{ public static void main(String args[]) { TemperatureState state=new LowState(-12); Thermometer thermometer=new Thermometer(); thermometer.setState(state); thermometer.showMessage(); state=new MiddleState(20); thermometer.setState(state); thermometer.showMessage(); state=new HeightState(39); thermometer.setState(state); thermometer.showMessage(); } }
  • 200. 三、状态模式的优点 Java设计模式 Java设计模式10/19/2018200使用一个类封装对象的一种状态,很容易增加新的状态。 在状态模式中,环境(context)中不必出现大量的条件判断语句。环境(context)实例所呈现的状态变得更加清晰、容易理解。 使用状态模式可以让用户程序很方便的切换环境(context)实例的状态。 使用状态模式不会让环境(context)的实例中出现内部状态不一致的情况。 当状态对象没有实例变量时,环境(context)的各个实例可以共巷一个状态对象。
  • 201. 第二十一章 模板方法模式 Java设计模式 Java设计模式10/19/2018201模板方法模式 定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 Template Method Pattern Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.
  • 202. 一 、 概述 Java设计模式 Java设计模式10/19/2018202 模板方法是关于怎样将若干个方法集成到一个方法中,以便形成一个解决问题的算法骨架。模板方法模式的关键是在一个抽象类中定义一个算法的骨架,即将若干个方法集成到一个方法中,并称该方法为一个模板方法,或简称为模板。
  • 203. 二、模板方法模式的结构与使用 Java设计模式 Java设计模式10/19/2018203模式的结构中包括两种角色: 抽象模板(Abstract Template) 具体模板(Concrete Template)
  • 204. Java设计模式 Java设计模式10/19/2018204模式的UML类图
  • 205. Java设计模式 Java设计模式10/19/2018205模式的结构的描述与使用 1.抽象模板(Abstract Template): AbstractTemplate.java import java.io.*; public abstract class AbstractTemplate{ File [] allFiles; File dir; AbstractTemplate(File dir){ this.dir=dir; } public final void showFileName(){ allFiles=dir.listFiles(); sort(); printFiles(); } public abstract void sort(); public abstract void printFiles(); }
  • 206. Java设计模式 Java设计模式10/19/2018206模式的结构的描述与使用 2.具体模板(Concrete Template)_1: ConcreteTemplate1.java import java.io.*; import java.awt.*; import java.util.Date; import java.text.SimpleDateFormat; public class ConcreteTemplate1 extends AbstractTemplate{ ConcreteTemplate1(File dir){ super(dir); } public void sort(){ for(int i=0;i
  • 207. Java设计模式 Java设计模式10/19/2018207模式的结构的描述与使用 2.具体模板(Concrete Template)_2:ConcreteTemplate2.java import java.io.*; import java.awt.*; public class ConcreteTemplate2 extends AbstractTemplate{ ConcreteTemplate2(File dir){ super(dir); } public void sort(){ for(int i=0;i
  • 208. Java设计模式 Java设计模式10/19/2018208模式的结构的描述与使用 3.应用 Application.java import java.io.File; public class Application{ public static void main(String args[]) { File dir=new File("d:/javaExample"); AbstractTemplate template=new ConcreteTemplate1(dir); System.out.println(dir.getPath()+"目录下的文件:"); template.showFileName(); template=new ConcreteTemplate2(dir); System.out.println(dir.getPath()+"目录下的文件:"); template.showFileName(); } }
  • 209. 三、模板方法模式的优点 Java设计模式 Java设计模式10/19/2018209可以通过在抽象模板定义模板方法给出成熟的算法步骤,同时又不限制步骤的细节,具体模板实现算法细节不会改变整个算法的骨架。 在抽象模板模式中,可以通过钩子方法对某些步骤进行挂钩,具体模板通过钩子可以选择算法骨架中的某些步骤。
  • 210. 第二十二章 代理模式 Java设计模式 Java设计模式10/19/2018210 代理模式 为其他对象提供一种代理以控制对这个对象的访问。 Proxy Pattern Provide a surrogate or placeholder for another object to control access to it.
  • 211. 一 、 概述 Java设计模式 Java设计模式10/19/2018211 代理模式是为对象提供一个代理,代理可以控制对它所代理的对象的访问。 代理模式最常见的两种情况:远程代理和虚拟代理。
  • 212. 二、代理模式的结构与使用 Java设计模式 Java设计模式10/19/2018212模式的结构中包括三种角色: 抽象主题(Subject) 实际主题(RealSubject) 代理(Proxy)
  • 213. Java设计模式 Java设计模式10/19/2018213模式的UML类图
  • 214. Java设计模式 Java设计模式10/19/2018214模式的结构的描述与使用 1.抽象主题(Subject): Geometry.java public interface Geometry{ public double getArea(); }
  • 215. Java设计模式 Java设计模式10/19/2018215模式的结构的描述与使用 2.具体模板(Concrete Template): Trangle.java public class Triangle implements Geometry{ double sideA,sideB,sideC,area; public Triangle(double a,double b,double c) { sideA=a; sideB=b; sideC=c; } public double getArea(){ double p=(sideA+sideB+sideC)/2.0; area=Math.sqrt(p*(p-sideA)*(p-sideB)*(p-sideC)) ; return area; } }
  • 216. Java设计模式 Java设计模式10/19/2018216模式的结构的描述与使用 3.代理(Proxy):TriangleProxy.java public class TriangleProxy implements Geometry{ double sideA,sideB,sideC; Triangle triangle; public void setABC(double a,double b,double c) { sideA=a; sideB=b; sideC=c; } public double getArea(){ if(sideA+sideB>sideC&&sideA+sideC>sideB&&sideB+sideC>sideA){ triangle=new Triangle(sideA,sideB,sideC); double area=triangle.getArea(); return area; } else return -1; } }
  • 217. Java设计模式 Java设计模式10/19/2018217模式的结构的描述与使用 4.应用 Application.java import java.util.Scanner; public class Application{ public static void main(String args[]) { Scanner reader=new Scanner(System.in); System.out.println("请输入三个数,每输入一个数回车确认"); double a=-1,b=-1,c=-1; a=reader.nextDouble(); b=reader.nextDouble(); c=reader.nextDouble(); TriangleProxy proxy=new TriangleProxy(); proxy.setABC(a,b,c); double area=proxy.getArea(); System.out.println("面积是:"+area); } }
  • 218. 三、代理模式的优点 Java设计模式 Java设计模式10/19/2018218代理模式可以屏蔽用户真正请求的对象,使用户程序和真正的对象之间解耦。 使用代理来担当那些创建耗时的对象的替身。
  • 219. 第二十三章 享元模式 Java设计模式 Java设计模式10/19/2018219 享元模式 运用共享技术有效地支持大量细粒度的对象。 Flyweight Pattern Use sharing to support large numbers of fine-grained objects efficiently.
  • 220. 一 、 概述 Java设计模式 Java设计模式10/19/2018220 一个类中的成员变量表明该类所创建的对象所具有的属性,在某些程序设计中我们可能用一个类创建若干个对象,但是我们发现这些对象的一个共同特点是它们有一部分属性的取值必须是完全相同的。
  • 221. 二、享元模式的结构与使用 Java设计模式 Java设计模式10/19/2018221模式的结构中包括三种角色: 享元接口(Flyweight) 具体享元(Concrete Flyweight) 享元工厂(Flyweight Factory)
  • 222. Java设计模式 Java设计模式10/19/2018222模式的UML类图
  • 223. Java设计模式 Java设计模式10/19/2018223模式的结构的描述与使用 1.享元接口(Flyweight): Flyweight.java public interface Flyweight{ public double getHeight(); public double getWidth(); public double getLength(); public void printMess(String mess); }
  • 224. Java设计模式 Java设计模式10/19/2018224模式的结构的描述与使用 2.享元工厂(FlyweightFactory)与具体享元_1: FlyweightFactory.java import java.util.HashMap; public class FlyweightFactory{ private HashMap hashMap; static FlyweightFactory factory=new FlyweightFactory(); private FlyweightFactory(){ hashMap=new HashMap(); } public static FlyweightFactory getFactory(){ return factory; } public synchronized Flyweight getFlyweight(String key){ if(hashMap.containsKey(key)) return hashMap.get(key); else{ double width=0,height=0,length=0; String [] str=key.split("#"); width=Double.parseDouble(str[0]); height=Double.parseDouble(str[1]); length=Double.parseDouble(str[2]); Flyweight ft=new ConcreteFlyweight(width,height,length); hashMap.put(key,ft); return ft; } }
  • 225. Java设计模式 Java设计模式10/19/2018225模式的结构的描述与使用 2.享元工厂(FlyweightFactory)与具体享元_2: FlyweightFactory.java class ConcreteFlyweight implements Flyweight{ private double width; private double height; private double length; private ConcreteFlyweight(double width,double height,double length){ this.width=width; this.height=height; this.length=length; } public double getHeight(){ return height; } public double getWidth(){ return width; } public double getLength(){ return length; } public void printMess(String mess){ System.out.print(mess); System.out.print(" 宽度:"+width); System.out.print(" 高度:"+height); System.out.println("长度:"+length); } } }
  • 226. Java设计模式 Java设计模式10/19/2018226模式的结构的描述与使用 3.应用_1: Car.java public class Car{ Flyweight flyweight; String name,color; int power; Car(Flyweight flyweight,String name,String color,int power){ this.flyweight=flyweight; this.name=name; this.color=color; this.power=power; } public void print(){ System.out.print(" 名称:"+name); System.out.print(" 颜色:"+color); System.out.print(" 功率:"+power); System.out.print(" 宽度:"+flyweight.getWidth()); System.out.print(" 高度:"+flyweight.getHeight()); System.out.println("长度:"+flyweight.getLength()); } }
  • 227. Java设计模式 Java设计模式10/19/2018227模式的结构的描述与使用 3.应用_2: Application.java public class Application{ public static void main(String args[]) { FlyweightFactory factory=FlyweightFactory.getFactory(); double width=1.82,height=1.47,length=5.12; String key=""+width+"#"+height+"#"+length; Flyweight flyweight=factory.getFlyweight(key); Car audiA6One=new Car(flyweight,"奥迪A6","黑色",128); Car audiA6Two=new Car(flyweight,"奥迪A6","灰色",160); audiA6One.print(); audiA6Two.print(); width=1.77; height=1.45; length=4.63; key=""+width+"#"+height+"#"+length; flyweight=factory.getFlyweight(key); Car audiA4One=new Car(flyweight,"奥迪A4","蓝色",126); Car audiA4Two=new Car(flyweight,"奥迪A4","红色",138); flyweight.printMess(" 名称:奥迪A4 颜色:蓝色 功率:126"); flyweight.printMess(" 名称:奥迪A4 颜色:红色 功率:138"); } }
  • 228. 三、享元模式的优点 Java设计模式 Java设计模式10/19/2018228使用享元可以节省内存的开销,特别适合处理大量细粒度对象,这些对象的许多属性值是相同的,而且一旦创建则不容许修改。 享元模式中的享元可以使用方法的参数接受外部状态中的数据,但外部状态数据不会干扰到享元中的内部数据,这就使得享元可以在不同的环境中被共享。
  • 229. 第二十四章 访问者模式 Java设计模式 Java设计模式10/19/2018229访问者模式 表示一个作用于某对象结构中的各个元素的操作。它使你可以在不改变各个元素的类的前提下定义作用于这些元素的新操作。 Visitor Pattern Represent an operation to be performed on the elements of an objectstructure. Visitor lets you define a new operation without changing the classes of the elements on which it operates.
  • 230. 一 、 概述 Java设计模式 Java设计模式10/19/2018230 当一个集合中有若干个对象时,习惯上将这些对象称作集合中的元素,访问者模式可以使得我们在不改变集合中各个元素的类的前提下定义作用于这些元素上的新操作。
  • 231. 二、访问者模式的结构与使用 Java设计模式 Java设计模式10/19/2018231模式的结构中包括五种角色: 抽象元素(Element) 具体元素(Concrete Element) 对象结构(Object Structure) 抽象访问者(Visitor) 具体访问者(Concrete Visitor)
  • 232. Java设计模式 Java设计模式10/19/2018232模式的UML类图
  • 233. Java设计模式 Java设计模式10/19/2018233模式的结构的描述与使用 1.抽象元素(Element): Student.java public abstract class Student{ public abstract void accept(Visitor v); }
  • 234. Java设计模式 Java设计模式10/19/2018234模式的结构的描述与使用 2.具体元素(Concrete Element)_1: Undergraduate.java public class Undergraduate extends Student{ double math,english; //成绩 String name; Undergraduate(String name,double math,double english){ this.name=name; this.math=math; this.english=english; } public double getMath(){ return math; } public double getEnglish(){ return english; } public String getName(){ return name; } public void accept(Visitor v){ v.visit(this); } }
  • 235. Java设计模式 Java设计模式10/19/2018235模式的结构的描述与使用 2.具体元素(Concrete Element)_2: GraduateStudent.java public class GraduateStudent extends Student{ double math,english,physics; //成绩 String name; GraduateStudent(String name,double math,double english,double physics){ this.name=name; this.math=math; this.english=english; this.physics=physics; } public double getMath(){ return math; } public double getEnglish(){ return english; } public double getPhysics(){ return physics; } public String getName(){ return name; } public void accept(Visitor v){ v.visit(this); } }
  • 236. Java设计模式 Java设计模式10/19/2018236模式的结构的描述与使用 3.对象结构(Object Structure) 本问题中,我们让该角色是java.util包中的ArrayList集合。
  • 237. Java设计模式 Java设计模式10/19/2018237模式的结构的描述与使用 4.抽象访问者(Visitor): Visitor.java public interface Visitor{ public void visit(Undergraduate stu); public void visit(GraduateStudent stu); }
  • 238. Java设计模式 Java设计模式10/19/2018238模式的结构的描述与使用 5.具体访问者( Concrete Visitor): Company.java public class Company implements Visitor{ public void visit(Undergraduate stu){ double math=stu.getMath(); double english=stu.getEnglish(); if(math>80&&english>90) System.out.println(stu.getName()+"被录用"); } public void visit(GraduateStudent stu){ double math=stu.getMath(); double english=stu.getEnglish(); double physics=stu.getPhysics(); if(math>80&&english>90&&physics>70) System.out.println(stu.getName()+"被录用"); } }
  • 239. Java设计模式 Java设计模式10/19/2018239模式的结构的描述与使用 6.应用: Application.java import java.util.*; public class Application{ public static void main(String args[]) { Visitor visitor=new Company(); ArrayList studentList=new ArrayList(); Student student=null; studentList.add(student=new Undergraduate("张三",67,88)); studentList.add(student=new Undergraduate("李四",90,98)); studentList.add(student=new Undergraduate("将粼粼",85,92)); studentList.add(student=new GraduateStudent("刘名",88,70,87)); studentList.add(student=new GraduateStudent("郝人",90,95,82)); Iterator iter=studentList.iterator(); while(iter.hasNext()){ Student stu=iter.next(); stu.accept(visitor); } } }
  • 240. 三、访问者模式的优点 Java设计模式 Java设计模式10/19/2018240可以在不改变一个集合中的元素的类的情况下,增加新的施加于该元素上的新操作。 可以将集合中各个元素的某些操作集中到访问者中,不仅便于集合的维护,也有利于集合中元素的复用。
  • 241. 第二十五章 备忘录模式 Java设计模式 Java设计模式10/19/2018241 备忘录模式(别名:标记) 在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样以后就可将该对象恢复到原先保存的状态。 Memento Pattern (Another Name: Token) Without violating encapsulation, capture and externalize an object'sinternal state so that the object can be restored to this state later.
  • 242. 一 、 概述 Java设计模式 Java设计模式10/19/2018242 备忘录模式是关于怎样保存对象状态的成熟模式,其关键是提供一个备忘录对象,该备忘录负责存储一个对象的状态,程序可以在磁盘或内存中保存这个备忘录,这样一来,程序就可以根据对象的备忘录将该对象恢复到备忘录中所存储的状态。
  • 243. 二、备忘录模式的结构与使用 Java设计模式 Java设计模式10/19/2018243模式的结构中包括三种角色: 原发者(Originator) 备忘录(Memento) 负责人(Caretaker)
  • 244. Java设计模式 Java设计模式10/19/2018244模式的UML类图
  • 245. Java设计模式 Java设计模式10/19/2018245模式的结构的描述与使用 1.原发者(Originator): ReadPhrase.java package tom.jiafei; import java.io.*; public class ReadPhrase { long readPosition; File file; RandomAccessFile in; String phrase=null; public ReadPhrase(File file){ this.file=file; try{ in=new RandomAccessFile(file,"r"); } catch(IOException exp){ } } public Memento createMemento(){ Memento mem=new Memento(); mem.setPositionState(readPosition); return mem; } public void restoreFromMemento(Memento mem){ readPosition=mem.getPositionState(); } public String readLine(){ try{ in.seek(readPosition); phrase=in.readLine(); if(phrase!=null){ byte b[]= phrase.getBytes("iso-8859-1"); phrase=new String(b); } readPosition=in.getFilePointer(); } catch(IOException exp){} return phrase; } public void closeRead(){ try{ in.close(); } catch(IOException exp){ } } }
  • 246. Java设计模式 Java设计模式10/19/2018246模式的结构的描述与使用 2.备忘录(Memento): Memento.java package tom.jiafei; public class Memento implements java.io.Serializable{ private long state; void setPositionState(long state){ this.state=state; } long getPositionState(){ return state; } }
  • 247. Java设计模式 Java设计模式10/19/2018247模式的结构的描述与使用 3.负责人(Caretaker):Caretaker.java import tom.jiafei.*; import java.io.*; public class Caretaker{ File file; private Memento memento=null; Caretaker(){ file=new File("saveObject.txt"); } public Memento getMemento(){ if(file.exists()) { try{ FileInputStream in=new FileInputStream("saveObject.txt"); ObjectInputStream inObject=new ObjectInputStream(in); memento=(Memento)inObject.readObject(); } catch(Exception exp){} } return memento; } public void saveMemento(Memento memento){ try{ FileOutputStream out=new FileOutputStream("saveObject.txt"); ObjectOutputStream outObject=new ObjectOutputStream(out); outObject.writeObject(memento); } catch(Exception exp){} } }
  • 248. Java设计模式 Java设计模式10/19/2018248模式的结构的描述与使用 4.应用: Application.java _1 import tom.jiafei.*; import java.util.Scanner; import java.io.*; public class Application{ public static void main(String args[]) { Scanner reader=new Scanner(System.in); ReadPhrase readPhrase=new ReadPhrase(new File("phrase.txt")); File favorPhrase=new File("favorPhrase.txt"); RandomAccessFile out=null; try{ out=new RandomAccessFile(favorPhrase,"rw"); } catch(IOException exp){} System.out.println("是否从上次读取的位置继续读取成语(输入y或n)"); String answer=reader.nextLine(); if(answer.startsWith("y")||answer.startsWith("Y")){ Caretaker caretaker=new Caretaker(); //创建负责人 Memento memento=caretaker.getMemento(); //得到备忘录 if(memento!=null) readPhrase.restoreFromMemento(memento); //使用备忘录恢复状态 } String phrase=null; while((phrase=readPhrase.readLine())!=null){ System.out.println(phrase); System.out.println("是否将该成语保存到"+favorPhrase.getName()); answer=reader.nextLine();
  • 249. Java设计模式 Java设计模式10/19/2018249模式的结构的描述与使用 4.应用: Application.java _2 if(answer.startsWith("y")||answer.startsWith("Y")){ try{ out.seek(favorPhrase.length()); byte [] b=phrase.getBytes(); out.write(b); out.writeChar('\n'); } catch(IOException exp){} } System.out.println("是否继续读取成语?(输入y或n)"); answer=reader.nextLine(); if(answer.startsWith("y")||answer.startsWith("Y")) continue; else{ readPhrase.closeRead(); Caretaker caretaker=new Caretaker(); //创建负责人 caretaker.saveMemento(readPhrase.createMemento());//保存备忘录 try{ out.close(); } catch(IOException exp){} System.exit(0); } } System.out.println("读完全部成语"); } }
  • 250. 三、备忘录模式的优点 Java设计模式 Java设计模式10/19/2018250备忘录模式使用备忘录可以把原发者的内部状态保存起来,使得只有很“亲密的”的对象可以访问备忘录中的数据。 备忘录模式强调了类设计单一责任原则,即将状态的刻画和保存分开。
  • 251. 第二十六章 解释器模式 Java设计模式 Java设计模式10/19/2018251 解释器模式 给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。 Interpreter Pattern Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.
  • 252. 一 、 概述 Java设计模式 Java设计模式10/19/2018252 解释模式是关于怎样实现一个简单语言的成熟模式,其关键是将每一个语法规则表示成一个类。
  • 253. 二、解释器模式的结构与使用 Java设计模式 Java设计模式10/19/2018253模式的结构中包括四种角色: 抽象表达式(AbstractExpression) 终结符表达式子(TerminalExpression) 非终结符表达式子(NonterminalExpression) 上下文(Context)
  • 254. Java设计模式 Java设计模式10/19/2018254模式的UML类图
  • 255. Java设计模式 Java设计模式10/19/2018255模式的结构的描述与使用 1.抽象表达式(AbstractExpression): Node.java public interface Node{ public void parse(Context text); public void execute(); }
  • 256. Java设计模式 Java设计模式10/19/2018256模式的结构的描述与使用 2.终结符表达式(TerminalExpression)_1: SubjectPronounOrNounNode.java public class SubjectPronounOrNounNode implements Node{ String [] word={"You","He","Teacher","Student"}; String token; boolean boo; public void parse(Context context){ token=context.nextToken(); int i=0; for(i=0;i
  • 257. Java设计模式 Java设计模式10/19/2018257模式的结构的描述与使用 2.终结符表达式(TerminalExpression)_2: ObjectPronounOrNounNode.java public class ObjectPronounOrNounNode implements Node{ String [] word={"Me","Him","Tiger","Apple"}; String token; boolean boo; public void parse(Context context){ token=context.nextToken(); int i=0; for(i=0;i
  • 258. Java设计模式 Java设计模式10/19/2018258模式的结构的描述与使用 2.终结符表达式(TerminalExpression)_3: VerbNode.java public class VerbNode implements Node{ String [] word={"Drink","Eat","Look","beat"}; String token; boolean boo; public void parse(Context context){ token=context.nextToken(); int i=0; for(i=0;i
  • 259. Java设计模式 Java设计模式10/19/2018259模式的结构的描述与使用 3.非终结符表达式(TerminalExpression)_1: SentenceNode.java public class SentenceNode implements Node{ Node subjectNode,predicateNode; public void parse(Context context){ subjectNode =new SubjectNode(); predicateNode=new PredicateNode(); subjectNode.parse(context); predicateNode.parse(context); } public void execute(){ subjectNode.execute(); predicateNode.execute(); } }
  • 260. Java设计模式 Java设计模式10/19/2018260模式的结构的描述与使用 3.非终结符表达式(TerminalExpression)_2: SubjectNode.java public class SubjectNode implements Node{ Node node; public void parse(Context context){ node =new SubjectPronounOrNounNode(); node.parse(context); } public void execute(){ node.execute(); } }
  • 261. Java设计模式 Java设计模式10/19/2018261模式的结构的描述与使用 3.非终结符表达式(TerminalExpression)_3: PredicateNode.java public class PredicateNode implements Node{ Node verbNode,objectNode; public void parse(Context context){ verbNode =new VerbNode(); objectNode=new ObjectNode(); verbNode.parse(context); objectNode.parse(context); } public void execute(){ verbNode.execute(); objectNode.execute(); } }
  • 262. Java设计模式 Java设计模式10/19/2018262模式的结构的描述与使用 3.非终结符表达式(TerminalExpression)_4: ObjectNode.java public class ObjectNode implements Node{ Node node; public void parse(Context context){ node =new ObjectPronounOrNounNode(); node.parse(context); } public void execute(){ node.execute(); } }
  • 263. Java设计模式 Java设计模式10/19/2018263模式的结构的描述与使用 4.上下文(Context):Context.java import java.util.StringTokenizer; public class Context{ StringTokenizer tokenizer; String token; public Context(String text){ setContext(text); } public void setContext(String text){ tokenizer=new StringTokenizer(text); } String nextToken(){ if(tokenizer.hasMoreTokens()){ token=tokenizer.nextToken(); } else token=""; return token; } }
  • 264. Java设计模式 Java设计模式10/19/2018264模式的结构的描述与使用 5.应用 Application.java public class Application{ public static void main(String args[]){ String text="Teacher beat tiger"; Context context=new Context(text); Node node=new SentenceNode(); node.parse(context); node.execute(); text="You eat apple"; context.setContext(text); System.out.println(); node.parse(context); node.execute(); text="you look him"; context.setContext(text); System.out.println(); node.parse(context); node.execute(); } }
  • 265. 三、解释器模式的优点 Java设计模式 Java设计模式10/19/2018265将每一个语法规则表示成一个类,方便于实现简单的语言。 由于使用类表示语法规则,可以较容易改变或扩展语言的行为。 通过在类结构中加入新的方法,可以在解释的同时增加新的行为。