From e0f630be6e67c2758afc02cb994888f505c5e5f0 Mon Sep 17 00:00:00 2001
From: CyC2018 <1029579233@qq.com>
Date: Fri, 30 Mar 2018 23:17:26 +0800
Subject: [PATCH] auto commit
---
notes/设计模式.md | 1865 ++---------------
pics/a8644ee5-dc04-40b6-8492-e2d3c922eb04.png | Bin 0 -> 41984 bytes
pics/bf0ff9fc-467e-4a3f-8922-115ba2c55bde.png | Bin 0 -> 30720 bytes
pics/d7f6dec1-02b6-4969-b3ab-e01ee78659b9.png | Bin 0 -> 14336 bytes
pics/db54db2f-82b2-4222-8d63-e49a8a7fc966.png | Bin 0 -> 10240 bytes
5 files changed, 209 insertions(+), 1656 deletions(-)
create mode 100644 pics/a8644ee5-dc04-40b6-8492-e2d3c922eb04.png
create mode 100644 pics/bf0ff9fc-467e-4a3f-8922-115ba2c55bde.png
create mode 100644 pics/d7f6dec1-02b6-4969-b3ab-e01ee78659b9.png
create mode 100644 pics/db54db2f-82b2-4222-8d63-e49a8a7fc966.png
diff --git a/notes/设计模式.md b/notes/设计模式.md
index 59659653..dccf8b59 100644
--- a/notes/设计模式.md
+++ b/notes/设计模式.md
@@ -1,23 +1,10 @@
* [一、前言](#一前言)
* [二、设计模式概念](#二设计模式概念)
-* [三、策略模式](#三策略模式)
-* [三、观察者模式](#三观察者模式)
-* [四、装饰模式](#四装饰模式)
-* [五、简单工厂](#五简单工厂)
-* [六、工厂方法模式](#六工厂方法模式)
-* [七、抽象工厂模式](#七抽象工厂模式)
-* [八、单例模式](#八单例模式)
-* [九、命令模式](#九命令模式)
-* [十、适配器模式](#十适配器模式)
-* [十、外观模式](#十外观模式)
-* [十一、模板方法模式](#十一模板方法模式)
-* [十二、迭代器模式](#十二迭代器模式)
-* [十三、组合模式](#十三组合模式)
-* [十四、状态模式](#十四状态模式)
-* [十五、代理模式](#十五代理模式)
-* [十六、MVC](#十六mvc)
-* [十七、与设计模式相处](#十七与设计模式相处)
+* [三、单例模式](#三单例模式)
+* [四、简单工厂](#四简单工厂)
+* [五、工厂方法模式](#五工厂方法模式)
+* [六、抽象工厂模式](#六抽象工厂模式)
* [参考资料](#参考资料)
@@ -26,742 +13,46 @@
文中涉及一些 UML 类图，为了更好地理解，可以先阅读 [UML 类图](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E6%80%9D%E6%83%B3.md#%E7%AC%AC%E4%B8%89%E7%AB%A0-uml)。
-需要说明的一点是，文中的 UML 类图和规范的 UML 类图不大相同，其中组合关系使用以下箭头表示：
-
- 
-
# 二、设计模式概念
设计模式不是代码，而是解决问题的方案，学习现有的设计模式可以做到经验复用。
拥有设计模式词汇，在沟通时就能用更少的词汇来讨论，并且不需要了解底层细节。
-# 三、策略模式
+# 三、单例模式
-## 模式定义
-
-定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。
-
-## 问题描述
-
-设计不同种类的鸭子拥有不同的叫声和飞行方式。
-
-## 简单实现方案
-
-使用继承的解决方案如下，这种方案代码无法复用，如果两个鸭子类拥有同样的飞行方式，就有两份重复的代码。
-
- 
-
-## 设计原则
-
-**封装变化** ：在这里变化的是鸭子叫和飞行的行为方式。
-
-**针对接口编程，而不是针对实现编程** ：变量声明的类型为父类，而不是具体的某个子类。父类中的方法实现不在父类，而是在各个子类。程序在运行时可以动态改变变量所指向的子类类型。
-
-运用这一原则，将叫和飞行的行为抽象出来，实现多种不同的叫和飞行的子类，让子类去实现具体的叫和飞行方式。
-
- 
-
-**多用组合，少用继承** ：组合也就是 HAS-A 关系，通过组合，可以在运行时动态改变实现，只要通过改变父类对象具体指向哪个子类即可。而继承就不能做到这些，继承体系在创建类时就已经确定。
-
-运用这一原则，在 Duck 类中组合 FlyBehavior 和 QuackBehavior 类，performQuack() 和 performFly() 方法委托给这两个类去处理。通过这种方式，一个 Duck 子类可以根据需要去初始化 FlyBehavior 和 QuackBehavior 的子类对象，并且也可以动态地进行改变。
-
- 
-
-## 问题的解决方案类图
-
-（可放大网页查看）
-
- 
-
-## 代码实现
-
-```java
-public abstract class Duck {
- FlyBehavior flyBehavior;
- QuackBehavior quackBehavior;
-
- public Duck(){
- }
-
- public void performFly(){
- flyBehavior.fly();
- }
-
- public void setFlyBehavior(FlyBehavior fb){
- flyBehavior = fb;
- }
-
- public void performQuack(){
- quackBehavior.quack();
- }
-
- public void setQuackBehavior(QuackBehavior qb){
- quackBehavior = qb;
- }
-}
-```
-```java
-public class MallardDuck extends Duck{
- public MallardDuck(){
- flyBehavior = new FlyWithWings();
- quackBehavior = new Quack();
- }
-}
-```
-```java
-public interface FlyBehavior {
- void fly();
-}
-```
-```java
-public class FlyNoWay implements FlyBehavior{
- @Override
- public void fly() {
- System.out.println("FlyBehavior.FlyNoWay");
- }
-}
-```
-```java
-public class FlyWithWings implements FlyBehavior{
- @Override
- public void fly() {
- System.out.println("FlyBehavior.FlyWithWings");
- }
-}
-```
-```java
-public interface QuackBehavior {
- void quack();
-}
-```
-```java
-public class Quack implements QuackBehavior{
- @Override
- public void quack() {
- System.out.println("QuackBehavior.Quack");
- }
-}
-```
-```java
-public class MuteQuack implements QuackBehavior{
- @Override
- public void quack() {
- System.out.println("QuackBehavior.MuteQuack");
- }
-}
-```
-```java
-public class Squeak implements QuackBehavior{
- @Override
- public void quack() {
- System.out.println("QuackBehavior.Squeak");
- }
-}
-```
-```java
-public class MiniDuckSimulator {
- public static void main(String[] args) {
- Duck mallardDuck = new MallardDuck();
- mallardDuck.performQuack();
- mallardDuck.performFly();
- mallardDuck.setFlyBehavior(new FlyNoWay());
- mallardDuck.performFly();
- }
-}
-```
-执行结果
-```html
-QuackBehavior.Quack
-FlyBehavior.FlyWithWings
-FlyBehavior.FlyNoWay
-```
-
-# 三、观察者模式
-
-## 模式定义
-
-定义了对象之间的一对多依赖，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。主题（Subject）是被观察的对象，而其所有依赖者（Observer）称为观察者。
-
- 
-
-## 模式类图
-
-主题具有注册和移除观察者、并通知所有注册者的功能，主题是通过维护一张观察者列表来实现这些操作的。
-
-观察者拥有一个主题对象的引用，因为注册、移除观察者功能，还有数据都在主题当中，必须通过操作主题才能完成相应操作。
-
- 
-
-## 问题描述
-
-天气数据布告板会在天气信息发生改变时更新其内容，布告板有多个，并且在将来会继续增加。
-
-## 问题的解决方案类图
-
- 
-
-## 设计原则
-
-为交互对象之间的松耦合设计而努力：当两个对象之间松耦合，它们依然可以交互，但是不清楚彼此的细节。由于松耦合的两个对象之间互相依赖程度很低，因此系统具有弹性，能够应对变化。
-
-## 代码实现
-
-```java
-public interface Subject {
- public void resisterObserver(Observer o);
- public void removeObserver(Observer o);
- public void notifyObserver();
-}
-```
-```java
-
-public class WeatherData implements Subject {
- private List observers;
- private float temperature;
- private float humidity;
- private float pressure;
-
- public WeatherData() {
- observers = new ArrayList<>();
- }
-
- @Override
- public void resisterObserver(Observer o) {
- observers.add(o);
- }
-
- @Override
- public void removeObserver(Observer o) {
- int i = observers.indexOf(o);
- if (i >= 0) {
- observers.remove(i);
- }
- }
-
- @Override
- public void notifyObserver() {
- for (Observer o : observers) {
- o.update(temperature, humidity, pressure);
- }
- }
-
- public void setMeasurements(float temperature, float humidity, float pressure) {
- this.temperature = temperature;
- this.humidity = humidity;
- this.pressure = pressure;
- notifyObserver();
- }
-}
-```
-```java
-public interface Observer {
- public void update(float temp, float humidity, float pressure);
-}
-```
-```java
-public class CurrentConditionsDisplay implements Observer {
- private Subject weatherData;
-
- public CurrentConditionsDisplay(Subject weatherData) {
- this.weatherData = weatherData;
- weatherData.resisterObserver(this);
- }
-
- @Override
- public void update(float temp, float humidity, float pressure) {
- System.out.println("CurrentConditionsDisplay.update:" + temp + " " + humidity + " " + pressure);
- }
-}
-```
-```java
-public class StatisticsDisplay implements Observer {
- private Subject weatherData;
-
- public StatisticsDisplay(Subject weatherData) {
- this.weatherData = weatherData;
- weatherData.resisterObserver(this);
- }
-
- @Override
- public void update(float temp, float humidity, float pressure) {
- System.out.println("StatisticsDisplay.update:" + temp + " " + humidity + " " + pressure);
- }
-}
-```
-```java
-public class WeatherStation {
- public static void main(String[] args) {
- WeatherData weatherData = new WeatherData();
- CurrentConditionsDisplay currentConditionsDisplay = new CurrentConditionsDisplay(weatherData);
- StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
-
- weatherData.setMeasurements(0, 0, 0);
- weatherData.setMeasurements(1, 1, 1);
- }
-}
-```
-执行结果
-```html
-CurrentConditionsDisplay.update:0.0 0.0 0.0
-StatisticsDisplay.update:0.0 0.0 0.0
-CurrentConditionsDisplay.update:1.0 1.0 1.0
-StatisticsDisplay.update:1.0 1.0 1.0
-```
-
-# 四、装饰模式
-
-## 问题描述
-
-设计不同种类的饮料，饮料可以添加配料，比如可以添加牛奶，并且支持动态添加新配料。每增加一种配料，该饮料的价格就会增加，要求计算一种饮料的价格。
-
-## 模式定义
-
-动态地将责任附加到对象上。在扩展功能上，装饰者提供了比继承更有弹性的替代方案。
-
-下图表示在 DarkRoast 饮料上新增新添加 Mocha 配料，之后又添加了 Whip 配料。DarkRoast 被 Mocha 包裹，Mocha 又被 Whip 包裹。它们都继承自相同父类，都有 cost() 方法，外层类的 cost() 方法调用了内层类的 cost() 方法。
-
- 
-
-## 模式类图
-
-装饰者（Decorator）和具体组件（ConcreteComponent）都继承自组件（Component），具体组件的方法实现不需要依赖于其它对象，而装饰者组合了一个组件，这样它可以装饰其它装饰者或者具体组件。所谓装饰，就是把这个装饰者套在被装饰上，从而动态扩展被装饰者的功能。装饰者的方法有一部分是自己的，这属于它的功能，然后调用被装饰者的方法实现，从而也保留了被装饰者的功能。可以看到，具体组件应当是装饰层次的最低层，因为只有具体组件的方法实现不需要依赖于其它对象。
-
- 
-
-## 问题的解决方案类图
-
- 
-
-## 设计原则
-
-类应该对扩展开放，对修改关闭：也就是添加新功能时不需要修改代码。在本章问题中该原则体现在，饮料可以动态添加新的配料，而不需要去修改饮料的代码。观察者模式也符合这个原则。不可能把所有的类设计成都满足这一原则，应当把该原则应用于最有可能发生改变的地方。
-
-## Java I/O 中的装饰者模式
-
- 
-
-## 代码实现
-
-```java
-public interface Beverage {
- public double cost();
-}
-```
-```java
-public class HouseBlend implements Beverage{
- @Override
- public double cost() {
- return 1;
- }
-}
-```
-```java
-public class DarkRoast implements Beverage{
- @Override
- public double cost() {
- return 1;
- }
-}
-```
-```java
-public abstract class CondimentDecorator implements Beverage{
- protected Beverage beverage;
-}
-```
-```java
-public class Mocha extends CondimentDecorator {
-
- public Mocha(Beverage beverage) {
- this.beverage = beverage;
- }
-
- @Override
- public double cost() {
- return 1 + beverage.cost();
- }
-}
-```
-```java
-public class Milk extends CondimentDecorator {
-
- public Milk(Beverage beverage) {
- this.beverage = beverage;
- }
-
- @Override
- public double cost() {
- return 1 + beverage.cost();
- }
-}
-```
-```java
-public class StartbuzzCoffee {
- public static void main(String[] args) {
- Beverage beverage = new HouseBlend();
- beverage = new Mocha(beverage);
- beverage = new Milk(beverage);
- System.out.println(beverage.cost());
- }
-}
-```
-
-输出
-
-```html
-3.0
-```
-
-# 五、简单工厂
-
-## 问题描述
-
-Pizza 类有很多子类，要求根据不同的情况用不同的子类实例化一个 Pizza 对象。
-
-## 模式定义
-
-简单工厂不是设计模式，更像是一种编程习惯。它把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个子类来实例化。
-
-这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类。因为客户类往往有多个，如果不使用简单工厂，所有的客户类都要知道所有子类的细节。而且一旦子类发生改变，例如增加子类，那么所有的客户类都要进行修改。
-
- 
-
-## 问题的解决方案类图
-
- 
-
-## 代码实现
-
-```java
-public interface Pizza {
- public void make();
-}
-```
-
-```java
-public class CheesePizza implements Pizza{
- @Override
- public void make() {
- System.out.println("CheesePizza");
- }
-}
-```
-
-```java
-public class GreekPizza implements Pizza{
- @Override
- public void make() {
- System.out.println("GreekPizza");
- }
-}
-```
-
-```java
-public class SimplePizzaFactory {
- public Pizza createPizza(String type) {
- if (type.equals("cheese")) {
- return new CheesePizza();
- } else if (type.equals("greek")) {
- return new GreekPizza();
- } else {
- throw new UnsupportedOperationException();
- }
- }
-}
-```
-
-```java
-public class PizzaStore {
- public static void main(String[] args) {
- SimplePizzaFactory simplePizzaFactory = new SimplePizzaFactory();
- Pizza pizza = simplePizzaFactory.createPizza("cheese");
- pizza.make();
- }
-}
-```
-
-运行结果
-
-```java
-CheesePizza
-```
-
-# 六、工厂方法模式
-
-## 问题描述
-
-每个地区的 PizzaStore 卖的 Pizza 虽然种类相同，但是都有自己的风味。一个客户点了纽约的 cheese 种类的 Pizza 和在芝加哥点的相同种类的 Pizza 是不同的。要求设计出满足条件的 PizzaStore。
-
-## 模式定义
-
-定义了一个创建对象的接口，但由子类决定要实例化哪个类。工厂方法把实例化推迟到子类。
-
-## 模式类图
-
-在简单工厂中，创建对象的是另一个类，而在工厂方法中，是由子类来创建对象。
-
-下图中，Creator 有一个 anOperation() 方法，这个方法需要用到一组产品对象，这组产品对象由 factoryMethod() 方法创建。该方法是抽象的，需要由子类去实现。
-
- 
-
-## 问题的解决方案类图
-
-PizzaStore 有 orderPizza() 方法，顾客可以用它来下单。下单之后需要先使用 createPizza() 来制作 Pizza，这里的 createPizza() 就是 factoryMethod()，不同的 PizzaStore 子类实现了不同的 createPizza()。
-
- 
-
-## 设计原则
-
-依赖倒置原则：要依赖抽象，不要依赖具体类。听起来像是针对接口编程，不针对实现编程，但是这个原则说明了：不能让高层组件依赖底层组件，而且，不管高层或底层组件，两者都应该依赖于抽象。例如，下图中 Pizza 是抽象类，PizzaStore 和 Pizza 子类都依赖于 Pizza 这个抽象类。
-
- 
-
-## 代码实现
-
-```java
-public interface Pizza {
- public void make();
-}
-```
-```java
-public interface PizzaStore {
- public Pizza orderPizza(String item);
-}
-```
-```java
-public class NYStyleCheesePizza implements Pizza{
- @Override
- public void make() {
- System.out.println("NYStyleCheesePizza is making..");
- }
-}
-```
-```java
-public class NYStyleVeggiePizza implements Pizza {
- @Override
- public void make() {
- System.out.println("NYStyleVeggiePizza is making..");
- }
-}
-```
-```java
-public class ChicagoStyleCheesePizza implements Pizza{
- @Override
- public void make() {
- System.out.println("ChicagoStyleCheesePizza is making..");
- }
-}
-```
-```java
-public class ChicagoStyleVeggiePizza implements Pizza{
- @Override
- public void make() {
- System.out.println("ChicagoStyleVeggiePizza is making..");
- }
-}
-```
-```java
-public class NYPizzaStore implements PizzaStore {
- @Override
- public Pizza orderPizza(String item) {
- Pizza pizza = null;
- if (item.equals("cheese")) {
- pizza = new NYStyleCheesePizza();
- } else if (item.equals("veggie")) {
- pizza = new NYStyleVeggiePizza();
- } else {
- throw new UnsupportedOperationException();
- }
- pizza.make();
- return pizza;
- }
-}
-```
-```java
-public class ChicagoPizzaStore implements PizzaStore {
- @Override
- public Pizza orderPizza(String item) {
- Pizza pizza = null;
- if (item.equals("cheese")) {
- pizza = new ChicagoStyleCheesePizza();
- } else if (item.equals("veggie")) {
- pizza = new ChicagoStyleVeggiePizza();
- } else {
- throw new UnsupportedOperationException();
- }
- pizza.make();
- return pizza;
- }
-}
-```
-```java
-public class PizzaTestDrive {
- public static void main(String[] args) {
- PizzaStore nyStore = new NYPizzaStore();
- nyStore.orderPizza("cheese");
- PizzaStore chicagoStore = new ChicagoPizzaStore();
- chicagoStore.orderPizza("cheese");
- }
-}
-```
-
-运行结果
-
-```html
-NYStyleCheesePizza is making..
-ChicagoStyleCheesePizza is making..
-```
-
-# 七、抽象工厂模式
-
-## 模式定义
-
-提供一个接口，用于创建 **相关的对象家族** 。
-
-## 模式类图
-
-抽象工厂模式创建的是对象家族，也就是很多对象而不是一个对象，并且这些对象是相关的，也就是说必须一起创建出来。而工厂模式只是用于创建一个对象，这和抽象工厂模式有很大不同。
-
-抽象工厂模式用到了工厂模式来创建单一对象，在类图左部，AbstractFactory 中的 CreateProductA 和 CreateProductB 方法都是让子类来实现，这两个方法单独来看就是在创建一个对象，这符合工厂模式的定义。
-
-至于创建对象的家族这一概念是在 Client 体现，Client 要通过 AbstractFactory 同时调用两个方法来创建出两个对象，在这里这两个对象就有很大的相关性，Client 需要同时创建出这两个对象。
-
-从高层次来看，抽象工厂使用了组合，即 Cilent 组合了 AbstractFactory，而工厂模式使用了继承。
-
- 
-
-## 解决方案类图
-
- 
-
-## 代码实现
-
-```java
-public interface Dough {
- public String doughType();
-}
-```
-```java
-public class ThickCrustDough implements Dough{
-
- @Override
- public String doughType() {
- return "ThickCrustDough";
- }
-}
-```
-```java
-public class ThinCrustDough implements Dough {
- @Override
- public String doughType() {
- return "ThinCrustDough";
- }
-}
-```
-```java
-public interface Sauce {
- public String sauceType();
-}
-```
-```java
-public class MarinaraSauce implements Sauce {
- @Override
- public String sauceType() {
- return "MarinaraSauce";
- }
-}
-```
-```java
-public class PlumTomatoSauce implements Sauce {
- @Override
- public String sauceType() {
- return "PlumTomatoSauce";
- }
-}
-```
-```java
-public interface PizzaIngredientFactory {
- public Dough createDough();
- public Sauce createSauce();
-}
-```
-```java
-public class NYPizzaIngredientFactory implements PizzaIngredientFactory{
- @Override
- public Dough createDough() {
- return new ThickCrustDough();
- }
-
- @Override
- public Sauce createSauce() {
- return new MarinaraSauce();
- }
-}
-```
-```java
-public class ChicagoPizzaIngredientFactory implements PizzaIngredientFactory{
- @Override
- public Dough createDough() {
- return new ThinCrustDough();
- }
-
- @Override
- public Sauce createSauce() {
- return new PlumTomatoSauce();
- }
-}
-```
-```java
-public class NYPizzaStore {
- private PizzaIngredientFactory ingredientFactory;
-
- public NYPizzaStore() {
- ingredientFactory = new NYPizzaIngredientFactory();
- }
-
- public void makePizza() {
- Dough dough = ingredientFactory.createDough();
- Sauce sauce = ingredientFactory.createSauce();
- System.out.println(dough.doughType());
- System.out.println(sauce.sauceType());
- }
-}
-```
-```java
-public class NYPizzaStoreTestDrive {
- public static void main(String[] args) {
- NYPizzaStore nyPizzaStore = new NYPizzaStore();
- nyPizzaStore.makePizza();
- }
-}
-```
-
-运行结果
-
-```html
-ThickCrustDough
-MarinaraSauce
-```
-
-# 八、单例模式
-
-## 模式定义
+## 意图
确保一个类只有一个实例，并提供了一个全局访问点。
-## 模式类图
+## 类图
使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。
私有构造函数保证了不能通过构造函数来创建对象实例，只能通过公有静态函数返回唯一的私有静态变量。
- 
+ 
-## 懒汉式-线程不安全
+## 使用场景
+
+- Logger Classes
+- Configuration Classes
+- Accesing resources in shared mode
+- Factories implemented as Singletons
+
+## JDK 的使用
+
+- [java.lang.Runtime#getRuntime()](http://docs.oracle.com/javase/8/docs/api/java/lang/Runtime.html#getRuntime%28%29)
+- [java.awt.Desktop#getDesktop()](http://docs.oracle.com/javase/8/docs/api/java/awt/Desktop.html#getDesktop--)
+- [java.lang.System#getSecurityManager()](http://docs.oracle.com/javase/8/docs/api/java/lang/System.html#getSecurityManager--)
+
+## 实现
+
+### 懒汉式-线程不安全
以下实现中，私有静态变量 uniqueInstance 被延迟化实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 uniqueInstance，从而节约资源。
-这个实现在多线程环境下是不安全的，如果多个线程能够同时进入`if(uniqueInstance == null)` ，那么就会多次实例化 uniqueInstance。
+这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 if(uniqueInstance == null) ，那么就会多次实例化 uniqueInstance。
```java
public class Singleton {
@@ -780,9 +71,9 @@ public class Singleton {
}
```
-## 懒汉式-线程安全
+### 懒汉式-线程安全
-只需要对 `getUniqueInstance()` 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了对 uniqueInstance 进行多次实例化的问题。
+只需要对 getUniqueInstance() 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了对 uniqueInstance 进行多次实例化的问题。
但是这样有一个问题，就是当一个线程进入该方法之后，其它线程试图进入该方法都必须等待，因此性能上有一定的损耗。
@@ -795,7 +86,7 @@ public static synchronized Singleton getUniqueInstance() {
}
```
-## 饿汉式-线程安全
+### 饿汉式-线程安全
线程不安全问题主要是由于 uniqueInstance 被实例化了多次，如果 uniqueInstance 采用直接实例化的话，就不会被实例化多次，也就不会产生线程不安全问题。但是直接实例化的方式也丢失了延迟实例化带来的节约资源的优势。
@@ -803,7 +94,7 @@ public static synchronized Singleton getUniqueInstance() {
private static Singleton uniqueInstance = new Singleton();
```
-## 双重校验锁-线程安全
+### 双重校验锁-线程安全
uniqueInstance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行。也就是说，只有当 uniqueInstance 没有被实例化时，才需要进行加锁。
@@ -830,7 +121,7 @@ public class Singleton {
}
```
-考虑下面的实现，也就是只使用了一个 if 语句。在 uniqueInstance == null 的情况下，如果两个线程同时执行 if 语句，那么两个线程就会同时进入 if 语句块内。虽然在 if 语句块内有加锁操作，但是两个线程都会执行`uniqueInstance = new Singleton();`这条语句，只是早晚的问题，也就是说会进行两次实例化，从而产生了两个实例。因此必须使用双重校验锁，也就是需要使用两个 if 判断。
+考虑下面的实现，也就是只使用了一个 if 语句。在 uniqueInstance == null 的情况下，如果两个线程同时执行 if 语句，那么两个线程就会同时进入 if 语句块内。虽然在 if 语句块内有加锁操作，但是两个线程都会执行 uniqueInstance = new Singleton(); 这条语句，只是早晚的问题，也就是说会进行两次实例化，从而产生了两个实例。因此必须使用双重校验锁，也就是需要使用两个 if 判断。
```java
if (uniqueInstance == null) {
@@ -840,966 +131,228 @@ if (uniqueInstance == null) {
}
```
-# 九、命令模式
+# 四、简单工厂
-## 问题描述
+## 意图
-设计一个遥控器，它有很多按钮，每个按钮可以发起一个命令，命令会让一个家电完成相应操作。
+在创建一个对象时不向客户暴露内部细节；
- 
+## 类图
-有非常多的家电，并且之后会增加家电。
+简单工厂不是设计模式，更像是一种编程习惯。它把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个子类来实例化。
- 
+ 
-## 模式定义
+这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类。因为客户类往往有多个，如果不使用简单工厂，所有的客户类都要知道所有子类的细节。而且一旦子类发生改变，例如增加子类，那么所有的客户类都要进行修改。
-将命令封装成对象，以便使用不同的命令来参数化其它对象。
-
-## 问题的解决方案类图
-
-- RemoteControl 是遥控器，它可以为每个按钮设置命令对象，并且执行命令。
-
-- Command 是命令对象。
-
-- Light（电灯）是命令真正的执行者。
-
-- RemoteLoader 是客户端，应该注意它与 RemoteControl 的区别。因为 RemoteControl 不能主动地调用自身的方法，因此也就不能当成是客户端。客户端好比人，只有人才能去真正去使用遥控器。
-
- 
-
-## 模式类图
-
- 
-
-## 代码实现
-
-```java
-public interface Command {
- public void execute();
-}
-```
-
-```java
-public class Light {
-
- public void on() {
- System.out.println("Light is on!");
- }
-
- public void off() {
- System.out.println("Light is off!");
- }
-}
-```
-
-```java
-public class LightOnCommand implements Command{
- Light light;
-
- public LightOnCommand(Light light) {
- this.light = light;
- }
-
- @Override
- public void execute() {
- light.on();
- }
-}
-```
-
-```java
-/**
- * 遥控器类
- */
-public class SimpleRemoteControl {
- Command slot;
-
- public SimpleRemoteControl() {
-
- }
-
- public void setCommand(Command command) {
- this.slot = command;
- }
-
- public void buttonWasPressed() {
- slot.execute();
- }
-
-}
-```
-
-```java
-/**
- * 客户端
- */
-public class RemoteLoader {
- public static void main(String[] args) {
- SimpleRemoteControl remote = new SimpleRemoteControl();
- Light light = new Light();
- LightOnCommand lightOnCommand = new LightOnCommand(light);
- remote.setCommand(lightOnCommand);
- remote.buttonWasPressed();
- }
-}
-```
-
-输出
-
-```html
-Light is on!
-```
-
-# 十、适配器模式
-
-## 模式定义
-
-将一个类的接口，转换为客户期望的另一个接口。适配器让原本不兼容的类可以合作无间。
-
- 
-
-## 模式类图
-
-适配器（Adapter）组合一个适配者（Adaptee），Adapter 把操作委托给 Adaptee。
-
- 
-
-## 问题描述
-
-鸭子（Duck）和火鸡（Turkey）拥有不同的叫声，Duck 的叫声调用 quack() 方法，而 Turkey 调用 gobble() 方法。
-
-要求将 Turkey 的 gobble() 方法适配成 Duck 的 quack() 方法，从而让火鸡冒充鸭子！
-
-## 问题的解决方案类图
-
- 
-
-## 代码实现
-
-```java
-public interface Duck {
- public void quack();
-}
-```
-
-```java
-public interface Turkey {
- public void gobble();
-}
-```
-
-```java
-public class WildTurkey implements Turkey{
- @Override
- public void gobble() {
- System.out.println("gobble!");
- }
-}
-```
-
-```java
-public class TurkeyAdapter implements Duck{
- Turkey turkey;
-
- public TurkeyAdapter(Turkey turkey) {
- this.turkey = turkey;
- }
-
- @Override
- public void quack() {
- turkey.gobble();
- }
-}
-```
-
-```java
-public class DuckTestDrive {
- public static void main(String[] args) {
- Turkey turkey = new WildTurkey();
- Duck duck = new TurkeyAdapter(turkey);
- duck.quack();
- }
-}
-```
-
-运行结果
-
-```html
-gobble!
-```
-
-# 十、外观模式
-
-## 模式定义
-
-提供了一个统一的接口，用来访问子系统中的一群接口，从而让子系统更容易使用。
-
-## 模式类图
-
- 
-
-## 问题描述
-
-家庭影院中有众多电器，当要进行观看电影时需要对很多电器进行操作。要求简化这些操作，使得家庭影院类只提供一个简化的接口，例如提供一个看电影相关的接口。
-
- 
-
-## 解决方案类图
-
- 
-
-## 设计原则
-
-**最少知识原则** ：只和你的密友谈话。也就是客户对象所需要交互的对象应当尽可能少。
-
-## 代码实现
-
-过于简单，无实现。
-
-# 十一、模板方法模式
-
-## 模式定义
-
-在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。
-
-模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。
-
-## 模式类图
-
-模板方法 templateMethod() 定义了算法的骨架，确定了 primitiveOperation1() 和 primitiveOperation2() 方法执行的顺序，而 primitiveOperation1() 和 primitiveOperation2() 让子类去实现。
-
- 
-
-## 问题描述
-
-冲咖啡和冲茶都有类似的流程，但是某些步骤会有点不一样，要求复用那些相同步骤的代码。
-
- 
-
-## 问题的解决方案类图
-
-prepareRecipe() 方法就是模板方法，它确定了其它四个方法的具体执行步骤。其中 brew() 和 addCondiments() 方法在子类中实现。
-
- 
-
-## 设计原则
-
-**好莱坞原则** ：别调用（打电话给）我们，我们会调用（打电话给）你。这一原则可以防止依赖腐败，即防止高层组件依赖底层组件，底层组件又依赖高层组件。该原则在模板方法的体现为，只有父类会调用子类，子类不会调用父类。
-
-## 钩子
-
-某些步骤在不同实现中可有可无，可以先定义一个什么都不做的方法，把它加到模板方法中，如果子类需要它就覆盖默认实现并加上自己的实现。
-
-## 代码实现
-
-```java
-public abstract class CaffeineBeverage {
-
- final void prepareRecipe(){
- boilWater();
- brew();
- pourInCup();
- addCondiments();
- }
-
- abstract void brew();
-
- abstract void addCondiments();
-
- void boilWater(){
- System.out.println("boilWater");
- }
-
- void pourInCup(){
- System.out.println("pourInCup");
- }
-}
-```
-
-```java
-public class Coffee extends CaffeineBeverage{
- @Override
- void brew() {
- System.out.println("Coffee.brew");
- }
-
- @Override
- void addCondiments() {
- System.out.println("Coffee.addCondiments");
- }
-}
-```
-
-```java
-public class Tea extends CaffeineBeverage{
- @Override
- void brew() {
- System.out.println("Tea.brew");
- }
-
- @Override
- void addCondiments() {
- System.out.println("Tea.addCondiments");
- }
-}
-```
-
-```java
-public class CaffeineBeverageTestDrive {
- public static void main(String[] args) {
- CaffeineBeverage caffeineBeverage = new Coffee();
- caffeineBeverage.prepareRecipe();
- System.out.println("-----------");
- caffeineBeverage = new Tea();
- caffeineBeverage.prepareRecipe();
- }
-}
-```
-
-运行结果
-
-```html
-boilWater
-Coffee.brew
-pourInCup
-Coffee.addCondiments
------------
-boilWater
-Tea.brew
-pourInCup
-Tea.addCondiments
-```
-
-# 十二、迭代器模式
-
-## 模式定义
-
-提供顺序访问一个聚合对象中的各个元素的方法，而又不暴露聚合对象内部的表示。
-
-## 模式类图
-
-- Aggregate 是聚合类，其中 createIterator() 方法可以产生一个 Iterator；
-
-- Iterator 主要定义了 hasNext() 和 next() 方法。
-
-- Client 组合了 Aggregate，为了迭代遍历 Aggregate，也需要组合 Iterator。
-
- 
-
-## 代码实现
-
-```java
-public class Aggregate {
-
- private int[] items;
-
- public Aggregate() {
- items = new int[10];
- for (int i = 0; i < items.length; i++) {
- items[i] = i;
- }
- }
-
- public Iterator createIterator() {
- return new ConcreteIterator(items);
- }
-
-}
-```
-
-```java
-public interface Iterator {
- boolean hasNext();
- int next();
-}
-```
-
-```java
-public class ConcreteIterator implements Iterator {
-
- private int[] items;
- private int position = 0;
-
- public ConcreteIterator(int[] items) {
- this.items = items;
- }
-
- @Override
- public boolean hasNext() {
- return position < items.length;
- }
-
- @Override
- public int next() {
- return items[position++];
- }
-}
-```
-```java
-public class Client {
- public static void main(String[] args) {
- Aggregate aggregate = new Aggregate();
- Iterator iterator = aggregate.createIterator();
- while(iterator.hasNext()){
- System.out.println(iterator.next());
- }
- }
-}
-```
-运行结果
-```html
-0
-1
-2
-3
-4
-5
-6
-7
-8
-9
-```
-
-## Java 内置的迭代器
-
-需要让聚合类实现 Iterable 接口，该接口有一个 iterator() 方法会返回一个 Iterator 对象。
-
-可以使用 foreach 循环来顺序访问聚合对象中的每个元素。
-
-Java 中的集合类基本都实现了 Iterable 接口。
-
-```java
-import java.util.Iterator;
-
-public class Aggregate implements Iterable{
-
- private int[] items;
-
- public Aggregate() {
- items = new int[10];
- for (int i = 0; i < items.length; i++) {
- items[i] = i;
- }
- }
-
- @Override
- public Iterator iterator() {
- return new ConcreteIterator(items);
- }
-}
-```
-```java
-import java.util.Iterator;
-
-public class ConcreteIterator implements Iterator {
-
- private int[] items;
- private int position = 0;
-
- public ConcreteIterator(int[] items) {
- this.items = items;
- }
-
- @Override
- public boolean hasNext() {
- return position < items.length;
- }
-
- @Override
- public Integer next() {
- return items[position++];
- }
-}
-```
-```java
-public class Client {
- public static void main(String[] args) {
- Aggregate aggregate = new Aggregate();
- for (int item : aggregate) {
- System.out.println(item);
- }
- }
-}
-```
-
-# 十三、组合模式
-
-## 设计原则
-
-一个类应该只有一个引起它改变的原因。
-
-## 模式定义
-
-允许将对象组合成树形结构来表现“整体/部分”关系。
-
-组合能让客户以一致的方式处理个别对象以及组合对象。
-
-## 模式类图
-
-组件（Component）类是组合类（Composite）和叶子类（Leaf）的父类，可以把组合类看成是树的中间节点。
-
-组合对象拥有一个组件对象，因此组合对象的操作可以委托给组件对象去处理，而组件对象可以是另一个组合对象或者叶子对象。
-
- 
-
-## 代码实现
-
-```java
-public abstract class Component {
- protected String name;
-
- public Component(String name) {
- this.name = name;
- }
-
- abstract public void addChild(Component component);
-
- public void print() {
- print(0);
- }
-
- abstract protected void print(int level);
-}
-```
-
-```java
-public class Leaf extends Component {
- public Leaf(String name) {
- super(name);
- }
-
- @Override
- public void addChild(Component component) {
- throw new UnsupportedOperationException(); // 牺牲透明性换取单一职责原则，这样就不用考虑是叶子节点还是组合节点
- }
-
- @Override
- protected void print(int level) {
- for (int i = 0; i < level; i++) {
- System.out.print("--");
- }
- System.out.println("left:" + name);
- }
-}
-```
-
-```java
-public class Composite extends Component {
-
- private List childs;
-
- public Composite(String name) {
- super(name);
- childs = new ArrayList<>();
- }
-
- @Override
- public void addChild(Component component) {
- childs.add(component);
- }
-
- @Override
- protected void print(int level) {
- for (int i = 0; i < level; i++) {
- System.out.print("--");
- }
- System.out.println("Composite:" + name);
- for (Component component : childs) {
- component.print(level + 1);
- }
- }
-}
-```
+如果存在下面这种代码，就需要使用简单工厂将对象实例化的部分放到简单工厂中。
```java
public class Client {
public static void main(String[] args) {
- Composite root = new Composite("root");
- Component node1 = new Leaf("1");
- Component node2 = new Composite("2");
- Component node3 = new Leaf("3");
- root.addChild(node1);
- root.addChild(node2);
- root.addChild(node3);
- Component node21 = new Leaf("21");
- Component node22 = new Composite("22");
- node2.addChild(node21);
- node2.addChild(node22);
- Component node221 = new Leaf("221");
- node22.addChild(node221);
- root.print();
- }
-}
-```
-运行结果
-
-```html
-Composite:root
---left:1
---Composite:2
-----left:21
-----Composite:22
-------left:221
---left:3
-```
-
-# 十四、状态模式
-
-## 模式定义
-
-允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它所属的类。
-
-## 模式类图
-
-Context 的 request() 方法委托给 State 对象去处理。当 Context 组合的 State 对象发生改变时，它的行为也就发生了改变。
-
- 
-
-## 与策略模式的比较
-
-状态模式的类图和策略模式一样，并且都是能够动态改变对象的行为。
-
-但是状态模式是通过状态转移来改变 Context 所组合的 State 对象，而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。
-
-所谓的状态转移，是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变，注意必须要是在运行过程中。
-
-状态模式主要是用来解决状态转移的问题，当状态发生转移了，那么 Context 对象就会改变它的行为；而策略模式主要是用来封装一组可以互相替代的算法族，并且可以根据需要动态地去替换 Context 使用的算法。
-
-## 问题描述
-
-糖果销售机有多种状态，每种状态下销售机有不同的行为，状态可以发生转移，使得销售机的行为也发生改变。
-
- 
-
-## 直接解决方案
-
-在糖果机的每个操作函数里面，判断当前的状态，根据不同的状态进行不同的处理，并且发生不同的状态转移。
-
-这种解决方案在需要增加状态的时候，必须对每个操作的代码都进行修改。
-
- 
-
-## 代码实现
-
-糖果销售机即 Context。
-
-下面的实现中每个 State 都组合了 Context 对象，这是因为状态转移的操作在 State 对象中，而状态转移过程又必须改变 Context 对象的 state 对象，因此 State 必须组合 Context 对象。
-
-```java
-public interface State {
- /**
- * 投入 25 分钱
- */
- void insertQuarter();
-
- /**
- * 退回 25 分钱
- */
- void ejectQuarter();
-
- /**
- * 转动曲柄
- */
- void turnCrank();
-
- /**
- * 发放糖果
- */
- void dispense();
-}
-```
-```java
-public class HasQuarterState implements State{
-
- private GumballMachine gumballMachine;
-
- public HasQuarterState(GumballMachine gumballMachine){
- this.gumballMachine = gumballMachine;
- }
-
- @Override
- public void insertQuarter() {
- System.out.println("You can't insert another quarter");
- }
-
- @Override
- public void ejectQuarter() {
- System.out.println("Quarter returned");
- gumballMachine.setState(gumballMachine.getNoQuarterState());
- }
-
- @Override
- public void turnCrank() {
- System.out.println("You turned...");
- gumballMachine.setState(gumballMachine.getSoldState());
- }
-
- @Override
- public void dispense() {
- System.out.println("No gumball dispensed");
- }
-}
-```
-```java
-public class NoQuarterState implements State {
-
- GumballMachine gumballMachine;
-
- public NoQuarterState(GumballMachine gumballMachine) {
- this.gumballMachine = gumballMachine;
- }
-
- @Override
- public void insertQuarter() {
- System.out.println("You insert a quarter");
- gumballMachine.setState(gumballMachine.getHasQuarterState());
- }
-
- @Override
- public void ejectQuarter() {
- System.out.println("You haven't insert a quarter");
- }
-
- @Override
- public void turnCrank() {
- System.out.println("You turned, but there's no quarter");
- }
-
- @Override
- public void dispense() {
- System.out.println("You need to pay first");
- }
-}
-```
-```java
-public class SoldOutState implements State {
-
- GumballMachine gumballMachine;
-
- public SoldOutState(GumballMachine gumballMachine) {
- this.gumballMachine = gumballMachine;
- }
-
- @Override
- public void insertQuarter() {
- System.out.println("You can't insert a quarter, the machine is sold out");
- }
-
- @Override
- public void ejectQuarter() {
- System.out.println("You can't eject, you haven't inserted a quarter yet");
- }
-
- @Override
- public void turnCrank() {
- System.out.println("You turned, but there are no gumballs");
- }
-
- @Override
- public void dispense() {
- System.out.println("No gumball dispensed");
- }
-}
-```
-```java
-public class SoldState implements State {
-
- GumballMachine gumballMachine;
-
- public SoldState(GumballMachine gumballMachine) {
- this.gumballMachine = gumballMachine;
- }
-
- @Override
- public void insertQuarter() {
- System.out.println("Please wait, we're already giving you a gumball");
- }
-
- @Override
- public void ejectQuarter() {
- System.out.println("Sorry, you already turned the crank");
- }
-
- @Override
- public void turnCrank() {
- System.out.println("Turning twice doesn't get you another gumball!");
- }
-
- @Override
- public void dispense() {
- gumballMachine.releaseBall();
- if(gumballMachine.getCount()>0){
- gumballMachine.setState(gumballMachine.getNoQuarterState());
- } else{
- System.out.println("Oops, out of gumballs");
- gumballMachine.setState(gumballMachine.getSoldOutState());
- }
- }
-}
-```
-```java
-public class GumballMachine {
-
- private State soldOutState;
- private State noQuarterState;
- private State hasQuarterState;
- private State soldState;
-
- private State state;
- private int count = 0;
-
- public GumballMachine(int numberGumballs) {
- count = numberGumballs;
- soldOutState = new SoldOutState(this);
- noQuarterState = new NoQuarterState(this);
- hasQuarterState = new HasQuarterState(this);
- soldState = new SoldState(this);
-
- if (numberGumballs > 0) {
- state = noQuarterState;
+ int type = 1;
+ Product product;
+ if (type == 1) {
+ product = new ConcreteProduct1();
+ } else if (type == 2) {
+ product = new ConcreteProduct2();
} else {
- state = soldOutState;
+ product = new ConcreteProduct();
}
}
-
- public void insertQuarter() {
- state.insertQuarter();
- }
-
- public void ejectQuarter() {
- state.ejectQuarter();
- }
-
- public void turnCrank() {
- state.turnCrank();
- state.dispense();
- }
-
- public void setState(State state) {
- this.state = state;
- }
-
- public void releaseBall() {
- System.out.println("A gumball comes rolling out the slot...");
- if (count != 0) {
- count -= 1;
- }
- }
-
- public State getSoldOutState() {
- return soldOutState;
- }
-
- public State getNoQuarterState() {
- return noQuarterState;
- }
-
- public State getHasQuarterState() {
- return hasQuarterState;
- }
-
- public State getSoldState() {
- return soldState;
- }
-
- public int getCount() {
- return count;
- }
}
```
+
+## 实现
+
```java
-public class GumballMachineTestDrive {
+public interface Product {
+}
+```
- public static void main(String[] args) {
- GumballMachine gumballMachine = new GumballMachine(5);
+```java
+public class ConcreteProduct implements Product{
+}
+```
- gumballMachine.insertQuarter();
- gumballMachine.turnCrank();
+```java
+public class ConcreteProduct1 implements Product{
+}
+```
- gumballMachine.insertQuarter();
- gumballMachine.ejectQuarter();
- gumballMachine.turnCrank();
+```java
+public class ConcreteProduct2 implements Product{
+}
+```
- gumballMachine.insertQuarter();
- gumballMachine.turnCrank();
- gumballMachine.insertQuarter();
- gumballMachine.turnCrank();
- gumballMachine.ejectQuarter();
-
- gumballMachine.insertQuarter();
- gumballMachine.insertQuarter();
- gumballMachine.turnCrank();
- gumballMachine.insertQuarter();
- gumballMachine.turnCrank();
- gumballMachine.insertQuarter();
- gumballMachine.turnCrank();
+```java
+public class SimpleFactory {
+ public Product createProduct(int type) {
+ if (type == 1) {
+ return new ConcreteProduct1();
+ } else if (type == 2) {
+ return new ConcreteProduct2();
+ }
+ return new ConcreteProduct();
}
}
```
-运行结果
-```html
-You insert a quarter
-You turned...
-A gumball comes rolling out the slot...
-You insert a quarter
-Quarter returned
-You turned, but there's no quarter
-You need to pay first
-You insert a quarter
-You turned...
-A gumball comes rolling out the slot...
-You insert a quarter
-You turned...
-A gumball comes rolling out the slot...
-You haven't insert a quarter
-You insert a quarter
-You can't insert another quarter
-You turned...
-A gumball comes rolling out the slot...
-You insert a quarter
-You turned...
-A gumball comes rolling out the slot...
-Oops, out of gumballs
-You can't insert a quarter, the machine is sold out
-You turned, but there are no gumballs
-No gumball dispensed
+
+```java
+public class Client {
+ public static void main(String[] args) {
+ SimpleFactory simpleFactory = new SimpleFactory();
+ Product product = simpleFactory.createProduct(1);
+ }
+}
```
-# 十五、代理模式
-# 十六、MVC
+# 五、工厂方法模式
-## 传统 MVC
+## 意图
-视图使用组合模式，模型使用了观察者模式，控制器使用了策略模式。
+定义了一个创建对象的接口，但由子类决定要实例化哪个类。工厂方法把实例化推迟到子类。
- 
+## 类图
-## Web 中的 MVC
+在简单工厂中，创建对象的是另一个类，而在工厂方法中，是由子类来创建对象。
-模式不再使用观察者模式。
+下图中，Factory 有一个 doSomethind() 方法，这个方法需要用到一组产品对象，这组产品对象由 factoryMethod() 方法创建。该方法是抽象的，需要由子类去实现。
- 
+ 
-# 十七、与设计模式相处
+## 实现
-## 定义
+```java
+public abstract class Factory {
+ abstract public Product factoryMethod();
+ public void doSomethind() {
+ Product product = factoryMethod();
+ // do something with the product
+ }
+}
+```
-在某情境下，针对某问题的某种解决方案。
+```java
+public class ConcreteFactory extends Factory {
+ public Product factoryMethod() {
+ return new ConcreteProduct();
+ }
+}
+```
-## 何时使用
+```java
+public class ConcreteFactory1 extends Factory{
+ public Product factoryMethod() {
+ return new ConcreteProduct1();
+ }
+}
+```
-过度使用设计模式可能导致代码被过度工程化，应该总是用最简单的解决方案完成工作，并在真正需要模式的地方才使用它。
+```java
+public class ConcreteFactory2 extends Factory {
+ public Product factoryMethod() {
+ return new ConcreteProduct2();
+ }
+}
+```
-## 反模式
+# 六、抽象工厂模式
-不好的解决方案来解决一个问题。主要作用是为了警告人们不要使用这些解决方案。
+## 意图
-## 模式分类
+提供一个接口，用于创建 **相关的对象家族** 。
- 
+## 类图
+
+ 
+
+抽象工厂模式创建的是对象家族，也就是很多对象而不是一个对象，并且这些对象是相关的，也就是说必须一起创建出来。而工厂模式只是用于创建一个对象，这和抽象工厂模式有很大不同。
+
+抽象工厂模式用到了工厂模式来创建单一对象，在类图左部，AbstractFactory 中的 createProductA 和 createProductB 方法都是让子类来实现，这两个方法单独来看就是在创建一个对象，这符合工厂模式的定义。
+
+至于创建对象的家族这一概念是在 Client 体现，Client 要通过 AbstractFactory 同时调用两个方法来创建出两个对象，在这里这两个对象就有很大的相关性，Client 需要同时创建出这两个对象。
+
+从高层次来看，抽象工厂使用了组合，即 Cilent 组合了 AbstractFactory，而工厂模式使用了继承。
+
+
+## 代码实现
+
+```java
+public class AbstractProductA {
+}
+```
+
+```java
+public class AbstractProductB {
+}
+```
+
+```java
+public class ProductA1 extends AbstractProductA {
+}
+```
+
+```java
+public class ProductA2 extends AbstractProductA {
+}
+```
+
+```java
+public class ProductB1 extends AbstractProductB{
+}
+```
+
+```java
+public class ProductB2 extends AbstractProductB{
+}
+```
+
+```java
+public abstract class AbstractFactory {
+ abstract AbstractProductA createProductA();
+ abstract AbstractProductB createProductB();
+}
+```
+
+```java
+public class ConcreteFactory1 extends AbstractFactory{
+ AbstractProductA createProductA() {
+ return new ProductA1();
+ }
+
+ AbstractProductB createProductB() {
+ return new ProductB1();
+ }
+}
+```
+
+```java
+public class ConcreteFactory2 extends AbstractFactory {
+ AbstractProductA createProductA() {
+ return new ProductA2();
+ }
+
+ AbstractProductB createProductB() {
+ return new ProductB2();
+ }
+}
+```
+
+```java
+public class Client {
+ public static void main(String[] args) {
+ AbstractFactory abstractFactory = new ConcreteFactory1();
+ AbstractProductA productA = abstractFactory.createProductA();
+ abstractFactory = new ConcreteFactory2();
+ productA = abstractFactory.createProductA();
+ }
+}
+```
# 参考资料
- 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
+- [Design Patterns](http://www.oodesign.com/)
+- [Design patterns implemented in Java](http://java-design-patterns.com/)
diff --git a/pics/a8644ee5-dc04-40b6-8492-e2d3c922eb04.png b/pics/a8644ee5-dc04-40b6-8492-e2d3c922eb04.png
new file mode 100644
index 0000000000000000000000000000000000000000..3e9cd4e7c2cdc7b597fd3743fe1d4af8a3e23b39
GIT binary patch
literal 41984
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�bPd!`0R7}#ewcMq7#?K2AqRU9XdW<06XjFi6?hC
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