• 1. 封面 Java设计模式 Java设计模式Java设计模式 10/23/20181
  • 2. 第一章 设计模式简介 1.1 什么是设计模式 Java设计模式 Java设计模式10/23/20182 每一个设计模式描述一个在我们周围不断重复发生的问题,以及该问题的解决方案的核心。这样,你就能一次一次地使用该方案而不必做重复劳动。
  • 3. 1.2 设计模式的起源 Java设计模式 Java设计模式10/23/20183 软件领域的设计模式起源于建筑学。 1977年,建筑大师Alexander出版了《A Pattern Language:Towns, Building, Construction》一书。受Alexander著作的影响 ,Kent Beck和Ward Cunningham在1987年举行的一次面向对象的会议上发表了论文:《在面向对象编程中使用模式》。
  • 4. 1.3 GOF之著作 Java设计模式 Java设计模式10/23/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/23/20185 学习设计模式不仅可以使我们使用好这些成功的模式,更重要的是可以使我们更加深刻地理解面向对象的设计思想,非常有利于我们更好地使用面向对象语言解决设计中的问题。
  • 6. 1.5 合理使用模式 Java设计模式 Java设计模式10/23/20186 1.正确使用 2.避免教条 3.模式挖掘
  • 7. 第二章 面向对象的几个基本原则 2.1 面向抽象原则 Java设计模式 Java设计模式10/23/20187 设计一个类时,不让该类面向具体的类,而是面向抽象类或接口 。
  • 8. 第二章 面向对象的几个基本原则 Java设计模式 Java设计模式10/23/20188public class Circle{ double r;Circle(double r){this.r=r;} public double getArea(){ return 3.14*r*r;}}public class Pillar{ Circle bottom; double height; Pillar(Circle bottom,double height){ this.bottom=bottom;this.height=height;}}定义底面为三角形的柱体?
  • 9. 第二章 面向对象的几个基本原则 Java设计模式 Java设计模式10/23/20189public abstract class Geometry{ public abstract double getArea(); }public class Pillar{ Geometry bottom; double height; Pillar(Circle bottom,double height){ this.bottom=bottom;this.height=height;}}
  • 10. 2.2 开-闭原则 Java设计模式 Java设计模式10/23/201810 设计应当对扩展开放,对修改关闭。 如果您的设计遵守了“开-闭原则”,那么这个设计一定是易维护的,因为在设计中增加新的模块时,不必去修改设计中的核心模块。
  • 11. 2.3 高内聚-低耦合原则 Java设计模式 Java设计模式10/23/201811 如果类中的方法是一组相关的行为,则称该类是高内聚的,反之称为低内聚的。 所谓低耦合就是尽量不要让一个类含有太多的其它类的实例的引用,以避免修改系统的其中一部分会影响到其它部分。
  • 12. 第四章 命令模式 Java设计模式 Java设计模式10/23/201812 命令模式(别名:动作,事务) 将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤消的操作。 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.
  • 13. 一 、 概述 Java设计模式 Java设计模式10/23/201813 在许多设计中,经常涉及到一个对象请求另一个对象调用其方法到达某种目的。如果请求者不希望或无法直接和被请求者打交道,即不希望或无法含有被请求者的引用,那么就可以使用命令模式。
  • 14. 实例在军队作战中,指挥官请求三连偷袭敌人,但是指挥官不希望或无法直接与三连取得联系,那么可以将该请求:“三连偷袭敌人”形成一个“作战命令”。只要能让该作战命令被执行,就会实现三连偷袭敌人的目的。
  • 15. 二、命令模式的结构与使用 Java设计模式 Java设计模式10/23/201815模式的结构中包括四种角色: 接收者(Receiver) 命令(Command)接口 具体命令(ConcreteCommand) 请求者(Invoker)
  • 16. Java设计模式 Java设计模式10/23/201816模式的UML类图
  • 17. Java设计模式 Java设计模式10/23/201817模式的结构的描述与使用 1.接收者(Receiver) : CompanyArmy.java public class CompanyArmy{ public void sneakAttack(){ System.out.println("我们知道如何偷袭敌人,保证完成任务"); } }
  • 18. Java设计模式 Java设计模式10/23/201818模式的结构的描述与使用 2.命令(Command)接口 : Command.java public interface Command { public abstract void execute(); }
  • 19. Java设计模式 Java设计模式10/23/201819模式的结构的描述与使用 3.具体命令(ConcreteCommand) ConcreteCommand.java public class ConcreteCommand implements Command{ CompanyArmy army; //含有接收者的引用 ConcreteCommand(CompanyArmy army){ this.army=army; } public void execute(){ //封装着指挥官的请求 army.sneakAttack(); //偷袭敌人 } }
  • 20. Java设计模式 Java设计模式10/23/201820模式的结构的描述与使用 4.请求者(Invoker) ArmySuperior.java public class ArmySuperior{ Command command; //用来存放具体命令的引用 public void setCommand(Command command){ this.command=command; } public void startExecuteCommand(){ //让具体命令执行execute()方法 command.execute(); } }
  • 21. Java设计模式 Java设计模式10/23/201821模式的结构的描述与使用 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(); } }
  • 22. 三、命令模式的优点 Java设计模式 Java设计模式10/23/201822 在命令模式中,请求者(Invoker)不直接与接收者(Receiver)交互,即请求者(Invoker)不包含接收者(Receiver)的引用,因此彻底消除了彼此之间的耦合。 命令模式满足“开-闭原则”。如果增加新的具体命令和该命令的接受者,不必修改调用者的代码,调用者就可以使用新的命令对象;反之,如果增加新的调用者,不必修改现有的具体命令和接受者,新增加的调用者就可以使用已有的具体命令。
  • 23. 四、应用举例 模拟带控制开关的小电器。该电器上有四个开关,两个一组,其中一组负责打开、关闭小电器上的照明灯,另一组负责打开、关闭小电器上的摄像头。
  • 24. 第五章 观察者模式 Java设计模式 Java设计模式10/23/201824 观察者模式(别名:依赖,发布-订阅) 定义对象间的一种一对多的依赖关系,当一个对象的状态发生变化时,所有依赖于它的对象都得到通知并被自动更新。 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..
  • 25. 一 、 概述 Java设计模式 Java设计模式10/23/201825 在许多设计中,经常涉及到多个对象都对一个特殊对象中的数据变化感兴趣,而且这多个对象都希望跟踪那个特殊对象中的数据变化。
  • 26. 实例某些寻找工作的人对“求职中心”的职业需求信息的变化非常关心,很想跟踪“求职中心”中职业需求信息的变化。“求职者”可以让“求职中心”把自己登记下来,这样求职中心就会及时通知她最新的职业信息需求。
  • 27. 二、 模式的结构与使用 Java设计模式 Java设计模式10/23/201827观察者模式的结构中包括四种角色: 主题(Subject) 观察者(Observer) 具体主题(ConcreteSubject) 具体观察者(ConcreteObserver)
  • 28. Java设计模式 Java设计模式10/23/201828模式的UML类图
  • 29. Java设计模式 Java设计模式10/23/201829模式的结构的描述与使用 1.主题 : Subject.java public interface Subject{ public void addObserver(Observer o); public void deleteObserver(Observer o); public void notifyObservers(); }
  • 30. Java设计模式 Java设计模式10/23/201830模式的结构的描述与使用 2.观察者 : Obsever.java public interface Observer{ public void hearTelephone(String heardMess); }
  • 31. Java设计模式 Java设计模式10/23/201831模式的结构的描述与使用 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); }
  • 32. Java设计模式 Java设计模式10/23/201832模式的结构的描述与使用 3.具体主题 SeekJobCenter.java_2 public void notifyObservers(){ if(changed){for(int i=0;i
  • 33. Java设计模式 Java设计模式10/23/201833模式的结构的描述与使用 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()); } } }
  • 34. Java设计模式 Java设计模式10/23/201834模式的结构的描述与使用 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()); } } }
  • 35. Java设计模式 Java设计模式10/23/201835模式的结构的描述与使用 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(); }
  • 36. 三、观察者模式的优点 Java设计模式 Java设计模式10/23/201836具体主题和具体观察者是松耦合关系。由于主题(Subject)接口仅仅依赖于观察者(Observer)接口,因此具体主题只是知道它的观察者是实现观察者(Observer)接口的某个类的实例,但不需要知道具体是哪个类。同样,由于观察者仅仅依赖于主题(Subject)接口,因此具体观察者只是知道它依赖的主题是实现主题(subject)接口的某个类的实例,但不需要知道具体是哪个类。 观察模式满足“开-闭原则”。主题(Subject)接口仅仅依赖于观察者(Observer)接口,这样,我们就可以让创建具体主题的类也仅仅是依赖于观察者(Observer)接口,因此如果增加新的实现观察者(Observer)接口的类,不必修改创建具体主题的类的代码。同样,创建具体观察者的类仅仅依赖于主题(Observer)接口,如果增加新的实现主题(Subject)接口的类,也不必修改创建具体观察者类的代码。
  • 37. 四、应用举例指挥部希望按时得到水文站测量到的关于水流的信息,比如流量、流速等。
  • 38. 第六章 装饰模式 Java设计模式 Java设计模式10/23/201838 装饰模式(别名:包装器) 动态地给对象添加一些额外的职责。就功能来说装饰模式相比生成子类更为灵活。 Decorator Pattern(Another Name: Wrapper) Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.
  • 39. 一 、 概述 Java设计模式 Java设计模式10/23/201839 装饰模式是动态地扩展一个对象的功能,而不需要改变原始类代码的一种成熟模式。在装饰模式中,“具体组件”类和“具体装饰”类是该模式中的最重要的两个角色。
  • 40. 实例 Java设计模式 Java设计模式10/23/201840假设系统中有一个Bird抽象类以及Bird类的一个子类:Sparrow。 Sparrow类实现了Bird类的fly方法,使得Sparrow类创建的对象 调用fly方法能连续飞行100米。现在用户需要两种鸟,必须分别 能连续飞行150米和200米。
  • 41. 二、装饰模式模式的结构与使用 Java设计模式 Java设计模式10/23/201841装饰模式的结构中包括四种角色: 抽象组件(Component) 具体组件(ConcreteComponent) 装饰(Decorator) 具体装饰(ConcreteDecotator)
  • 42. Java设计模式 Java设计模式10/23/201842装饰模式的UML类图
  • 43. Java设计模式 Java设计模式10/23/201843装饰模式的结构的描述与使用 1.抽象组件 : Bird.java public abstract class Bird{ public abstract int fly(); }
  • 44. Java设计模式 Java设计模式10/23/201844装饰模式的结构的描述与使用 2.具体组件 : Sparrow.java public class Sparrow extends Bird{ public final int DISTANCE=100; public int fly(){ return DISTANCE; } }
  • 45. Java设计模式 Java设计模式10/23/201845装饰模式的结构的描述与使用 3.装饰 (Decorator): Decorator.java public abstract class Decorator extends Bird{ protected Bird bird; public Decorator(){ } public Decorator(Bird bird){ this.bird=bird; } }
  • 46. Java设计模式 Java设计模式10/23/201846装饰模式的结构的描述与使用 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; } }
  • 47. Java设计模式 Java设计模式10/23/201847装饰模式的结构的描述与使用 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); } }
  • 48. 三、装饰模式的优点 Java设计模式 Java设计模式10/23/201848 被装饰者和装饰者是松耦合关系。由于装饰(Decorator)仅仅依赖于抽象组件(Component),因此具体装饰只知道它要装饰的对象是抽象组件的某一个子类的实例,但不需要知道是哪一个具体子类。 装饰模式满足“开-闭原则”。不必修改具体组件,就可以增加新的针对该具体组件的具体装饰。 可以使用多个具体装饰来装饰具体组件的实例。
  • 49. 四、应用举例当前系统已有一个抽象类ReadWord,该类有一个抽象方法readWord(),另外还有一个ReadWord类的子类ReadEnglishWord,该类的readWord()方法可以读取一个由英文单词构成的文本文件word.txt。系统已有类的类图如图6.11所示。目前已有一些客户在使用该系统,并使用ReadWord类的对象调用readWord()方法读取文件中的单词。 ReadWord+readWord(File)ReadEnglishWord+readWord(File)
  • 50. 四、应用举例现有部分用户希望使用ReadWord类的对象调用readWord()方法读取文件word.txt中的单词,并希望同时也能得到该单词 的汉语解释,也有一些用户希望不仅能得到该单词汉语解释也能得到该单词的英文例句。要求不允许修改现有系统的代码以及word.txt文件,对系统进行扩展以满足用户需求。
  • 51. 第七章 策略模式 Java设计模式 Java设计模式10/23/201851 策略模式(别名:政策) 定义一系列算法,把它们一个个封装起来,并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。 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.
  • 52. 一 、 概述 Java设计模式 Java设计模式10/23/201852 策略模式是处理算法的不同变体的一种成熟模式,策略模式通过接口或抽象类封装算法的标识,即在接口中定义一个抽象方法,实现该接口的类将实现接口中的抽象方法。 在策略模式中,封装算法标识的接口称作策略,实现该接口的类称作具体策略。
  • 53. 实例 Java设计模式 Java设计模式10/23/201853 策略模式是处理算法的不同变体的一种成熟模式,策略模式通过接口或抽象类封装算法的标识,即在接口中定义一个抽象方法,实现该接口的类将实现接口中的抽象方法。 在策略模式中,封装算法标识的接口称作策略,实现该接口的类称作具体策略。
  • 54. 二、策略模式的结构与使用 Java设计模式 Java设计模式10/23/201854策略模式的结构中包括三种角色: 策略(Strategy) 具体策略(ConcreteStrategy) 上下文(Context)
  • 55. Java设计模式 Java设计模式10/23/201855策略模式的UML类图
  • 56. Java设计模式 Java设计模式10/23/201856策略模式的结构的描述与使用 1.策略(Strategy) : Computable.java public interface ComputableStrategy{ public abstract double computeScore(double [] a); }
  • 57. Java设计模式 Java设计模式10/23/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/23/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/23/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/23/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/23/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/23/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/23/201863 上下文(Context)和具体策略(ConcreteStrategy)是松耦合关系。因此上下文只知道它要使用某一个实现Strategy接口类的实例,但不需要知道具体是哪一个类。 策略模式满足“开-闭原则”。当增加新的具体策略时,不需要修改上下文类的代码,上下文就可以引用新的具体策略的实例。
  • 64. 第八章 适配器模式 Java设计模式 Java设计模式10/23/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/23/201865 适配器模式是将一个类的接口(被适配者)转换成客户希望的另外一个接口(目标)的成熟模式,该模式中涉及有目标、被适配者和适配器。适配器模式的关键是建立一个适配器,这个适配器实现了目标接口并包含有被适配者的引用。
  • 66. 实例 Java设计模式 Java设计模式10/23/201866 用户已有一个两相的插座,但最近用户又有了一个新的三相插座。用户现在已经有一台洗衣机和一台电视机,洗衣机按着三相插座的标准配有三相插头,而电视机按着两相插座的标准配有两相插头。现在用户想用新的三相插座来使用洗衣机和电视机。
  • 67. 二、适配器模式的结构与使用 Java设计模式 Java设计模式10/23/201867模式的结构中包括三种角色: 目标(Target) 被适配者(Adaptee) 适配器(Adapter)
  • 68. Java设计模式 Java设计模式10/23/201868模式的UML类图
  • 69. Java设计模式 Java设计模式10/23/201869模式的结构的描述与使用 1.目标(Target) : ThreeElectricOutlet.java public interface ThreeElectricOutlet{ public abstract void connectElectricCurrent(); }
  • 70. Java设计模式 Java设计模式10/23/201870模式的结构的描述与使用 2.被适配者(Adaptee): TwoElectricOutlet.java public interface TwoElectricOutlet{ public abstract void connectElectricCurrent(); }
  • 71. Java设计模式 Java设计模式10/23/201871模式的结构的描述与使用 3.适配器(Adapter) TreeElectricAdapter.java public class TreeElectricAdapter implements ThreeElectricOutlet{ TwoElectricOutlet outlet; TreeElectricAdapter(TwoElectricOutlet outlet){ this.outlet=outlet; } public void connectElectricCurrent(){ outlet.connectElectricCurrent(); } }
  • 72. Java设计模式 Java设计模式10/23/201872模式的结构的描述与使用 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(); } }
  • 73. Java设计模式 Java设计模式10/23/201873模式的结构的描述与使用 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+"开始洗衣物。"); } }
  • 74. Java设计模式 Java设计模式10/23/201874模式的结构的描述与使用 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+"开始播放节目。"); } }
  • 75. 三、适配器模式的优点 Java设计模式 Java设计模式10/23/201875目标(Target)和被适配者(Adaptee)是完全解耦的关系。 适配器模式满足“开-闭原则”。当添加一个实现Adaptee接口的新类时,不必修改Adapter,Adapter就能对这个新类的实例进行适配。
  • 76. 第九章 责任链模式 Java设计模式 Java设计模式10/23/201876 责任链模式 使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。 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.
  • 77. 一 、 概述 Java设计模式 Java设计模式10/23/201877 责任链模式是使用多个对象处理用户请求的成熟模式,责任链模式的关键是将用户的请求分派给许多对象,这些对象被组织成一个责任链,即每个对象含有后继对象的引用,并要求责任链上的每个对象,如果能处理用户的请求,就做出处理,不再将用户的请求传递给责任链上的下一个对象;如果不能处理用户的请求,就必须将用户的请求传递给责任链上的下一个对象。
  • 78. 一 、 实例 Java设计模式 Java设计模式10/23/201878 用户提交一个人的身份证号码,想知道该人是在北京、上海或者天津居住。
  • 79. 二、责任链模式的结构与使用 Java设计模式 Java设计模式10/23/201879模式的结构中包括两种角色: 处理者(Handler) 具体处理者(ConcreteHandler)
  • 80. Java设计模式 Java设计模式10/23/201880模式的UML类图
  • 81. Java设计模式 Java设计模式10/23/201881模式的结构的描述与使用 1.处理者(Handler): Handler.java public interface Handler{ public abstract void handleRequest(String number); public abstract void setNextHandler(Handler handler); }
  • 82. Java设计模式 Java设计模式10/23/201882模式的结构的描述与使用 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; } }
  • 83. Java设计模式 Java设计模式10/23/201883模式的结构的描述与使用 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; } }
  • 84. Java设计模式 Java设计模式10/23/201884模式的结构的描述与使用 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; } }
  • 85. Java设计模式 Java设计模式10/23/201885模式的结构的描述与使用 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");; } }
  • 86. 三、责任链模式的优点 Java设计模式 Java设计模式10/23/201886责任链中的对象只和自己的后继是低耦合关系,和其他对象毫无关联,这使得编写处理者对象以及创建责任链变得非常容易。 使用责任链的用户不必知道处理者的信息,用户不会知道到底是哪个对象处理了它的请求。
  • 87. 四、应用举例 Java设计模式 Java设计模式10/23/201887设计一个类,该类创建的对象用int型数据计算阶乘,特点是占用内存小,计算速度快; 设计一个类,该类创建的对象用long型数据计算阶乘,特点是能计算更大整数的阶乘; 设计一个类,该类创建的对象用BigInteger型数据计算阶乘,特点是能计算任意大整数的阶乘; 要求用责任链模式将上面的对象组成一个责任链,要求责任链上对象的顺序是:首先使用int型数据计算阶乘的对象,然后是使用long型数据计算阶乘的对象,最后是使用BigInteger对象计算阶乘对象。
  • 88. 第十章 外观模式 Java设计模式 Java设计模式10/23/201888 外观模式 为系统中的一组接口提供一个一致的界面,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.
  • 89. 一 、 概述 Java设计模式 Java设计模式10/23/201889 外观模式是简化用户和子系统进行交互的成熟模式,外观模式的关键是为子系统提供一个称作外观的类,该外观类的实例负责和子系统中类的实例打交道。当用户想要和子系统中的若干个类的实例打交道时,可以代替地和子系统的外观类的实例打交道。
  • 90. 一 、 应用实例 Java设计模式 Java设计模式10/23/201890 邮政系统负责邮寄包裹的子系统包含Check、Weight和Transport类。Check类的实例负责对包裹进行安全检查,Weight类的实例负责根据包裹的重量计算邮资,Transport类的实例负责为包裹选择运输工具。一个要邮寄的包裹的用户如果直接和负责邮寄包裹的子系统的类打交道就会非常不方便。
  • 91. 三 、 应用实例 Java设计模式 Java设计模式10/23/201891 报社的广告系统有三个类CheckWord、Charge和TypeSetting类,各个类的职责如下:CheckWord类负责检查广告内容含有的字符数量;Charge类的实例负责计算费用;TypeSetting的实例负责对广告进行排版。使用外观模式简化用户和上述子系统所进行的交互。
  • 92. 二、外观模式的结构与使用 Java设计模式 Java设计模式10/23/201892模式的结构中包括两种角色: 子系统(Subsystem) 外观(Facade)
  • 93. Java设计模式 Java设计模式10/23/201893模式的UML类图
  • 94. Java设计模式 Java设计模式10/23/201894模式的结构的描述与使用 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; } }
  • 95. Java设计模式 Java设计模式10/23/201895模式的结构的描述与使用 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+"元"); } }
  • 96. Java设计模式 Java设计模式10/23/201896模式的结构的描述与使用 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("********"); } }
  • 97. Java设计模式 Java设计模式10/23/201897模式的结构的描述与使用 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(); } }
  • 98. Java设计模式 Java设计模式10/23/201898模式的结构的描述与使用 3.应用 Application.java public class Application{ public static void main(String args[]){ ClientServerFacade clientFacade; String clientAdvertisement="鹿花牌洗衣机,价格2356元,联系电话:1234567"; clientFacade=new ClientServerFacade(clientAdvertisement); clientFacade.doAdvertisement(); } }
  • 99. 三、外观模式的优点 Java设计模式 Java设计模式10/23/201899使客户和子系统中的类无耦合。 外观只是提供了一个更加简洁的界面,并不影响用户直接使用子系统中的类。 子系统中任何类对其方法的内容进行修改,不影响外观的代码。
  • 100. 三、一个实例 Java设计模式 Java设计模式10/23/2018100设计一个子系统,该子系统有三个类ReadFile、AnalyzeInformation和SaveFile类,各个类的职责如下: ReadFile类的实例可以读取文本文件 AnalyzeInformation类的实例可以从一个文本中删除用户不需要的内容 SaveFile类的实例能将一个文本保存到文本文件
  • 101. 第十一章 迭代器模式 Java设计模式 Java设计模式10/23/2018101 迭代器模式(别名:游标) 提供一种方法顺序访问一个聚合对象中的各个元素,而又不需要暴露该对象的内部表示。 Iterator Pattern (Another Name: Cursor) Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
  • 102. 一 、 概述 Java设计模式 Java设计模式10/23/2018102 迭代器模式是遍历集合的成熟模式,迭代器模式的关键是将遍历集合的任务交给一个称作迭代器的对象。
  • 103. 一 、 一个示例 Java设计模式 Java设计模式10/23/2018103 一栋楼中住着张三、李四、刘武三个人,分别被安排在不同的房间中,张三知道李四的房间,李四知道刘武的房间。假设有一个警察,他并不知道这些人是以什么方式在此居住,只想找到他们,那么警察可以使用一个名字为next()的方法找人,找到一个人的同时立刻让这个人说出他所知道下一个人所在的房间。
  • 104. 二、迭代器模式的结构与使用 Java设计模式 Java设计模式10/23/2018104模式的结构中包括四种角色: 集合(Aggregate): 具体集合(ConcreteAggregate) 迭代器(Iterator) 具体迭代器(ConcreteIterator)
  • 105. Java设计模式 Java设计模式10/23/2018105模式的UML类图
  • 106. Java设计模式 Java设计模式10/23/2018106模式的结构的描述与使用 1.集合(Aggregate) : 在这里我们使用java.util包中的Collection接口作为模式中的集合角色。Java所有的集合都实现了该接口。
  • 107. Java设计模式 Java设计模式10/23/2018107模式的结构的描述与使用 2.具体集合(ConcreteAggregate) : 在这里我们使用java.util包中的HashSet类的实例作为模式中的具体集合角色。
  • 108. Java设计模式 Java设计模式10/23/2018108模式的结构的描述与使用 3.迭代器(Iterator) : 在本问题中,我们使用的迭代器是java.util包中的Itertator接口 。
  • 109. Java设计模式 Java设计模式10/23/2018109模式的结构的描述与使用 4.具体迭代器(ConcreteIterator) HashSet创建的集合可以使用iterator ()方法返回一个实现Iterator接口类的实例,即一个具体迭代器。
  • 110. Java设计模式 Java设计模式10/23/2018110模式的结构的描述与使用 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+"元"); } }
  • 111. Java设计模式 Java设计模式10/23/2018111模式的结构的描述与使用 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; } }
  • 112. 三、迭代器模式的优点 Java设计模式 Java设计模式10/23/2018112用户使用迭代器访问集合中的对象,而不需要知道这些对象在集合中是如何表示及存储的。 用户可以同时使用多个迭代器遍历一个集合。
  • 113. 第十二章 中介者模式 Java设计模式 Java设计模式10/23/2018113中介者模式 用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。 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.
  • 114. 一 、 概述 Java设计模式 Java设计模式10/23/2018114 中介者模式是封装一系列的对象交互的成熟模式,其关键是将对象之间的交互封装在称作中介者的对象中,中介者使各对象不需要显示地相互引用,这些对象只包含中介者的引用。当系统中某个对象需要和系统中另外一个对象交互时,只需将自己的请求通知中介者即可。
  • 115. 一 、 一个实例 Java设计模式 Java设计模式10/23/2018115 古代相互交战的A、B、C三方,想通过一个中介者调停之间的战火。A方委托调停者转达这样的信息是:要求B方归还曾经抢夺的100斤土豆,要求C方归还曾抢夺的20头牛;B方委托调停者转达的信息是:要求A方归还曾经抢夺的10只公鸡,要求C方归还曾抢夺的15匹马;C方委托调停者转达的信息是:要求A方归还曾抢夺的300斤小麦,要求B方曾抢夺的50头牛。
  • 116. 二、中介者模式的结构与使用 Java设计模式 Java设计模式10/23/2018116模式的结构中包括四种角色: 中介者(Mediator) 具体中介者(ConcreteMediator) 同事(Colleague) 具体同事(ConcreteColleague)
  • 117. Java设计模式 Java设计模式10/23/2018117模式的UML类图
  • 118. 实验目的 实验环境 实验内容:类图+Java代码 实验结果:
  • 119. Java设计模式 Java设计模式10/23/2018119模式的结构的描述与使用 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(); }
  • 120. Java设计模式 Java设计模式10/23/2018120模式的结构的描述与使用 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]); } } } }
  • 121. Java设计模式 Java设计模式10/23/2018121模式的结构的描述与使用 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); } }
  • 122. Java设计模式 Java设计模式10/23/2018122模式的结构的描述与使用 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); } }
  • 123. Java设计模式 Java设计模式10/23/2018123模式的结构的描述与使用 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); } }
  • 124. Java设计模式 Java设计模式10/23/2018124模式的结构的描述与使用 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); } }
  • 125. 三、中介者模式的优点 Java设计模式 Java设计模式10/23/2018125可以避免许多的对象为了之间的通信而相互显示引用,不仅系统难于维护,而且也使其他系统难以复用这些对象。 可以通过中介者将原本分布于多个对象之间的交互行为集中在一起。当这些对象之间需要改变之间的通信行为时,只需使用一个具体中介者即可,不必修改各个具体同事的代码,即这些同事可被重用。 具体中介者使得各个具体同事完全解耦,修改任何一个具体同事的代码不会影响到其他同事。 具体中介者集中了同事之间是如何交互的细节,使得系统比较清楚地知道整个系统中的同事是如何交互的。 当一些对象想互相通信,但又无法相互包含对方的引用,那么使用中介者模式就可以使得这些对象互相通信。
  • 126. 中介者模式 Java设计模式 Java设计模式10/23/2018126十字路口的交通信号是人们很熟悉的装置。南北和东西方向的信号分别由一组红、黄、绿的灯构成,这些灯的开、闭变化由一个控制器负责。当一个方向的信号是红灯时,另一个方向时绿灯;当一个方向的信号时绿灯时,另一个方向是红灯;当一个方向的信号是黄灯时,另一个方向时红灯。
  • 127. 第十三章 工厂方法模式 Java设计模式 Java设计模式10/23/2018127 工厂方法模式(别名:虚拟构造) 定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。 Factory Method 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.
  • 128. 一 、 概述 Java设计模式 Java设计模式10/23/2018128 当系统准备为用户提供某个类的子类的实例,又不想让用户代码和该子类形成耦合时,就可以使用工厂方法模式来设计系统。工厂方法模式的关键是在一个接口或抽象类中定义一个抽象方法,该方法返回某个类的子类的实例,该抽象类或接口让其子类或实现该接口的类通过重写这个抽象方法返回某个子类的实例。
  • 129. 一 、 一个实例 Java设计模式 Java设计模式10/23/2018129 假设有三个笔芯,分别是红笔芯、蓝笔芯和黑笔芯。用户希望通过圆珠笔来明确笔芯的颜色。
  • 130. 二、工厂方法模式的结构与使用 Java设计模式 Java设计模式10/23/2018130模式的结构中包括四种角色: 抽象产品(Product) 具体产品(ConcreteProduct) 构造者(Creator) 具体构造者(ConcreteCreator)
  • 131. Java设计模式 Java设计模式10/23/2018131模式的UML类图
  • 132. Java设计模式 Java设计模式10/23/2018132模式的结构的描述与使用 1.抽象产品(Product) : PenCore.java public abstract class PenCore{ String color; public abstract void writeWord(String s); }
  • 133. Java设计模式 Java设计模式10/23/2018133模式的结构的描述与使用 2.具体产品(ConcreteProduct)_1 : RedPenCore.java public class RedPenCore extends PenCore{ RedPenCore(){ color="红色"; } public void writeWord(String s){ System.out.println("写出"+color+"的字:"+s); } }
  • 134. Java设计模式 Java设计模式10/23/2018134模式的结构的描述与使用 2.具体产品(ConcreteProduct)_2 : BluePenCore.java public class BluePenCore extends PenCore{ BluePenCore(){ color="蓝色"; } public void writeWord(String s){ System.out.println("写出"+color+"的字:"+s); } }
  • 135. Java设计模式 Java设计模式10/23/2018135模式的结构的描述与使用 2.具体产品(ConcreteProduct)_3: BlackPenCore.java public class BlackPenCore extends PenCore{ BlackPenCore(){ color="黑色"; } public void writeWord(String s){ System.out.println("写出"+color+"的字:"+s); } }
  • 136. Java设计模式 Java设计模式10/23/2018136模式的结构的描述与使用 3.构造者(Creator):BallPen.java public abstract class BallPen{ BallPen(){ System.out.println("生产了一只装有"+getPenCore().color+"笔芯的圆珠笔"); } public abstract PenCore getPenCore(); //工厂方法 }
  • 137. Java设计模式 Java设计模式10/23/2018137模式的结构的描述与使用 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(); } }
  • 138. Java设计模式 Java设计模式10/23/2018138模式的结构的描述与使用 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"); } }
  • 139. 三、工厂方法模式的优点 Java设计模式 Java设计模式10/23/2018139使用工厂方法可以让用户的代码和某个特定类的子类的代码解耦。 工厂方法使用户不必知道它所使用的对象是怎样被创建的,只需知道该对象有哪些方法即可。
  • 140. 三、一个实例 Java设计模式 Java设计模式10/23/2018140 创建药品对象:系统设计了一个抽象类Drug,该抽象类特别规定了所创建的药品必须给出药品的成分及其含量。Drug目前有两个子类:Paracetamol和Amorolfine。 Paracetamol子类负责创建氨加黄敏一类的药品, Amorolfine子类负责创建盐酸阿莫罗分一类的药品。 一个为某药店开发的应用程序需要使用Drug类的某个子类的实例为用户提供药品。但是药店的应用程序不能使用Drug的子类的构造方法直接创建对象,因为药店没有能力给出药品的各个成分的含量,只有药厂才有这样的能力。
  • 141. 第十四章 抽象工厂模式 Java设计模式 Java设计模式10/23/2018141 抽象工厂模式(别名:配套) 提供一个创建一系列(相互依赖)对象的接口,而无需指定它们具体的类。 Abstract Factory Pattern(Another Name:Kit) Provide an interface for creating families of related or dependent objects without specifying their concrete classes.
  • 142. 一 、 概述 Java设计模式 Java设计模式10/23/2018142 当系统准备为用户提供一系列相关的对象,又不想让用户代码和创建这些对象的类形成耦合时,就可以使用抽象工厂方法模式来设计系统。抽象工厂模式的关键是在一个抽象类或接口中定义若干个抽象方法,这些抽象方法分别返回某个类的实例,该抽象类或接口让其子类或实现该接口的类重写这些抽象方法,为用户提供一系列相关的对象。
  • 143. 一 、 一个实例 Java设计模式 Java设计模式10/23/2018143 建立一个系统,该系统可以为用户提供西服套装(上衣+裤子)和牛仔套装(上衣+裤子)。
  • 144. 二、抽象工厂模式的结构与使用 Java设计模式 Java设计模式10/23/2018144模式的结构中包括四种角色: 抽象产品(Prodcut) 具体产品(ConcreteProduct) 抽象工厂(AbstractFactory) 具体工厂(ConcreteFactory)
  • 145. Java设计模式 Java设计模式10/23/2018145模式的UML类图
  • 146. Java设计模式 Java设计模式10/23/2018146模式的结构的描述与使用 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(); }
  • 147. Java设计模式 Java设计模式10/23/2018147模式的结构的描述与使用 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; } }
  • 148. Java设计模式 Java设计模式10/23/2018148模式的结构的描述与使用 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; } }
  • 149. Java设计模式 Java设计模式10/23/2018149模式的结构的描述与使用 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; } }
  • 150. Java设计模式 Java设计模式10/23/2018150模式的结构的描述与使用 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; } }
  • 151. Java设计模式 Java设计模式10/23/2018151模式的结构的描述与使用 3.抽象工厂(AbstractFactory):ClothesFactory.java public abstract class ClothesFactory{ public abstract UpperClothes createUpperClothes(int chestSize,int height); public abstract Trousers createTrousers(int waistSize,int height); }
  • 152. Java设计模式 Java设计模式10/23/2018152模式的结构的描述与使用 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); } }
  • 153. Java设计模式 Java设计模式10/23/2018153模式的结构的描述与使用 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()); } }
  • 154. Java设计模式 Java设计模式10/23/2018154模式的结构的描述与使用 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); } }
  • 155. 三、抽象工厂模式的优点 Java设计模式 Java设计模式10/23/2018155抽象工厂模式可以为用户创建一系列相关的对象,使得用户和创建这些对象的类脱耦。 使用抽象工厂模式可以方便的为用户配置一系列对象。用户使用不同的具体工厂就能得到一组相关的对象,同时也能避免用户混用不同系列中的对象。 在抽象工厂模式中,可以随时增加“具体工厂”为用户提供一组相关的对象。
  • 156. 一 、 一个实例 Java设计模式 Java设计模式10/23/2018156 军队要为士兵提供机关枪、手枪以及相应的子弹,但军队系统不希望由士兵(用户)来生产机关枪、手枪及相应的子弹,而是应当有专门的的工厂负责配套生产,即有一个专门负责生产机关枪、机关枪子弹的工厂和一个专门负责生产手枪、手枪子弹的工厂。
  • 157. 第十五章 生成器模式 Java设计模式 Java设计模式10/23/2018157 生成器模式 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 Builder Pattern Separate the construction of a complex object from its representation so that the same construction process can create different representations.
  • 158. 一 、 概述 Java设计模式 Java设计模式10/23/2018158 当系统准备为用户提供一个内部结构复杂的对象时,就可以使用生成器模式,使用该模式可以逐步地构造对象,使得对象的创建更具弹性。生成器模式的关键是将一个包含有多个组件对象的创建分成若干个步骤,并将这些步骤封装在一个称作生成器的接口中。
  • 159. 一 、 一个实例 Java设计模式 Java设计模式10/23/2018159 创建含有按钮、标签和文本框组件的容器。不同用户对容器有不同的要求,比如某些用户希望容器中只含有按钮和标签,某些用户希望容器只含有按钮和文本框等。另外用户对组件在容器中的顺序位置也有不同的要求,比如某些用户要求组件在容器中从左至右的排列顺序是按钮、标签、文本框,而某些用户要求从左至右的排序时标签、文本框、按钮。
  • 160. 二、生成器模式的结构与使用 Java设计模式 Java设计模式10/23/2018160模式的结构中包括四种角色: 产品(Product) 抽象生成器(Builder) 具体生成器(ConcreteBuilder) 指挥者(Director)
  • 161. Java设计模式 Java设计模式10/23/2018161模式的UML类图
  • 162. Java设计模式 Java设计模式10/23/2018162模式的结构的描述与使用 1.产品(Product): PanelProduct.java import javax.swing.*; public class PanelProduct extends JPanel{ JButton button; JLabel label; JTextField textField; }
  • 163. Java设计模式 Java设计模式10/23/2018163模式的结构的描述与使用 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(); }
  • 164. Java设计模式 Java设计模式10/23/2018164模式的结构的描述与使用 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(){ } public JPanel getPanel(){ panel.add(panel.button); panel.add(panel.label); return panel; } }
  • 165. Java设计模式 Java设计模式10/23/2018165模式的结构的描述与使用 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(){ } public void buildTextField(){ panel.textField=new JTextField("textField"); } public JPanel getPanel(){ panel.add(panel.textField); panel.add(panel.button); return panel; } }
  • 166. Java设计模式 Java设计模式10/23/2018166模式的结构的描述与使用 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; } }
  • 167. Java设计模式 Java设计模式10/23/2018167模式的结构的描述与使用 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); } }
  • 168. 三、生成器模式的优点 Java设计模式 Java设计模式10/23/2018168生成器模式将对象的构造过程封装在具体生成器中,用户使用不同的具体生成器就可以得到该对象的不同表示。 可以更加精细有效地控制对象的构造过程。生成器将对象的构造过程分解成若干步骤,这就使得程序可以更加精细,有效地控制整个对象的构造。 生成器模式将对象的构造过程与创建该对象类解耦,使得对象的创建更加灵活有弹性。 当增加新的具体生成器时,不必修改指挥者的代码,即该模式满足开-闭原则。
  • 169. 三、一个实例 Java设计模式 Java设计模式10/23/2018169Geometry由三角形、长方形和圆形构成的。有时候用户不需要Geometry类所创建的对象含有其全部组件,即不希望当前图形实例化它含有的全部组件;用户对所创建的图形对象中的组件有特殊的要求:三角形是等边的,长方形是正方的等。
  • 170. 第十六章 原型模式 Java设计模式 Java设计模式10/23/2018170 原型模式 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。 Prototype Pattern Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.
  • 171. 第十六章 原型模式 Java设计模式 Java设计模式10/23/2018171java.lang.Object类的clone方法 1.clone()方法:protected[必须位于java.lang包中],用于复制对象。 2.clone()方法的重写:super.clone(),public; 3.Cloneable接口:
  • 172. 第十六章 原型模式 Java设计模式 Java设计模式10/23/2018172class Circle implements Cloneable{ private double radius; public void setRadius(double r){ radius=r; } public double getRadius(){ return radius; } public Object clone() throws CloneNotSupportException{ object object=super.clone(); return object; } }
  • 173. 第十六章 原型模式 Java设计模式 Java设计模式10/23/2018173Public class Example{ public static void main(String args[]){ Circle circle=new Circle(); circle.setRadius(198.99); try{ Circle circleCopy=(Circle)circle.clone(); System.out.println(“circle对象中的数据:”+circle.getRadius()); System.out.println(“circleCopy对象中的数据:”+circle.getRadius();) }catch(CloneNotSupportedException exp){} }
  • 174. 第十六章 原型模式 Java设计模式 Java设计模式10/23/2018174Ox12310052898objectxyOx78910052898cloneobjectxyOx1230x552898objectrectangleheightOx78910052898cloneobjectrectangleheight10052898mn?
  • 175. 一 、 概述 Java设计模式 Java设计模式10/23/2018175 原型模式是从一个对象出发得到一个和自己有相同状态的新对象的成熟模式,该模式的关键是将一个对象定义为原型,并为其提供复制自己的方法。
  • 176. 二、原型模式的结构与使用 Java设计模式 Java设计模式10/23/2018176模式的结构中包括两种角色: 抽象原型(Prototype) 具体原型(Concrete Prototype)
  • 177. Java设计模式 Java设计模式10/23/2018177模式的UML类图
  • 178. Java设计模式 Java设计模式10/23/2018178模式的结构的描述与使用 1.抽象原型(Prototype): Prototype.java public interface Prototype { public Object cloneMe() throws CloneNotSupportedException,; }
  • 179. Java设计模式 Java设计模式10/23/2018179模式的结构的描述与使用 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; } }
  • 180. Java设计模式 Java设计模式10/23/2018180模式的结构的描述与使用 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; } }
  • 181. Java设计模式 Java设计模式10/23/2018181模式的结构的描述与使用 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){} } }
  • 182. 三、原型模式的优点 Java设计模式 Java设计模式10/23/2018182当创建类的新实例的代价更大时,使用原型模式复制一个已有的实例可以提高创建新实例的效率。 可以动态地保存当前对象的状态。在运行时刻,可以随时使用对象流保存当前对象的一个复制品。
  • 183. 第十七章 单件模式 Java设计模式 Java设计模式10/23/2018183 单件模式 保证一个类仅有一个实例,并提供一个访问它的全局访问点。 Prototype Pattern Ensure a class only has one instance, and provide a global point of access to it.
  • 184. 一 、 概述 Java设计模式 Java设计模式10/23/2018184 单件模式是关于怎样设计一个类,并使得该类只有一个实例的成熟模式,该模式的关键是将类的构造方法设置为private权限,并提供一个返回它的唯一实例的类方法。
  • 185. 二、单件模式的结构与使用 Java设计模式 Java设计模式10/23/2018185模式的结构中只包括一个角色: 单件类(Singleton)
  • 186. Java设计模式 Java设计模式10/23/2018186模式的UML类图
  • 187. Java设计模式 Java设计模式10/23/2018187模式的结构的描述与使用 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; } }
  • 188. Java设计模式 Java设计模式10/23/2018188模式的结构的描述与使用 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); } }
  • 189. 三、单件模式的优点 Java设计模式 Java设计模式10/23/2018189单件类的唯一实例由单件类本身来控制,所以可以很好地控制用户何时访问它。
  • 190. 第十八章 组合模式 Java设计模式 Java设计模式10/23/2018190 组合模式 将对象组合成数形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。 Composite Pattern Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.
  • 191. 一 、 概述 Java设计模式 Java设计模式10/23/2018191 组合模式是关于怎样将对象形成树形结构来表现整体和部分的层次结构的成熟模式。使用组合模式,可以让用户以一致的方式处理个体对象和组合对象,组合模式的关键在于无论是个体对象还是组合对象都实现了相同的接口或都是同一个抽象类的子类。
  • 192. 二、组合模式的结构与使用 Java设计模式 Java设计模式10/23/2018192模式的结构中包括三种角色: 抽象组件(Component) Composite节点(Composite Node) Leaf节点(Leaf Node)
  • 193. Java设计模式 Java设计模式10/23/2018193模式的UML类图
  • 194. Java设计模式 Java设计模式10/23/2018194模式的结构的描述与使用 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); }
  • 195. Java设计模式 Java设计模式10/23/2018195模式的结构的描述与使用 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; } }
  • 196. Java设计模式 Java设计模式10/23/2018196模式的结构的描述与使用 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; } }
  • 197. Java设计模式 Java设计模式10/23/2018197模式的结构的描述与使用 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; } }
  • 198. Java设计模式 Java设计模式10/23/2018198模式的结构的描述与使用 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(连长)); } }
  • 199. 三、组合模式的优点 Java设计模式 Java设计模式10/23/2018199组合模式中包含有个体对象和组合对象,并形成树形结构,使用户可以方便地处理个体对象和组合对象。 组合对象和个体对象实现了相同的接口,用户一般不需区分个体对象和组合对象。 当增加新的Composite节点和Leaf节点时,用户的重要代码不需要作出修改。
  • 200. 第十九章 桥接模式 Java设计模式 Java设计模式10/23/2018200 桥接模式(别名:柄体模式) 将抽象部分与它的实现部分分离,使得它们都可以独立地变化。 Bridge Pattern(Another Name: Handle-Body) Decouple an abstraction from its implementation so that the two can vary independently.
  • 201. 一 、 概述 Java设计模式 Java设计模式10/23/2018201 桥接模式是关于怎样将抽象部分与它的实现部分分离,使得它们都可以独立地变化的成熟模式。
  • 202. 二、桥接模式的结构与使用 Java设计模式 Java设计模式10/23/2018202模式的结构中包括四种角色: 抽象(Abstraction) 实现者(Implementor) 细化抽象(Refined Abstraction) 具体实现者(Concrete Implementor)
  • 203. Java设计模式 Java设计模式10/23/2018203模式的UML类图
  • 204. Java设计模式 Java设计模式10/23/2018204模式的结构的描述与使用 1.抽象(Abstraction): ArchitectureCose.java public abstract class ArchitectureCost{ BuildingDesign design; double unitPrice; public abstract double giveCost() ; }
  • 205. Java设计模式 Java设计模式10/23/2018205模式的结构的描述与使用 2.实现者(Implementor) : BuildingDesign.java public interface BuildingDesign{ public double computerArea(); }
  • 206. Java设计模式 Java设计模式10/23/2018206模式的结构的描述与使用 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; } }
  • 207. Java设计模式 Java设计模式10/23/2018207模式的结构的描述与使用 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; } }
  • 208. Java设计模式 Java设计模式10/23/2018208模式的结构的描述与使用 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); } }
  • 209. 三、桥接模式的优点 Java设计模式 Java设计模式10/23/2018209桥接模式分离实现与抽象,使得抽象和实现可以独立的扩展。当修改实现的代码时,不影响抽象的代码,反之也一样。比如,对于19.2.2中的例子,如果具体实现者HouseDesign类决定将面积的计算加上一个额外的值,即修改了computerArea()方法,那么并不影响到细化抽象者的代码,反之,如果抽象者决定增加一个参与计算的参数:adjust,即细化抽象者修改代码,在计算成本时通过设置该参数的值来计算成本,那么并不影响实现着者的代码。 满足开闭-原则。抽象和实现者处于同层次,使得系统可独立地扩展这两个层次。增加新的具体实现者,不需要修改细化抽象,反之增加新的细化抽象也不需要修改具体实现。
  • 210. 第二十章 状态模式 Java设计模式 Java设计模式10/23/2018210 状态模式(别名:状态对象) 允许一个对象在其内部状态改变时改变它的行为。 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.
  • 211. 一 、 概述 Java设计模式 Java设计模式10/23/2018211 一个对象的状态依赖于它的成员变量的取值情况。对象在不同的运行环境或运行时刻,可能具有不同的状态。在许多情况下,对象调用方法所产生的行为效果依赖于它当时的状态。 状态模式的关键是将对象的状态封装成为独立的类,对象调用方法时,可以委托当前对象所具有的状态(对象)调用相应的方法,使得当前对象看起来好像修改了它的类。
  • 212. 一 、 一个实例 Java设计模式 Java设计模式10/23/2018212class Thermometer{//温度计类 double temputer; public void showMessage(){ if( temperature<=-20 ) System.out.println(“现在温度是:”+temputer); else(temperature>=30) System.out.println(“现在温度是:”+temputer); } }//如果用户要求temperature>60……?//分离对象状态
  • 213. 二、状态模式的结构与使用 Java设计模式 Java设计模式10/23/2018213模式的结构中包括三种角色: 环境(Context) 抽象状态(State) 具体状态(Concrete State)
  • 214. Java设计模式 Java设计模式10/23/2018214模式的UML类图
  • 215. Java设计模式 Java设计模式10/23/2018215模式的结构的描述与使用 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; } }
  • 216. Java设计模式 Java设计模式10/23/2018216模式的结构的描述与使用 2.抽象状态(State): TemperatureState.java public interface TemperatureState{ public void showTemperature(); }
  • 217. Java设计模式 Java设计模式10/23/2018217模式的结构的描述与使用 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+"属于低温度"); } }
  • 218. Java设计模式 Java设计模式10/23/2018218模式的结构的描述与使用 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+"属于正常温度"); } }
  • 219. Java设计模式 Java设计模式10/23/2018219模式的结构的描述与使用 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+"属于高温度"); } }
  • 220. Java设计模式 Java设计模式10/23/2018220模式的结构的描述与使用 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(); } }
  • 221. 二、 状态切换 Java设计模式 Java设计模式10/23/2018221一个使用弹夹大小为3颗子弹的手枪通过更换弹夹重新获取子弹。使用弹夹的大小位3颗子弹的手枪共有4种状态:有3颗子弹,有2颗子弹,有1颗子弹,没有子弹。手枪只有在有子弹的状态下可以调用fire()方法进行射击,只有在没有子弹的状态下可以调用LoadBullet()方法装载新弹夹获得子弹。需要注意的是,手枪调用fire()方法和LoadBullet()都会导致手枪的状态发生变换。有3颗子弹有2颗子弹有1颗子弹没有子弹fire()fire()fire()LoadBullet()
  • 222. 二、 状态切换 Java设计模式 Java设计模式10/23/20182221.环境(Context): Gun.java public class Gun{ State stateThree,stateTwo,stateOne,stateNull,state; public void Gun(){ stateThree=new BulletStateThree(this); stateTwo=new BulletStateTwo(this); stateOne=new BulletStateOne(this); stateNull=new BulletStateNull(this); state=stateThree; } public void setState(State state){ this.state=state; }
  • 223. 二、 状态切换 Java设计模式 Java设计模式10/23/20182231.环境(Context): Gun.java public void fire(){state.fire();} public void State getBulletStateThree(){ return stateThree;} public void State getBulletStateTwo(){ return stateTwo;} public void State getBulletStateOne(){ return stateOne;} public void State getBulletStateNull(){ return stateNull;}
  • 224. 二、 状态切换 Java设计模式 Java设计模式10/23/20182242.抽象状态(State): State.java public interface State{ public void fire(); public void LoadBullet(); public String showStateMess(); }
  • 225. 二、 状态切换 Java设计模式 Java设计模式10/23/20182253.具体状态(Concrete State)_1:BulletStateThree.java public class BulletStateThree implements State{ Gun gun; BulletStateThree(Gun gun){this.gun=gun;} public void fire(){ System.out.print(“打出一个子弹”); · gun.setState(gun.getBulletStateTwo());//new BulletStateTwo()? public void loadBullet(){System.out.println(“无法装弹”);} public String showStateMess(){return “2个子弹状态”;} }
  • 226. 二、 状态切换 Java设计模式 Java设计模式10/23/20182263.具体状态(Concrete State)_2:BulletStateTwo.java public class BulletStateTwo implements State{ Gun gun; BulletStateThree(Gun gun){this.gun=gun;} public void fire(){ System.out.print(“打出1个子弹”); · gun.setState(gun.getBulletStateOne()); public void loadBullet(){System.out.println(“无法装弹”);} public String showStateMess(){return “1个子弹状态”;} }
  • 227. 二、 状态切换 Java设计模式 Java设计模式10/23/20182273.具体状态(Concrete State)_1:BulletStateOne.java public class BulletStateTwo implements State{ Gun gun; BulletStateOne(Gun gun){this.gun=gun;} public void fire(){ System.out.print(“打出1个子弹”); · gun.setState(gun.getBulletStateNull()); public void loadBullet(){System.out.println(“无法装弹”);} public String showStateMess(){return “1个子弹状态”;} }
  • 228. 二、 状态切换 Java设计模式 Java设计模式10/23/20182283.具体状态(Concrete State)_1:BulletStateNull.java public class BulletStateTwo implements State{ Gun gun; BulletStateOne(Gun gun){this.gun=gun;} public void fire(){System.out.print(“不能打出子弹”);} · gun.setState(gun.getBulletStateNull()); public void loadBullet(){ System.out.println(“装弹”); gun.setState(gun.getBulletStateThree());} public String showStateMess(){return “无子弹状态”;} }
  • 229. 二、 状态切换 Java设计模式 Java设计模式10/23/20182293.Application: Application.java public class Application { public static void main(String args[]){ Gun gun=new Gun(); gun.fire(); gun.fire(); gun.fire(); gun.fire(); gun.LoadBullet(); } }
  • 230. 三、 共享状态 Java设计模式 Java设计模式10/23/2018230一列客运列车的卧铺车厢和普通车厢共享运动和静止状态,车厢可以由静止状态切换到运行状态,也可以由运行状态切换到静止状态,当卧铺车厢从运动状态切换到静止状态候,普通车厢自然也是静止状态,反之亦然。
  • 231. 二、 状态切换 Java设计模式 Java设计模式10/23/20182311.Vehicle: Vehicle.java public class Vehicle { static State state,moveState,restState; String name; Vehicle(String name){ this.name=name;moveState=new VehicleMoveState(); restState=new VehicleRestState();state=restState;} public void startUp(){state.startUp(this);} public void stop(){state.stop(this);} public void setState(State state){this.state=state;} public State getMoveState(){return moveState;} public State getRestState(){return restState;} public String getName(){return name;} }
  • 232. 二、 状态切换 Java设计模式 Java设计模式10/23/20182322.抽象状态(State): State.java public interface State{ public void startUp( Vehicle vehicle); public void stop(Vehicle vehicle); }
  • 233. 二、 状态切换 Java设计模式 Java设计模式10/23/20182333.具体状态(Concrete State)_1:VehicleMoveState.java public class VehicleMoveState extends State{ public void startUp(Vehicle vehicle){ System.out.println(vehicle.getName()+”已经处于运动状态了”);} public void stop(Vehicle vehicle){ System.out.println(vehicle.getName()+”停止运动”); vehicle.setState(vehicle.getRestState());} }
  • 234. 二、 状态切换 Java设计模式 Java设计模式10/23/20182343.具体状态(Concrete State)_1:VehicleRestState.java public class VehicleRestState extends State{ public void stop(Vehicle vehicle){ System.out.println(vehicle.getName()+”已经处于静止状态了”);} public void startUp (Vehicle vehicle){ System.out.println(vehicle.getName()+”开始运动”); vehicle.setState(vehicle.getMoveState());} }
  • 235. 二、 状态切换 Java设计模式 Java设计模式10/23/20182353.Application: Application.java public class Application { public static void main(String args[]){ Vehicle carOne=new Vehicle(“卧铺车厢”); Vehicle carTwo=new Vehicle(“普通车厢”); carOne.startUp();carTwo.startUp(); carTwo.stop();carOne.stop(); } }
  • 236. 三、状态模式的优点 Java设计模式 Java设计模式10/23/2018236使用一个类封装对象的一种状态,很容易增加新的状态。 在状态模式中,环境(context)中不必出现大量的条件判断语句。环境(context)实例所呈现的状态变得更加清晰、容易理解。 使用状态模式可以让用户程序很方便的切换环境(context)实例的状态。 使用状态模式不会让环境(context)的实例中出现内部状态不一致的情况。 当状态对象没有实例变量时,环境(context)的各个实例可以共x享一个状态对象。
  • 237. 四、一个实例 Java设计模式 Java设计模式10/23/2018237咖啡自动售货机共有三种状态,分别是:有咖啡,无人投币;有咖啡,有人投币;无咖啡。咖啡自动售货机有两个方法:showMessage()和giveAnCupCaffee()。 咖啡自动售货机的默认状态是:有咖啡,无人投币。当售货机处于有咖啡,无人投币状态时,调用showMessage()方法将显示“请您投入一元硬币”;当用户投入一元硬币后,咖啡自动售货机将处于有咖啡,有人投币的状态。此时调用giveAnCupCaffee()方法,用户将得到一杯咖啡。然后咖啡自动售货机将处于有咖啡无人投币状态或无咖啡状态;当咖啡自动售货机处于无咖啡或有咖啡无人投币状态时,调用giveAnCupCaffee()方法不会得到咖啡。
  • 238. 第二十一章 模板方法模式 Java设计模式 Java设计模式10/23/2018238模板方法模式 定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 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.
  • 239. 一 、 概述 Java设计模式 Java设计模式10/23/2018239 模板方法是关于怎样将若干个方法集成到一个方法中,以便形成一个解决问题的算法骨架。模板方法模式的关键是在一个抽象类中定义一个算法的骨架,即将若干个方法集成到一个方法中,并称该方法为一个模板方法,或简称为模板。
  • 240. 一 、 实例 Java设计模式 Java设计模式10/23/2018240 显示某个目录下全部文件的名字,比如可以按文件的大小顺序、按最后修改的时间顺序或按文件名字的字典顺序来显示某个子目录下全部文件的名字。
  • 241. 二、模板方法模式的结构与使用 Java设计模式 Java设计模式10/23/2018241模式的结构中包括两种角色: 抽象模板(Abstract Template) 具体模板(Concrete Template)
  • 242. Java设计模式 Java设计模式10/23/2018242模式的UML类图
  • 243. Java设计模式 Java设计模式10/23/2018243模式的结构的描述与使用 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(); }
  • 244. Java设计模式 Java设计模式10/23/2018244模式的结构的描述与使用 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
  • 245. Java设计模式 Java设计模式10/23/2018245模式的结构的描述与使用 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
  • 246. Java设计模式 Java设计模式10/23/2018246模式的结构的描述与使用 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(); } }
  • 247. Java设计模式 Java设计模式10/23/2018247钩子方法钩子方法是抽象模板中定义的具体方法,但给出了空实现或默认的实现,并允许子类重写这个具体方法,否则应用final修饰。 某些钩子方法的作用是对模板方法中的某些步骤进行“挂钩”,即允许具体模板对算法的不同点进行“挂钩”,以确定在什么条件下执行模板方法中的哪些算法步骤,因此这类钩子方法的类型一般是boolean类型。另外一类钩子方法不是用来挂钩的,对于void类型的钩子方法,其默认实现一般为空,具体模板可以根据需要直接继承这样的钩子方法或重写这样的钩子方法。
  • 248. Java设计模式 Java设计模式10/23/2018248实例按下列步骤统计英文文本文件中的单词数量: 读文件的内容; 统计出文件内容中的全部单词; 将单词按着某种顺序排序,比如按字典顺序或单词的长度排序,但允许具体模板对排序挂钩,即具体模板可以对单词排序也可以不对单词进行排序。 输出全部单词
  • 249. Java设计模式 Java设计模式10/23/2018249实例public abstract class WordsTemplate{ File file; String content; String[] word; WordsTemplate(File file){this.file=file;content=“”;} public final void showAllWords(){ readContent();getWords();if(isSort())=sort(word);printWords(word);} public boolean isSort(){return true;} public final void readContent(){} public final void getWords(){} public void sort(String[] word){} public final void PrintWords(String[] word){} }
  • 250. Java设计模式 Java设计模式10/23/2018250实例Public class WordSortTemplate extends WordsTeplate{ WordSortTemplate(File file){super(file);} Public void sort(String[] word){Arrays.sort(word);} } Public class WordSortTemplate extends WordsTeplate{ WordSortTemplate(File file){super(file);} Public booelan isSort(){return false;} }
  • 251. 三、模板方法模式的优点 Java设计模式 Java设计模式10/23/2018251可以通过在抽象模板定义模板方法给出成熟的算法步骤,同时又不限制步骤的细节,具体模板实现算法细节不会改变整个算法的骨架。 在抽象模板模式中,可以通过钩子方法对某些步骤进行挂钩,具体模板通过钩子可以选择算法骨架中的某些步骤。
  • 252. 第二十二章 代理模式 Java设计模式 Java设计模式10/23/2018252 代理模式 为其他对象提供一种代理以控制对这个对象的访问。 Proxy Pattern Provide a surrogate or placeholder for another object to control access to it.
  • 253. 一 、 概述 Java设计模式 Java设计模式10/23/2018253 代理模式是为对象提供一个代理,代理可以控制对它所代理的对象的访问。 用户输入三个代表三角形三边长度的数值,代理对象验证用户输入的三个数值是否能构成三角形,如果能构成三角形,就创建一个三角形对象,并让三角形对象计算自身的面积。
  • 254. 二、代理模式的结构与使用 Java设计模式 Java设计模式10/23/2018254模式的结构中包括三种角色: 抽象主题(Subject) 实际主题(RealSubject) 代理(Proxy)
  • 255. Java设计模式 Java设计模式10/23/2018255模式的UML类图
  • 256. Java设计模式 Java设计模式10/23/2018256模式的结构的描述与使用 1.抽象主题(Subject): Geometry.java public interface Geometry{ public double getArea(); }
  • 257. Java设计模式 Java设计模式10/23/2018257模式的结构的描述与使用 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; } }
  • 258. Java设计模式 Java设计模式10/23/2018258模式的结构的描述与使用 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; } }
  • 259. Java设计模式 Java设计模式10/23/2018259模式的结构的描述与使用 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); } }
  • 260. 三、代理模式的优点 Java设计模式 Java设计模式10/23/2018260代理模式可以屏蔽用户真正请求的对象,使用户程序和真正的对象之间解耦。 使用代理来担当那些创建耗时的对象的替身。
  • 261. 第二十三章 享元模式 Java设计模式 Java设计模式10/23/2018261 享元模式 运用共享技术有效地支持大量细粒度的对象。 Flyweight Pattern Use sharing to support large numbers of fine-grained objects efficiently.
  • 262. 一 、 概述 Java设计模式 Java设计模式10/23/2018262 一个类中的成员变量表明该类所创建的对象所具有的属性,在某些程序设计中我们可能用一个类创建若干个对象,但是我们发现这些对象的一个共同特点是它们有一部分属性的取值必须是完全相同的。
  • 263. 二、享元模式的结构与使用 Java设计模式 Java设计模式10/23/2018263模式的结构中包括三种角色: 享元接口(Flyweight) 具体享元(Concrete Flyweight) 享元工厂(Flyweight Factory)
  • 264. Java设计模式 Java设计模式10/23/2018264模式的UML类图
  • 265. Java设计模式 Java设计模式10/23/2018265模式的结构的描述与使用 1.享元接口(Flyweight): Flyweight.java public interface Flyweight{ public double getHeight(); public double getWidth(); public double getLength(); public void printMess(String mess); }
  • 266. Java设计模式 Java设计模式10/23/2018266模式的结构的描述与使用 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; } }
  • 267. Java设计模式 Java设计模式10/23/2018267模式的结构的描述与使用 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); } } }
  • 268. Java设计模式 Java设计模式10/23/2018268模式的结构的描述与使用 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()); } }
  • 269. Java设计模式 Java设计模式10/23/2018269模式的结构的描述与使用 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"); } }
  • 270. 三、享元模式的优点 Java设计模式 Java设计模式10/23/2018270使用享元可以节省内存的开销,特别适合处理大量细粒度对象,这些对象的许多属性值是相同的,而且一旦创建则不容许修改。 享元模式中的享元可以使用方法的参数接受外部状态中的数据,但外部状态数据不会干扰到享元中的内部数据,这就使得享元可以在不同的环境中被共享。
  • 271. 第二十四章 访问者模式 Java设计模式 Java设计模式10/23/2018271访问者模式 表示一个作用于某对象结构中的各个元素的操作。它使你可以在不改变各个元素的类的前提下定义作用于这些元素的新操作。 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.
  • 272. 一 、 概述 Java设计模式 Java设计模式10/23/2018272 当一个集合中有若干个对象时,习惯上将这些对象称作集合中的元素,访问者模式可以使得我们在不改变集合中各个元素的类的前提下定义作用于这些元素上的新操作。 公司考核若干大学生和研究生,以决定是否录用。大学生和研究生都有自己的成绩,但是他们不能依据自己的成绩制定录用标准,录用标准由公司确定。
  • 273. 二、访问者模式的结构与使用 Java设计模式 Java设计模式10/23/2018273模式的结构中包括五种角色: 抽象元素(Element) 具体元素(Concrete Element) 对象结构(Object Structure) 抽象访问者(Visitor) 具体访问者(Concrete Visitor)
  • 274. Java设计模式 Java设计模式10/23/2018274模式的UML类图
  • 275. Java设计模式 Java设计模式10/23/2018275模式的结构的描述与使用 1.抽象元素(Element): Student.java public abstract class Student{ public abstract void accept(Visitor v); }
  • 276. Java设计模式 Java设计模式10/23/2018276模式的结构的描述与使用 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); } }
  • 277. Java设计模式 Java设计模式10/23/2018277模式的结构的描述与使用 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); } }
  • 278. Java设计模式 Java设计模式10/23/2018278模式的结构的描述与使用 3.对象结构(Object Structure) 本问题中,我们让该角色是java.util包中的ArrayList集合。
  • 279. Java设计模式 Java设计模式10/23/2018279模式的结构的描述与使用 4.抽象访问者(Visitor): Visitor.java public interface Visitor{ public void visit(Undergraduate stu); public void visit(GraduateStudent stu); }
  • 280. Java设计模式 Java设计模式10/23/2018280模式的结构的描述与使用 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()+"被录用"); } }
  • 281. Java设计模式 Java设计模式10/23/2018281模式的结构的描述与使用 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); } } }
  • 282. 三、访问者模式的优点 Java设计模式 Java设计模式10/23/2018282可以在不改变一个集合中的元素的类的情况下,增加新的施加于该元素上的新操作。 可以将集合中各个元素的某些操作集中到访问者中,不仅便于集合的维护,也有利于集合中元素的复用。
  • 283. 四、一个实例 Java设计模式 Java设计模式10/23/2018283有若干人员的体检表,每张体检表记载着和某个人有关的体检数据。但是体检表本身不可以使用一个方法来标明其中的这些数据是否符合某个行业的体检标准。现在假设有军队的一个负责人和工厂的一个负责人,他两分别审阅体检表,并标明体检表中的数据是否符合作为军人或者工人的体检标准。
  • 284. (本页无文本内容)
  • 285. 第二十五章 备忘录模式 Java设计模式 Java设计模式10/23/2018285 备忘录模式(别名:标记) 在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样以后就可将该对象恢复到原先保存的状态。 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.
  • 286. 一 、 概述 Java设计模式 Java设计模式10/23/2018286 备忘录模式是关于怎样保存对象状态的成熟模式,其关键是提供一个备忘录对象,该备忘录负责存储一个对象的状态,程序可以在磁盘或内存中保存这个备忘录,这样一来,程序就可以根据对象的备忘录将该对象恢复到备忘录中所存储的状态。
  • 287. 二、备忘录模式的结构与使用 Java设计模式 Java设计模式10/23/2018287模式的结构中包括三种角色: 原发者(Originator) 备忘录(Memento) 负责人(Caretaker)
  • 288. Java设计模式 Java设计模式10/23/2018288模式的UML类图
  • 289. Java设计模式 Java设计模式10/23/2018289模式的结构的描述与使用 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){ } } }
  • 290. Java设计模式 Java设计模式10/23/2018290模式的结构的描述与使用 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; } }
  • 291. Java设计模式 Java设计模式10/23/2018291模式的结构的描述与使用 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){} } }
  • 292. Java设计模式 Java设计模式10/23/2018292模式的结构的描述与使用 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();
  • 293. Java设计模式 Java设计模式10/23/2018293模式的结构的描述与使用 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("读完全部成语"); } }
  • 294. 三、备忘录模式的优点 Java设计模式 Java设计模式10/23/2018294备忘录模式使用备忘录可以把原发者的内部状态保存起来,使得只有很“亲密的”的对象可以访问备忘录中的数据。 备忘录模式强调了类设计单一责任原则,即将状态的刻画和保存分开。
  • 295. 第二十六章 解释器模式 Java设计模式 Java设计模式10/23/2018295 解释器模式 给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。 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.
  • 296. 一 、 概述 Java设计模式 Java设计模式10/23/2018296 解释模式是关于怎样实现一个简单语言的成熟模式,其关键是将每一个语法规则表示成一个类。
  • 297. 二、解释器模式的结构与使用 Java设计模式 Java设计模式10/23/2018297模式的结构中包括四种角色: 抽象表达式(AbstractExpression) 终结符表达式子(TerminalExpression) 非终结符表达式子(NonterminalExpression) 上下文(Context)
  • 298. Java设计模式 Java设计模式10/23/2018298模式的UML类图
  • 299. Java设计模式 Java设计模式10/23/2018299模式的结构的描述与使用 1.抽象表达式(AbstractExpression): Node.java public interface Node{ public void parse(Context text); public void execute(); }
  • 300. Java设计模式 Java设计模式10/23/2018300模式的结构的描述与使用 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
  • 301. Java设计模式 Java设计模式10/23/2018301模式的结构的描述与使用 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
  • 302. Java设计模式 Java设计模式10/23/2018302模式的结构的描述与使用 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
  • 303. Java设计模式 Java设计模式10/23/2018303模式的结构的描述与使用 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(); } }
  • 304. Java设计模式 Java设计模式10/23/2018304模式的结构的描述与使用 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(); } }
  • 305. Java设计模式 Java设计模式10/23/2018305模式的结构的描述与使用 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(); } }
  • 306. Java设计模式 Java设计模式10/23/2018306模式的结构的描述与使用 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(); } }
  • 307. Java设计模式 Java设计模式10/23/2018307模式的结构的描述与使用 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; } }
  • 308. Java设计模式 Java设计模式10/23/2018308模式的结构的描述与使用 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(); } }
  • 309. 三、解释器模式的优点 Java设计模式 Java设计模式10/23/2018309将每一个语法规则表示成一个类,方便于实现简单的语言。 由于使用类表示语法规则,可以较容易改变或扩展语言的行为。 通过在类结构中加入新的方法,可以在解释的同时增加新的行为。