1、目录1【 装饰模式 应用场景举例】 12【 策略模式应用场景举例】 53【 代理模式应用场景举例】 84【 外观模式应用场景举例】 125【 抽象工厂模式应用场景举例】 146【 观察者模式应用场景举例】 227【 建造者模式应用场景举例】 278【 原型模式应用场景举例】 329【 工厂方法模式应用场景举例】 3610【 模板方法模式应用场景举例】 401【装饰模式应用场景举例】比如在玩“极品飞车”这款游戏，游戏中有对汽车进行喷涂鸦的功能，而且这个喷涂鸦是可以覆盖的，并且覆盖的顺序也影响到最后车身的显示效果，假设现在喷涂鸦具有 2 种样式：（1）红色火焰 （2）紫色霞光如果使用“继承父类”设
2、计这样的功能，那么类图就像如下的这样：从图中可以看到使用继承来实现这种功能，并且是 2 种涂鸦样式，就需要创建 4 个子类，如果喷涂鸦有 3 种，4 种呢？这种情况就是典型中学课程学习过的“排列与组合”，那简直就是“Head First 设计模式”书中讲的“类爆炸”。显然继承“奥迪汽车类”的这个办法是无效，而且是非常徒劳，繁琐的。那么如何才能以“灵活”，“顺序敏感”这样的需求来实现这样的功能呢？【装饰模式解释】类型：结构模式动态的对一个对象进行功能上的扩展，也可以对其子类进行功能上的扩展。【装饰模式 UML 图】【装饰模式-JAVA 代码实现】新建一个抽象汽车父类：package car_pa
3、ckage;public abstract class car_parent / 汽车抽象父类private String make_address;private int speed;public String getMake_address() return make_address;public void setMake_address(String make_address) this.make_address = make_address;public int getSpeed() return speed;public void setSpeed(int speed) this.s
4、peed = speed;public abstract void print_face();然后新建一个奥迪汽车子类package car_package;public class audi_sub extends car_parent / 奥迪汽车子类Overridepublic void print_face() System.out.println(“audi 车默认的颜色为 黑色“);然后再新建一个装饰者父类：package decorator_package;import car_package.car_parent;public abstract class decorator_
5、parent extends car_parent / 装饰者父类protected car_parent car_parent_ref;public void setCar_parent_ref(car_parent car_parent_ref) this.car_parent_ref = car_parent_ref;Overridepublic void print_face() car_parent_ref.print_face();然后再新建装饰者子类：红色火焰装饰者类：package decorator_package;public class decorator_audi_re
6、d extends decorator_parent Overridepublic void print_face() super.print_face();System.out.println(“给 奥迪 喷涂鸦 - 颜色为 红色火焰“);然后再新建装饰者子类：紫色霞光装饰者类：package decorator_package;public class decorator_audi_purple extends decorator_parent Overridepublic void print_face() super.print_face();System.out.println(“给
7、 奥迪 喷涂鸦 - 颜色为 紫色霞光“);新建一个运行类package main_run;import car_package.audi_sub;import decorator_package.decorator_audi_purple;import decorator_package.decorator_audi_red;public class main_run public static void main(String args) audi_sub audi_sub_ref = new audi_sub();audi_sub_ref.setMake_address(“北京市朝阳区“)
8、;audi_sub_ref.setSpeed(200);decorator_audi_red decorator_audi_red_ref = new decorator_audi_red();decorator_audi_red_ref.setCar_parent_ref(audi_sub_ref);decorator_audi_purple decorator_audi_purple_ref = new decorator_audi_purple();decorator_audi_purple_ref.setCar_parent_ref(decorator_audi_red_ref);de
9、corator_audi_purple_ref.print_face();程序运行结果如下：audi 车默认的颜色为 黑色给 奥迪 喷涂鸦 - 颜色为 红色火焰给 奥迪 喷涂鸦 - 颜色为 紫色霞光从程序结构中可以看到，完全符合了前面我们的要求：“灵活”，“顺序敏感”。2【策略模式应用场景举例】比如在玩“极品飞车”这款游戏，那么游戏对车的轮胎是可以更换的，不同的轮胎在高速转弯时有不同的痕迹样式，那么针对“汽车”的配件“轮胎”就要可以变化，而且轮胎和轮胎之间是可以相互替换的，这就是典型的要应用“策略模式”的场景！从程序结构中可以看到，完全符合了前面我们的要求：“灵活”，“顺序敏感”。【策略模式解
10、释】类型：行为模式定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。策略模式使这些算法在客户端调用它们的时候能够互不影响地变化。【策略模式 UML 图】【策略模式-JAVA 代码实现】从策略模式 UML 图中可以看到 Context 与接口 Strategy 是组合关系，即强引用关系。新建一个轮胎接口：package strategy_interface;public interface tyre_interface / tyre 轮胎public void print_tyre_line();/ 显示出轮胎的痕迹新建 2 个轮胎接口的实现类：package strategy_imp
11、lement;import strategy_interface.tyre_interface;/长痕迹轮胎类public class tyre_long_implement implements tyre_interface public void print_tyre_line() System.out.println(“在路面上显示一个长轮胎痕迹“);package strategy_implement;import strategy_interface.tyre_interface;/短痕迹轮胎类public class tyre_short_implement implements
12、tyre_interface public void print_tyre_line() System.out.println(“在路面上显示一个短轮胎痕迹“);基于一个轮胎接口来实现不同样式的轮胎样式。组装一个 Car 车类：package car_package;import strategy_interface.tyre_interface;public class Car private String make_address;/ 制造地private int death_year;/ 报废年限private int speed;/ 速度private tyre_interface t
13、yre_interface_ref;/ 轮胎的样式public String getMake_address() return make_address;public void setMake_address(String make_address) this.make_address = make_address;public int getDeath_year() return death_year;public void setDeath_year(int death_year) this.death_year = death_year;public int getSpeed() ret
14、urn speed;public void setSpeed(int speed) this.speed = speed;public tyre_interface getTyre_interface_ref() return tyre_interface_ref;public void setTyre_interface_ref(tyre_interface tyre_interface_ref) this.tyre_interface_ref = tyre_interface_ref;public void start() System.out.println(“车的基本信息为：“);Sy
15、stem.out.println(“制造地make_address：“ + this.getMake_address();System.out.println(“报废年限death_year：“ + this.getDeath_year();System.out.println(“速度 speed：“ + this.getSpeed();System.out.println(“Car 起动了！“);System.out.println(“Car 高速行驶，遇到一个大转弯，路面显示：“);this.getTyre_interface_ref().print_tyre_line();让车跑起来，并
16、且具有更换轮胎样式的功能：package main_run;import strategy_implement.tyre_long_implement;import strategy_implement.tyre_short_implement;import car_package.Car;public class run_main public static void main(String args) tyre_long_implement tyre_long_implement = new tyre_long_implement();tyre_short_implement tyre_s
17、hort_implement = new tyre_short_implement();Car car = new Car();car.setDeath_year(8);car.setMake_address(“北京朝阳区“);car.setSpeed(200);car.setTyre_interface_ref(tyre_long_implement);car.start();控制台打印出：车的基本信息为：制造地 make_address：北京朝阳区报废年限 death_year：8速度 speed：200Car 起动了！Car 高速行驶，遇到一个大转弯，路面显示：在路面上显示一个长轮胎痕迹
18、是一个长轮胎痕迹，但在程序中可以使用代码：car.setTyre_interface_ref（tyre_long_implement）；来对轮胎的样式进行不同的替换，可以替换成短轮胎痕迹的汽车轮胎，这样在不更改 Car 类的前题下进行了不同轮胎样式的改变，轮胎和轮胎之间可以互相替换，这就是策略模式。3【代理模式应用场景举例】比如在玩“极品飞车”这款游戏，如果游戏者手中的金钱达到了一定的数量就可以到车店买一部性能更高的赛车，那么这个卖车的“车店”就是一个典型的“汽车厂家”的“代理”，他为汽车厂家“提供卖车的服务”给有需求的人士。从面向对象的方面考虑，“销售汽车的代理”也是一个对象，那么这个对象也
19、具有一定的状态，在软件项目中这个对象也具有管理财务进销存的基本功能，那么在设计时就要以面向 OOP 编程的思想来考虑软件的类结构，这个销售汽车的代理也是一个类了。【代理模式解释】类型：结构模式对一些对象提供代理，以限制那些对象去访问其它对象。【代理模式 UML 图】【代理模式-JAVA 代码实现】新建一个买车的接口：package buy_car_package;public interface buy_car_package public void buy_car();新建一个 people 人类，具有买车的行为，所以实现接口buy_car_package：package buy_car_i
20、mple;import buy_car_package.buy_car_package;public class people implements buy_car_package private int cash;private String username;public int getCash() return cash;public void setCash(int cash) this.cash = cash;public String getUsername() return username;public void setUsername(String username) thi
21、s.username = username;public void buy_car() System.out.println(username + “买了一台新车“);people 类不能拥有车，必须经过 proxy 代理类的认证，符合条件之后才可以拥有车辆，新建一个代理，这个代理类来考察当前的 people 是否有资格进行买车：package buy_car_imple;import buy_car_package.buy_car_package;public class proxy_buy_car_imple implements buy_car_package private peopl
22、e people;public people getPeople() return people;public void setPeople(people people) this.people = people;public void buy_car() if (people.getCash() 3000) System.out.println(people.getUsername() + “花“ + people.getCash()+ “块 买了新车 交易结束“); else System.out.println(people.getUsername() + “金钱不够，请继续比赛!“);
23、最后创建一个客户端，用来模拟买车的行为：package run_main;import buy_car_imple.people;import buy_car_imple.proxy_buy_car_imple;public class run_main public static void main(String args) people people_ref1 = new people();people_ref1.setCash(4000);people_ref1.setUsername(“高洪岩“);people people_ref2 = new people();people_ref
24、2.setCash(2000);people_ref2.setUsername(“岩洪高“);proxy_buy_car_imple proxy_buy_car_imple = new proxy_buy_car_imple();proxy_buy_car_imple.setPeople(people_ref1);proxy_buy_car_imple.buy_car();proxy_buy_car_imple.setPeople(people_ref2);proxy_buy_car_imple.buy_car();程序运行结果如下：高洪岩花 4000 块 买了新车 交易结束岩洪高金钱不够，请
25、继续比赛!这样 people 就不可能自由的拥有车辆，必须经过 proxy 的认证之后才可以。而代理模式在 GOF 四人帮的介绍中大体有 4 种使用情景：（1）远程代理。典型的就是客户端与 webservice 使用的情况，客户端由于是针对 OOP 编程，而不是针对 webservice 中的方法进行编程，所以得在客户端模拟一下 webservice 的环境，用 proxy 来对 webservice 进行包装，这样就可以使用 proxy 代理类来远程操作 webservice 了。（2）虚拟代理。比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有 100MB，在打开文件时不
26、可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用 proxy 来进行大图片的打开。（3）安全代理。其实也就是本例中所举的买车的例子，金钱不够不可以买车！（4）智能指引。比如在访问一个对象时检测其是否被锁定等情况。4【外观模式应用场景举例】比如在玩“极品飞车”这款游戏，你只需要等待的就是倒计时到 0 时以最快的车速冲到第一名，但游戏者根本没有想过在车冲出去之前要做哪些工作，比如挂档，离合器，油箱检测，调整方向等等的微操作，将这些微操作封装起来变成一个接口就是外观模式了。在 WEB 开发中的 MVC 分层架构就是典型的一个外观模式，每一层将操作的具体内容隐藏起来，保留一个接
27、口供上层调用。【外观模式解释】类型：结构模式为子系统中的一组接口提供一个一致的 interface 接口界面。【外观模式 UML 图】【外观模式-JAVA 代码实现】新建赛车类：package car_package;public class car public void start() System.out.println(“车子已启动“);public void check_stop() System.out.println(“刹车检查“);public void check_box() System.out.println(“检查油箱“);public void check_conso
28、le() System.out.println(“检查仪表盘是否异常“);新建赛车操作的外观类：package car_facade;import car_package.car;public class car_facade_imple public void car_go_go(car car_ref) car_ref.check_box();car_ref.check_console();car_ref.check_stop();car_ref.start();新建客户端运行类：package run_main;import car_facade.car_facade_imple;imp
29、ort car_package.car;public class run_main public static void main(String args) car_facade_imple car_facade_imple_ref = new car_facade_imple();car_facade_imple_ref.car_go_go(new car();程序运行结果如下：检查油箱检查仪表盘是否异常刹车检查车子已启动很简单吧，将子操作用一个外观接口封装起来，然后调用这个接口就是调用那些非常复杂的微操作了。5【抽象工厂模式应用场景举例】写到抽象工厂模式了，我深知“抽象工厂模式”博文会带来
30、一点点高潮，因为程序员对工厂模式中的“抽象工厂”都是比较感冒的，而且关注也很多，我就尽量用我所能理解的那么点程度来给大家介绍这个模式，如果有更好的比喻还请网友指正，先感谢了！设计模式-快餐简解-【工厂方法模式】介绍了工厂方法的使用，从那个程序中可以看到，奥迪 audi 车是从audi_car_factory_imple 工厂中创建出来的，而大众 3W 车是从threeW_car_factory_imple 工厂中创建出来的，那么如果这 2 家汽车生产大厂由总部在北京市，现在发展到上海，深圳等城市创建生气汽车的分厂，该怎么办？是不是得将原来的奥迪汽车工厂类：public class audi_c
31、ar_factory_imple implements Icar_factory public Icar_interface create_car() car_audi_imple car_audi_imple_ref = new car_audi_imple();car_audi_imple_ref.setName(“奥迪 A6“);car_audi_imple_ref.setSpeed(300);return car_audi_imple_ref;改成类似如下的模样：public class audi_car_factory_imple implements Icar_factory pu
32、blic Icar_interface create_car(String area_car) if (area_car.equals(“北京“)创建一个北京的奥迪汽车if (area_car.equals(“上海“)创建一个上海的奥迪汽车if (area_car.equals(“深圳“)创建一个深圳的奥迪汽车return car_audi_imple_ref;那么发现一个问题，不同地域的汽车却在一个工厂中出现，这是不合乎常理的，因为北京奥迪在北京分厂创建，上海奥迪在上海分厂创建，这样才对。所以如果遇到分“大系”来创建对象的时候，抽象工厂方法是肯定要使用的时候了。这里的大系指的就是从地域上来分
33、。这个例子就应该以“用抽象工厂来定义具体工厂的抽象，而由具体工厂来创建对象”比如在玩“极品飞车”这款游戏，每个地图处都有造车的工厂，每个造车的工厂都因为有造车的档次不同而划分为高级车厂，低级车厂，那么这样的场景正是应用抽象工厂的好时机，再来理解一下这句话“用抽象工厂来定义具体工厂的抽象，而由具体工厂来创建对象”，用抽象造车工厂来定义具体造车工厂的抽象，而由具体的造车工厂来创建汽车，这就是抽象工厂与工厂方法的不同，工厂方法中对象的创建是由工厂方法来确定的，创建的对象都是不分类并且实现一个接口的，而抽象工厂就是在工厂方法的基础上对创建车的对象的行为进行分类，比如北京车厂，上海车厂等。【抽象工厂模式
34、解释】类型：创建模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。【抽象工厂模式 UML 图】【抽象工厂模式-JAVA 代码实现】新建抽象工厂接口：package car_factory_interface;import car_interface.Icar_interface;public interface Icar_factory public Icar_interface create_threeW_car();public Icar_interface create_audi_car();新建抽象工厂接口的高级车 adv 工厂实现类：package car_fa
35、ctory_imple;import car_factory_interface.Icar_factory;import car_imple.car_3w_imple_adv;import car_imple.car_audi_imple_adv;import car_interface.Icar_interface;public class car_factory_adv implements Icar_factory public Icar_interface create_audi_car() car_audi_imple_adv car_audi_imple_adv = new car
36、_audi_imple_adv();car_audi_imple_adv.setName(“奥迪 A6“);car_audi_imple_adv.setSpeed(300);return car_audi_imple_adv;public Icar_interface create_threeW_car() car_3w_imple_adv car_3w_imple_adv_ref = new car_3w_imple_adv();car_3w_imple_adv_ref.setName(“大众 A6“);car_3w_imple_adv_ref.setSpeed(300);return ca
37、r_3w_imple_adv_ref;新建抽象工厂接口的普通车 low 工厂实现类：package car_factory_imple;import car_factory_interface.Icar_factory;import car_imple.car_3w_imple_low;import car_imple.car_audi_imple_low;import car_interface.Icar_interface;public class car_factory_low implements Icar_factory public Icar_interface create_au
38、di_car() car_audi_imple_low car_audi_imple_low_ref = new car_audi_imple_low();car_audi_imple_low_ref.setName(“奥迪 A6“);car_audi_imple_low_ref.setSpeed(300);return car_audi_imple_low_ref;public Icar_interface create_threeW_car() car_3w_imple_low car_3w_imple_low_ref = new car_3w_imple_low();car_3w_imp
39、le_low_ref.setName(“大众 A6“);car_3w_imple_low_ref.setSpeed(300);return car_3w_imple_low_ref;上面已经有抽象工厂和具体工厂的实现类了。新建汽车接口：package car_interface;public interface Icar_interface public void start();public void stop();新建汽车父类：package car_imple;import car_interface.Icar_interface;public class base_car_imple
40、implements Icar_interface private int speed;private String name;public int getSpeed() return speed;public void setSpeed(int speed) this.speed = speed;public String getName() return name;public void setName(String name) this.name = name;public void start() / TODO Auto-generated method stubpublic void
41、 stop() / TODO Auto-generated method stub新建大众高级车：package car_imple;import car_interface.Icar_interface;public class car_3w_imple_adv extends base_car_imple public void start() System.out.println(“富华版：“ + this.getName() + “ 车以专利技术起动了 最高速度为：“+ this.getSpeed();public void stop() System.out.println(“富华版
42、：“ + this.getName() + “ 车以专利技术停车了“);新建大众普通车：package car_imple;import car_interface.Icar_interface;public class car_3w_imple_low extends base_car_imple public void start() System.out.println(“普通版：“ + this.getName() + “ 车以专利技术起动了 最高速度为：“+ this.getSpeed();public void stop() System.out.println(“普通版：“ +
43、this.getName() + “ 车以专利技术停车了“);新建大众普通车：package car_imple;import car_interface.Icar_interface;public class car_audi_imple_adv extends base_car_imple public void start() System.out.println(“富华版：“ + this.getName() + “ 车以专利技术起动了 最高速度为：“+ this.getSpeed();public void stop() System.out.println(“富华版：“ + thi
44、s.getName() + “ 车以专利技术停车了“);新建奥迪普通车：package car_imple;import car_interface.Icar_interface;public class car_audi_imple_low extends base_car_imple public void start() System.out.println(“普通版：“ + this.getName() + “ 车以专利技术起动了 最高速度为：“+ this.getSpeed();public void stop() System.out.println(“普通版：“ + this.g
45、etName() + “ 车以专利技术停车了“);新建客户端运行类：package run_main;import car_factory_imple.car_factory_adv;import car_factory_interface.Icar_factory;import car_interface.Icar_interface;public class run_main public static void main(String args) Icar_factory Icar_factory_ref = new car_factory_adv();Icar_interface Ic
46、ar_interface_ref = Icar_factory_ref.create_threeW_car();Icar_interface_ref.start();Icar_interface_ref.stop();程序运行结果如下：富华版：大众 A6 车以专利技术起动了 最高速度为：300富华版：大众 A6 车以专利技术停车了抓一篇阎宏的小文字：一开始只在后花园中种蔬菜类的时候可以用简单工厂模式，由工厂负责生成具体的蔬菜类，但是如果后花园要引进水果类的时候简单模式就行不通了，因此需要使用工厂方法模式，将产品类族分开。但是如果后花园的规模继续扩大到地域范围的分割时，比如说一个在北京，一个在上
47、海的时候，工厂方法模式就不够了，因为对两个后花园来说，每个后花园的植物是要被种在一起的，并且两个后花园用工厂方法模式是无法体现其区别的从程序中可以看到，工厂是抽象的，工厂的实现是不样的，不同的工厂创建出不同汽车。而工厂方法仅仅是用一个工厂去创建很多汽车。6【观察者模式应用场景举例】比如在玩“极品飞车”这款游戏，每一个车手到达终点的时候，都会在其它车手的屏幕上显示：某某人以多少时间到达终点的提示，其实这就是一个典型的观察者模式的应用，观察者模式即是典型的双向一对多的应用场景下用一的一端来通知多的一端。【观察者模式解释】类型：行为模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对
48、象。这个主题对象的状态发生改变时，会通知所有的观察者对象，使它们能够自己更新自己。【观察者模式 UML 图】【观察者模式-JAVA 代码实现】新建抽象发布通知父类：package carer_subject;import java.util.ArrayList;import java.util.List;import carer_observer.carer_observer;public interface carer_subject_parent public void set_state(String state_string);public String get_state();pub
49、lic void add_observer(carer_observer carer_observer_ref);public void sub_observer(carer_observer carer_observer_ref);public void notityAllCarer();新建发布通知实现类：package carer_subject;import java.util.ArrayList;import java.util.List;import carer_observer.carer_observer;public class carer_subject_sub implements carer_subject_parent List list_observer = new ArrayList();private S
