1、,Java设计模式,2018/11/19,1,第一章 设计模式简介,1.1 什么是设计模式,2018/11/19,2,每一个设计模式描述一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心。这样，你就能一次一次地使用该方案而不必做重复劳动。,1.2 设计模式的起源,2018/11/19,3,软件领域的设计模式起源于建筑学。1977年，建筑大师Alexander出版了A Pattern Language：Towns, Building, Construction一书。受Alexander著作的影响 ，Kent Beck和Ward Cunningham在1987年举行的一次面向对象的会议上
2、发表了论文：在面向对象编程中使用模式。,1.3 GOF之著作,2018/11/19,4,目前，被公认在设计模式领域最具影响力的著作是Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides在1994年合作出版的著作：Design Patterns：Elements of Reusable Object-Oriented Software（中译本设计模式：可复用的面向对象软件的基本原理 或设计模式），该书被广大喜爱者昵称为GOF（Gang of Four）之书，被认为是学习设计模式的必读著作，GOF之书已经被公认为是设计模式领域的奠基之作。,1.
3、4 学习设计模式的重要性,2018/11/19,5,学习设计模式不仅可以使我们使用好这些成功的模式，更重要的是可以使我们更加深刻地理解面向对象的设计思想，非常有利于我们更好地使用面向对象语言解决设计中的问题。,1.5 合理使用模式,2018/11/19,6,1正确使用2避免教条3模式挖掘4 避免乱用5了解反模式,第二章 面向对象的几个基本原则,2.1 面向抽象原则,2018/11/19,7,设计一个类时，不让该类面向具体的类，而是面向抽象类或接口 。,2.2 开-闭原则,2018/11/19,8,设计应当对扩展开放，对修改关闭。 如果您的设计遵守了“开-闭原则”，那么这个设计一定是易维护的，因
4、为在设计中增加新的模块时，不必去修改设计中的核心模块。,2.3 多用组合少用继承原则,2018/11/19,9,设计中避开类继承的缺点，充分使用对象组合的优点。,2.4 高内聚-低耦合原则,2018/11/19,10,如果类中的方法是一组相关的行为，则称该类是高内聚的，反之称为低内聚的。所谓低耦合就是尽量不要让一个类含有太多的其它类的实例的引用，以避免修改系统的其中一部分会影响到其它部分。,第三章 UML类图简介,3.1 类(Class)_1,2018/11/19,11,在UML中，使用一个长方形描述一个类的主要构成，将长方形垂直地分为三层 。第1层是名字层，类名字是常规字形，表明该类是具体类
5、，类名字是斜体字形，表明该类是抽象类。 第2层是变量层，也称属性层，列出类的成员变量及类型，格式是“变量名字：类型”。 第3层是方法层，也称操作层，列出类的方法及返回类型，格式是“方法名字（参数列表）：类型”。,3.1 类(Class)_2,2018/11/19,12,Student,+name:String #age:int -money:double,+setName(String):void #printMess():void +getAge():int setAge(int):void -getMoney();,名字层,变量层,方法层,3.2 接口（Interface）_1,2018/
6、11/19,13,表示接口的UML图和表示类的UML图类似，使用一个长方形描述一个接口的主要构成，将长方形垂直地分为三层 。第1层是名字层，接口的名字必须是斜体字形，而且需要用修饰名字，并且该修饰和名字分列在2行。第2层是常量层，列出接口中的常量及类型，格式是“常量名字：类型”。 第3层是方法层，也称操作层，列出接口中的方法及返回类型，格式是“方法名字（参数列表）：类型”。,3.2 接口（Interface)_2,2018/11/19,14, Creator,+MAX:int,+factoryMethod():Product,名字层,常量层,方法层,3.3 泛化关系（Generalizatio
7、n）,2018/11/19,15,对于面向对象语言，UML中所说的泛化关系就是指类的继承关系。如果一个类是另一个类的子类，那么UML通过使用一个实线连接两个类的UML图来表示二者之间的继承关系，实线的起始端是子类的UML图，终点端是父类的UML图，但终点端使用一个空心的三角形表示实线的结束 。,3.4 关联关系（Association）,2018/11/19,16,如果A类中成员变量是用B类（接口）来声明的变量，那么A和B的关系是关联关系，称A关联于B。那么UML通过使用一个实线连A和B的UML图，实线的起始端是A的UML图，终点端是B的UML图，但终点端使用一个指向B的UML图的方向箭头表示
8、实线的结束 。,3.5 依赖关系（Dependency）,2018/11/19,17,如果A类中某个方法的参数用B类（接口）来声明的变量或某个方法返回的数据类型是B类型的，那么A和B的关系是依赖关系，称A依赖于B。那么UML通过使用一个虚线连A和B的UML图，虚线的起始端是A的UML图，终点端是B的UML图，但终点端使用一个指向B的UML图的方向箭头表示虚线的结束。,3.6 实现关系（Realization）,2018/11/19,18,如果一个类实现了一个接口，那么类和接口的关系是实现关系，称类实现接口。UML通过使用虚线连接类和它所实现的接口，虚线起始端是类，虚线的终点端是它实现的接口，但
9、终点端使用一个空心的三角形表示虚线的结束 。,3.7 注释（Annotation）,2018/11/19,19,UML使用注释为类图提供附加的说明。UML在一个带卷角的长方形中显示给出的注释，并使用虚线将这个带卷角的长方形和所它所注释的实体连接起来 。,第四章 命令模式,2018/11/19,20,命令模式（别名：动作，事务）将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。Command Pattern(Another Name: Action, Transaction) Encapsulate a request as an
10、object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.,一 、 概述,2018/11/19,21,在许多设计中，经常涉及到一个对象请求另一个对象调用其方法到达某种目的。如果请求者不希望或无法直接和被请求者打交道，即不希望或无法含有被请求者的引用，那么就可以使用命令模式。,二、命令模式的结构与使用,2018/11/19,22,模式的结构中包括四种角色：接收者（Receiver）命令(Comman
11、d)接口具体命令（ConcreteCommand）请求者（Invoker）,2018/11/19,23,模式的UML类图,2018/11/19,24,模式的结构的描述与使用,1接收者（Receiver） : CompanyArmy.java public class CompanyArmypublic void sneakAttack() System.out.println(“我们知道如何偷袭敌人,保证完成任务“); ,2018/11/19,25,模式的结构的描述与使用,2命令（Command）接口 : Command.javapublic interface Command public
12、abstract void execute(); ,2018/11/19,26,模式的结构的描述与使用,3具体命令（ConcreteCommand） ConcreteCommand.java public class ConcreteCommand implements CommandCompanyArmy army; /含有接收者的引用ConcreteCommand(CompanyArmy army)this.army=army;public void execute() /封装着指挥官的请求army.sneakAttack(); /偷袭敌人 ,2018/11/19,27,模式的结构的描述与
13、使用,4请求者（Invoker） ArmySuperior.java public class ArmySuperiorCommand command; /用来存放具体命令的引用public void setCommand(Command command)mand=command;public void startExecuteCommand() /让具体命令执行execute()方法command.execute(); ,2018/11/19,28,模式的结构的描述与使用,5应用 Application.javapublic class Applicationpublic static vo
14、id main(String args)CompanyArmy 三连=new CompanyArmy(); Command command=new ConcreteCommand(三连);ArmySuperior 指挥官=new ArmySuperior(); 指挥官.setCommand(command); 指挥官.startExecuteCommand(); ,三、命令模式的优点,2018/11/19,29,在命令模式中，请求者（Invoker）不直接与接收者（Receiver）交互，即请求者（Invoker）不包含接收者（Receiver）的引用，因此彻底消除了彼此之间的耦合。命令模式满
15、足“开-闭原则”。如果增加新的具体命令和该命令的接受者，不必修改调用者的代码，调用者就可以使用新的命令对象；反之，如果增加新的调用者，不必修改现有的具体命令和接受者，新增加的调用者就可以使用已有的具体命令。由于请求者的请求被封装到了具体命令中，那么就可以将具体命令保存到持久化的媒介中，在需要的时候，重新执行这个具体命令。因此，使用命令模式可以记录日志。使用命令模式可以对请求者的“请求”进行排队。每个请求都各自对应一个具体命令，因此可以按一定顺序执行这些具体命令。,第五章 观察者模式,2018/11/19,30,观察者模式（别名：依赖，发布-订阅）定义对象间的一种一对多的依赖关系，当一个对象的状
16、态发生变化时，所有依赖于它的对象都得到通知并被自动更新。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,一 、 概述,2018/11/19,31,在许多设计中，经常涉及到多个对象都对一个特殊对象中的数据变化感兴趣，而且这多个对象都希望
17、跟踪那个特殊对象中的数据变化。,二、 模式的结构与使用,2018/11/19,32,观察者模式的结构中包括四种角色：主题（Subject）观察者（Observer） 具体主题（ConcreteSubject） 具体观察者（ConcreteObserver）,2018/11/19,33,模式的UML类图,2018/11/19,34,模式的结构的描述与使用,1主题 : Subject.java public interface Subjectpublic void addObserver(Observer o);public void deleteObserver(Observer o);publ
18、ic void notifyObservers(); ,2018/11/19,35,模式的结构的描述与使用,2观察者 : Obsever.java public interface Observerpublic void hearTelephone(String heardMess); ,2018/11/19,36,模式的结构的描述与使用,3具体主题 SeekJobCenter.java_1 import java.util.ArrayList; public class SeekJobCenter implements SubjectString mess;boolean changed;A
19、rrayList 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); ,2018/11/19,37,模式的结构的描述与使用,3具体主题 SeekJobCenter.j
20、ava_2 public void notifyObservers() if(changed)for(int i=0;ipersonList.size();i+)Observer observer=personList.get(i);observer.hearTelephone(mess); changed=false; public void giveNewMess(String str)if(str.equals(mess)changed=false;elsemess=str;changed=true; ,2018/11/19,38,模式的结构的描述与使用,4具体观察者_1 Univers
21、ityStudent.java import java.io.*; public class UniverStudent implements ObserverSubject subject;File myFile; UniverStudent(Subject subject,String fileName)this.subject=subject;subject.addObserver(this); /使当前实例成为subject所引用的具体主题的观察者myFile=new File(fileName);public void hearTelephone(String heardMess)t
22、ry 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
23、(); ,2018/11/19,39,模式的结构的描述与使用,4具体观察者_2 HaiGui.java import java.io.*; import java.util.regex.*; public class HaiGui implements ObserverSubject subject;File myFile; HaiGui(Subject subject,String fileName)this.subject=subject;subject.addObserver(this); /使当前实例成为subject所引用的具体主题的观察者myFile=new File(fileNa
24、me);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(“我向文件“
25、+myFile.getName()+“写入如下内容:“);System.out.println(heardMess);elseSystem.out.println(“我是海归,这次的信息中没有我需要的信息“); catch(IOException exp)System.out.println(exp.toString(); ,2018/11/19,40,模式的结构的描述与使用,5应用 Application.java public class Applicationpublic static void main(String args)SeekJobCenter center=new Seek
26、JobCenter(); 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()
27、;center.giveNewMess(“仁海公司需要9个电工。“); center.notifyObservers(); ,三、观察者模式的优点,2018/11/19,41,具体主题和具体观察者是松耦合关系。由于主题（Subject）接口仅仅依赖于观察者（Observer）接口，因此具体主题只是知道它的观察者是实现观察者（Observer）接口的某个类的实例，但不需要知道具体是哪个类。同样，由于观察者仅仅依赖于主题（Subject）接口，因此具体观察者只是知道它依赖的主题是实现主题（subject）接口的某个类的实例，但不需要知道具体是哪个类。 观察模式满足“开-闭原则”。主题（Subjec
28、t）接口仅仅依赖于观察者（Observer）接口，这样，我们就可以让创建具体主题的类也仅仅是依赖于观察者（Observer）接口，因此如果增加新的实现观察者（Observer）接口的类，不必修改创建具体主题的类的代码。同样，创建具体观察者的类仅仅依赖于主题（Observer）接口，如果增加新的实现主题（Subject）接口的类，也不必修改创建具体观察者类的代码。,第六章 装饰模式,2018/11/19,42,装饰模式（别名：包装器）动态地给对象添加一些额外的职责。就功能来说装饰模式相比生成子类更为灵活。Decorator Pattern(Another Name: Wrapper) Attac
29、h additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.,一 、 概述,2018/11/19,43,装饰模式是动态地扩展一个对象的功能，而不需要改变原始类代码的一种成熟模式。在装饰模式中，“具体组件”类和“具体装饰”类是该模式中的最重要的两个角色。,二、装饰模式模式的结构与使用,2018/11/19,44,装饰模式的结构中包括四种角色：抽象组件（Component） 具体
30、组件（ConcreteComponent） 装饰（Decorator） 具体装饰（ConcreteDecotator）,2018/11/19,45,装饰模式的UML类图,2018/11/19,46,装饰模式的结构的描述与使用,1抽象组件 : Bird.java public abstract class Birdpublic abstract int fly(); ,2018/11/19,47,装饰模式的结构的描述与使用,2具体组件 : Sparrow.java public class Sparrow extends Birdpublic final int DISTANCE=100;pub
31、lic int fly()return DISTANCE; ,2018/11/19,48,装饰模式的结构的描述与使用,3装饰 （Decorator）: Decorator.java public abstract class Decorator extends Birdprotected Bird bird;public Decorator()public Decorator(Bird bird)this.bird=bird; ,2018/11/19,49,装饰模式的结构的描述与使用,4具体装饰（ConcreteDecotator）: SparrowDecorator.java public
32、class SparrowDecorator extends Decoratorpublic 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; ,2018/11/19,50,装饰模式的结构的描述与使用,5应用 Application.javapu
33、blic class Applicationpublic 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 sparrowDeco
34、rator2=new SparrowDecorator(sparrowDecorator1); client.needBird(sparrowDecorator1); client.needBird(sparrowDecorator2); ,三、装饰模式的优点,2018/11/19,51,被装饰者和装饰者是松耦合关系。由于装饰（Decorator）仅仅依赖于抽象组件（Component），因此具体装饰只知道它要装饰的对象是抽象组件的某一个子类的实例，但不需要知道是哪一个具体子类。装饰模式满足“开-闭原则”。不必修改具体组件，就可以增加新的针对该具体组件的具体装饰。可以使用多个具体装饰来装饰具体
35、组件的实例。,第七章 策略模式,2018/11/19,52,策略模式（别名：政策）定义一系列算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。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.,一 、 概述,2018
36、/11/19,53,策略模式是处理算法的不同变体的一种成熟模式，策略模式通过接口或抽象类封装算法的标识，即在接口中定义一个抽象方法，实现该接口的类将实现接口中的抽象方法。在策略模式中，封装算法标识的接口称作策略，实现该接口的类称作具体策略。,二、策略模式的结构与使用,2018/11/19,54,策略模式的结构中包括三种角色：策略（Strategy）具体策略（ConcreteStrategy） 上下文（Context）,2018/11/19,55,策略模式的UML类图,2018/11/19,56,策略模式的结构的描述与使用,1策略（Strategy） : Computable.java publ
37、ic interface ComputableStrategypublic abstract double computeScore(double a); ,2018/11/19,57,策略模式的结构的描述与使用,2具体策略（ConcreteStrategy）: StrategyOne.java public class StrategyOne implements ComputableStrategypublic double computeScore(double a)double score=0,sum=0;for(int i=0;ia.length;i+)sum=sum+ai;scor
38、e=sum/a.length;return score; ,2018/11/19,58,策略模式的结构的描述与使用,2具体策略（ConcreteStrategy）: StrategyTwo.java public class StrategyTwo implements ComputableStrategypublic double computeScore(double a)double score=0,multi=1;int n=a.length;for(int i=0;ia.length;i+)multi=multi*ai;score=Math.pow(multi,1.0/n);retu
39、rn score; ,2018/11/19,59,策略模式的结构的描述与使用,2具体策略（ConcreteStrategy）: StrategyThree.java import java.util.Arrays; public class StrategyThree implements ComputableStrategypublic double computeScore(double a)if(a.length=2)return 0;double score=0,sum=0;Arrays.sort(a);for(int i=1;ia.length-1;i+)sum=sum+ai; sc
40、ore=sum/(a.length-2);return score; ,2018/11/19,60,策略模式的结构的描述与使用,3上下文： GymnasticsGame.java public class GymnasticsGameComputableStrategy strategy;public void setStrategy(ComputableStrategy strategy)this.strategy=strategy; public double getPersonScore(double a)if(strategy!=null)return puteScore(a); el
41、sereturn 0; ,2018/11/19,61,策略模式的结构的描述与使用,4应用： Application.java_1public class Applicationpublic 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
42、 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
43、();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();,2018/11/19,62,策略模式的结构的描述
44、与使用,4应用： Application.java_2game.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.g
45、etScore(); class PersonString 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; ,三、策略模式的优点,2018/11/19,63,上下文（Context）和具体策略（ConcreteStrategy）是松耦合关系。因此上下文只知道它要使用某一个实现Strategy接口类的实例，但不需要知道
46、具体是哪一个类。策略模式满足“开-闭原则”。当增加新的具体策略时，不需要修改上下文类的代码，上下文就可以引用新的具体策略的实例。,第八章 适配器模式,2018/11/19,64,适配器模式（别名：包装器）将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。Adapter Pattern(Another Name: Wrapper) Convert the interface of a class into another interface clients expect. Adapter lets classes work t
47、ogether that couldnt otherwise because of incompatible interfaces.,一 、 概述,2018/11/19,65,适配器模式是将一个类的接口（被适配者）转换成客户希望的另外一个接口（目标）的成熟模式，该模式中涉及有目标、被适配者和适配器。适配器模式的关键是建立一个适配器，这个适配器实现了目标接口并包含有被适配者的引用。,二、适配器模式的结构与使用,2018/11/19,66,模式的结构中包括三种角色：目标（Target） 被适配者（Adaptee） 适配器（Adapter）,2018/11/19,67,模式的UML类图,2018/1
48、1/19,68,模式的结构的描述与使用,1目标（Target） : ThreeElectricOutlet.java public interface ThreeElectricOutletpublic abstract void connectElectricCurrent(); ,2018/11/19,69,模式的结构的描述与使用,2被适配者（Adaptee）: TwoElectricOutlet.java public interface TwoElectricOutletpublic abstract void connectElectricCurrent(); ,2018/11/19,70,模式的结构的描述与使用,3适配器（Adapter） TreeElectricAdapter.java public class TreeElectricAdapter implements ThreeElectricOutletTwoElectricOutlet outlet;TreeElectricAdapter(TwoElectricOutlet outlet)this.outlet=outlet;public void connectElectricCurrent()outlet.connectElectricCurrent(); ,
