💫你好，我是小航，一个正在变秃、变强的准大三党
💫本文主要讲解设计模式，示例Demo采用Java语言演示
💫欢迎大家的关注！

一、设计模式简介

1、什么是设计模式？

在软件工程中，设计模式是对软件设计中普遍存在的各种问题，所提出的解决方案。
换句话说，设计模式是一套被反复使用、多数人知晓的、经过分类的、代码设计的经验总结。使用设计模式是为了可重用代码，让代码更容易被他人理解，保证代码可靠性。

2、设计模式原则

1、开闭原则（Open Close Principle）
开闭原则的意思是： 对扩展开放，对修改封闭 。在程序需要进行扩展的时候，不能去修改或影响原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性更好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类。
2、里氏代换原则（Liskov Substitution Principle）
里氏代换原则是面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。里氏代换原则是继承复用的基石，只有当子类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而且子类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。里氏替换原则通俗来讲就是:子类可以扩展父类的功能,但不能改变父类原有的功能。
3、依赖倒转原则（Dependence Inversion Principle）
这个原则是开闭原则的基础，核心内容：针对接口编程，高层模块不应该依赖底层模块，二者都应该依赖抽象而不依赖于具体。
4、接口隔离原则（Interface Segregation Principle）
这个原则的意思是：使用多个隔离的接口，比使用单个庞大的接口要好。其目的在于降低耦合度。由此可见，其实设计模式就是从大型软件架构出发，便于升级和维护软件的设计思想。它强调低依赖、低耦合。
5、单一职责原则（Single Responsibility Principle）
类的职责要单一，不能将太多的职责放在一个类中。
可能有的人会觉得单一职责原则和前面的接口隔离原则很相似，其实不然。其一，单一职责原则原注重的是职责；而接口隔离原则注重对接口依赖的隔离。其二，单一职责原则主要约束的是类，其次才是接口和方法，它针对的是程序中的实现和细节；而接口隔离原则主要约束接口，主要针对抽象，针对程序整体框架的构建。
6、最少知道原则（Demeter Principle）
最少知道原则也叫迪米特法则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
一个对象应该对其他对象保持最少的了解。类与类之间的关系越密切，耦合度越大，当一个类发生改变时，对另一个类的影响也越大。如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某一个方法的话，可以通过第三者转发这个调用。所以在类的设计上，每一个类都应当尽量降低成员的访问权限。
7、合成复用原则（Composite Reuse Principle）
合成复用原则就是在一个新的对象里通过关联关系（组合关系、聚合关系）来使用一些已有的对象，使之成为新对象的一部分；新对象通过委派调用已有对象的方法达到复用功能的目的。简而言之，尽量多使用组合/聚合 的方式，尽量少使用甚至不使用继承关系。

3、设计模式分类

通常来说设计模式分为三大类：

创建型模式，共 5 种：工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共 7 种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共 11 种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

下面用图片来整体描述一下设计模式之间的关系：
在这里插入图片描述

二、常用设计模式

1、工厂模式

1.1 什么是工厂模式

工厂模式（Factory Pattern）的意义就跟它的名字一样，在面向对象程序设计中，工厂通常是一个用来创建其他对象的对象。工厂模式根据不同的参数来实现不同的分配方案和创建对象。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。例如将工厂比作女娲娘娘，用女娲娘娘来创建人这个对象，如果我们需要一个男人对象，女娲娘娘就会为我们创建一个男人；如果我们需要一个女人，女娲娘娘就会为我们生产一个女人。

1.2 工厂模式分类

工厂模式通常分为：

普通工厂模式
多个工厂方法模式
静态工厂方法模式

1.2.1 普通工厂模式

刚刚我们说到，用工厂模式来创建人。先创建一个男人，他每天都“吃饭、睡觉、打豆豆”，然后我们再创建一个女人，她每天也“吃饭、睡觉、打豆豆”。

工厂模式类图
在这里插入图片描述
我们以普通工厂模式为例，在 project 目录下新建一个 FactoryTest.java 。示例代码文末会以gitee地址给出。

示例代码如下：

// 定义 Female 和 Male 共同的接口
interface Human {
    public void eat(); // 吃饭
    public void sleep(); // 睡觉
    public void beat(); // 打豆豆
}
// 创建实现类 Male
class Male implements Human {
    @Override
    public void eat() {
        System.out.println("Male can eat.");
    }

    @Override
    public void sleep() {
        System.out.println("Male can sleep.");
    }

    @Override
    public void beat() {
        System.out.println("Male can beat.");
    }
}
// 创建实现类 Female
class Female implements Human {
    @Override
    public void eat() {
        System.out.println("Female can eat.");
    }

    @Override
    public void sleep() {
        System.out.println("Female can sleep.");
    }

    @Override
    public void beat() {
        System.out.println("Female can beat.");
    }
}
// 创建普通工厂类
class HumanFactory {
    public Human createHuman(String gender) {
        if("male".equals(gender)) {
            return new Male();
        }else if( "female".equals(gender)) {
            return new Female();
        }else {
            System.out.println("请输入正确的类型！");
            return null;
        }
    }
}
// 工厂测试类
class FactoryTest {
    public static void main(String[] args) {
        HumanFactory humanFactory = new HumanFactory();
        Human female = humanFactory.createHuman("female");
        female.eat();
        female.sleep();
        female.beat();
    }
}

运行结果：

Female can eat.
Female can sleep.
Female can beat.

1.2.2 多个工厂方法模式

普通工厂模式就是上面那样子了，那么多个工厂方法模式又有什么不同呢？在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象。多个工厂方法模式是提供多个工厂方法，分别创建对象。
将上面的普通工厂模式的 HumanFactory.java 和 FactoryTest.java 修改如下即可：

// 多个工厂方法
class HumanFactory1 {
    public Male creatMale() {
        return new Male();
    }

    public Female createFemale() {
        return new Female();
    }
}

// 工厂测试类
class FactoryTest {
    public static void main(String[] args) {
        HumanFactory1 humanFactory1 = new HumanFactory1();
        Male male = humanFactory1.creatMale();
        male.eat();
        male.sleep();
        male.sleep();
    }
}

运行结果：

Male can eat.
Male can sleep.
Male can sleep.

1.2.3 静态工厂方法模式

将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

// 多个工厂方法
class HumanFactory2 {
    public static Male creatMale() {
        return new Male();
    }

    public static Female createFemale() {
        return new Female();
    }
}

// 工厂测试类
class FactoryTest {
    public static void main(String[] args) {
        Female female = HumanFactory2.createFemale();
        female.eat();
        female.sleep();
        female.beat();
    }
}

总结：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。

1.2.4 工厂模式应用

你可能就问了，工厂模式工厂模式的，我咋没见过哪儿用过啊？这这这儿，在 Java 库里面。根据不同的参数， getInstance() 方法会返回不同的 Calendar 对象。

java.util.Calendar - getInstance()
java.util.Calendar - getInstance(TimeZone zone)
java.util.Calendar - getInstance(Locale aLocale)
java.util.Calendar - getInstance(TimeZone zone, Locale aLocale)
java.text.NumberFormat - getInstance()
java.text.NumberFormat - getInstance(Locale inLocale)

写 Android 的童鞋们，应该还知道 BitmapFactory , 这也是工厂模式的一种应用。

以上的示例代码整体一览：

/**
 * @author xh
 */

// 定义 Female 和 Male 共同的接口
interface Human {
    public void eat(); // 吃饭

    public void sleep(); // 睡觉

    public void beat(); // 打豆豆
}

// 创建实现类 Male
class Male implements Human {
    @Override
    public void eat() {
        System.out.println("Male can eat.");
    }

    @Override
    public void sleep() {
        System.out.println("Male can sleep.");
    }

    @Override
    public void beat() {
        System.out.println("Male can beat.");
    }
}

// 创建实现类 Female
class Female implements Human {
    @Override
    public void eat() {
        System.out.println("Female can eat.");
    }

    @Override
    public void sleep() {
        System.out.println("Female can sleep.");
    }

    @Override
    public void beat() {
        System.out.println("Female can beat.");
    }
}

// 创建普通工厂类
class HumanFactory {
    public Human createHuman(String gender) {
        if ("male".equals(gender)) {
            return new Male();
        } else if ("female".equals(gender)) {
            return new Female();
        } else {
            System.out.println("请输入正确的类型！");
            return null;
        }
    }
}

// 多个工厂方法
class HumanFactory1 {
    public Male creatMale() {
        return new Male();
    }

    public Female createFemale() {
        return new Female();
    }
}

// 多个工厂方法
class HumanFactory2 {
    public static Male creatMale() {
        return new Male();
    }

    public static Female createFemale() {
        return new Female();
    }
}

// 工厂测试类
class FactoryTest {
    public static void main(String[] args) {
//        HumanFactory humanFactory = new HumanFactory();
//        Human female = humanFactory.createHuman("female");
//        female.eat();
//        female.sleep();
//        female.beat();

//        HumanFactory1 humanFactory1 = new HumanFactory1();
//        Male male = humanFactory1.creatMale();
//        male.eat();
//        male.sleep();
//        male.sleep();

        Female female = HumanFactory2.createFemale();
        female.eat();
        female.sleep();
        female.beat();
    }
}

2、抽象工厂模式

2.1 抽象工厂模式定义

抽象工厂模式（Abstract Factory Pattern）是一种软件开发设计模式。抽象工厂模式提供了一种方式，可以将一组具有同一主题的单独的工厂封装起来。如果比较抽象工厂模式和工厂模式，我们不难发现前者只是在工厂模式之上增加了一层抽象的概念。抽象工厂是一个父类工厂，可以创建其它工厂类。所以我们也叫它 “工厂的工厂”。（想想上节课的 “女娲娘娘”，这简直就是 “女娲娘娘的亲娘” 啊...）

2.2 抽象工厂模式类图

“女娲娘娘”只有一个，而我们的工厂却可以有多个，因此在这里用作例子就不合适了。作为“女娲娘娘”生产出来的男人女人们，那就让我们来当一次吃货吧。（吃的东西总可以任性多来一点）
现在，假设我们有 A、B 两个厨房。每个厨房拥有的餐具和食品都不一样，但是用户搭配使用的方式，比如刀子和苹果、杯子和牛奶等等，我们假设是一致的。
在这里插入图片描述
抽象工厂模式示例

在 project 中新建 Foodaholic.java

/**
 * @author xh
 */
// 抽象食物
interface Food {
    public String getFoodName();
}
// 抽象餐具
interface TableWare {
    public String getToolName();
}
// 抽象工厂
interface KitchenFactory {
    public Food getFood();
    public TableWare getTableWare();
}
// 具体食物 Apple 的定义如下
class Apple implements Food{
    @Override
    public String getFoodName() {
        return "apple";
    }
}
// 具体餐具 Knife 的定义如下
class Knife implements TableWare {
    @Override
    public String getToolName() {
        return "knife";
    }
}
// 以具体工厂 AKitchen 为例
class AKitchen implements KitchenFactory {
    @Override
    public Food getFood() {
        return new Apple();
    }
    @Override
    public TableWare getTableWare() {
        return new Knife();
    }
}
public class Foodaholic {
    public void eat(KitchenFactory k) {
        System.out.println("A foodaholic is eating "+
                k.getFood().getFoodName()
                + " with " + k.getTableWare().getToolName() );
    }
    public static void main(String[] args) {
        Foodaholic fh = new Foodaholic();
        KitchenFactory kf = new AKitchen();
        fh.eat(kf);
    }
}

运行结果：

A foodaholic is eating apple with knife

2.3 抽象工厂模式应用

抽象工厂模式特别适合于这样的一种产品结构：产品分为几个系列，在每个系列中，产品的布局都是类似的，在一个系列中某个位置的产品，在另一个系列中一定有一个对应的产品。这样的产品结构是存在的，这几个系列中同一位置的产品可能是互斥的，它们是针对不同客户的解决方案，每个客户都只选择其一。

工厂方法模式、抽象工厂模式区别

工厂方法模式、抽象工厂模式，傻傻分不清楚。
为了解释得更清楚，先介绍两个概念：

产品等级结构：比如一个抽象类是食物，其子类有苹果、牛奶等等，则抽象食物与具体食物名称之间构成了一个产品等级结构。食物是抽象的父类，而具体的食物名称是其子类。
产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。如 AKitchen 生产的苹果、刀子，苹果属于食物产品等级结构中，而刀子则属于餐具产品等级结构中。而 BKitchen 可能生成另一组产品，如牛奶、杯子。

因此工厂方法模式、抽象工厂模式最大的区别在于：

工厂方法模式：针对的是一个产品等级结构。
抽象工厂模式：针对多个产品等级结构。

吃货们，懂了吧？

3、适配器模式

3.1 适配器模式的定义

顾名思义，适配器模式（Adapter Pattern）当然是用来适配的啦。当你想使用一个已有的类，但是这个类的接口跟你的又不一样，不能拿来直接用，这个时候你就需要一个适配器来帮你了。
这就好像你兴冲冲地跑去香港，买了个港版的 iPhone6，充电器插头拿回家一看，不能用啊。这时候你多么需要买一个转接头适配器...
在这里插入图片描述
你去香港旅游，买的 iPhone6 的充电器插头是英标的，它是那种三脚是方形的插头。

而咱们国标的插头是两只脚，即使是三只脚的插头也和英标不一样。

为了方便，这里我们就假设国标插头就只是两只脚的插头吧。（其实我是懒。。）
在这里插入图片描述
好的，目标明确，英标三只脚插头充电，国标两只脚插头充电。你家很富，有很多插座可以充电

3.2 适配器模式类图

在这里插入图片描述
适配器模式示例代码

在国内的家中只能用国标接口进行充电。

/**
 * @author xh
 * 国标插头
 */
public interface CnPluginInterface {
    void chargeWith2Pins();
}


/**
 * @author xh
 * 实现国标插座的充电方法
 */
public class CnPlugin implements CnPluginInterface{
    @Override
    public void chargeWith2Pins() {
        System.out.println("charge with CnPlugin");
    }
}


/**
 * @author xh
 * 在国内家中充电
 */
public class Home {
    private CnPluginInterface cnPlugin;

    public Home() {}

    public Home(CnPluginInterface cnPlugin) {
        this.cnPlugin = cnPlugin;
    }

    public void setPlugin(CnPluginInterface cnPlugin) {
        this.cnPlugin = cnPlugin;
    }

    // 充电
    public void charge() {
        // 国标充电
        cnPlugin.chargeWith2Pins();
    }
}


/**
 * @author xh
 */
public class CnTest {
    public static void main(String[] args) {
        CnPlugin cnPlugin = new CnPlugin();
        Home home = new Home(cnPlugin);
        home.charge();
    }
}

运行结果：

charge with CnPlugin

然而，当把 iPhone6 带回来时，因为与家里的插座不匹配，所以需要一个适配器。这个适配器必须满足以下条件：

插头必须符合国内标准的接口，否则的话还是没办法插到国内插座中。
在调用上面实现的国标接口进行充电时，提供一种机制，将这个调用转到对英标接口的调用。

这就要求：

适配器必须实现原有的旧的接口。
适配器对象中持有对新接口的引用，当调用旧接口时，将这个调用委托给实现新接口的对象来处理，也就是在适配器对象中组合一个新接口。

示例代码：

/**
 * @author xh
 * 英标插头
 */
public interface EnPluginInterface {
    void chargeWith3Pins();
}

/**
 * @author xh
 * 实现英标插座的充电方法
 */
public class EnPlugin implements EnPluginInterface{
    @Override
    public void chargeWith3Pins() {
        System.out.println("charge with EnPlugin");
    }
}

/**
 * @author xh
 * 适配器
 */
public class PluginAdapter implements CnPluginInterface{
    private EnPluginInterface enPlugin;

    public PluginAdapter(EnPluginInterface enPlugin) {
        this.enPlugin = enPlugin;
    }

    /**
     * 这是重点，适配器实现了国标的插头，然后重写国标的充电方法，在国标的充电方法中调用英标的充电方法
      */
    @Override
    public void chargeWith2Pins() {
        enPlugin.chargeWith3Pins();
    }
}


/**
 * @author xh
 * 适配器测试类
 */
public class AdapterTest {
    public static void main(String[] args) {
        EnPluginInterface enPlugin = new EnPlugin();
        Home home = new Home();
        PluginAdapter pluginAdapter = new PluginAdapter(enPlugin);
        home.setPlugin(pluginAdapter);
        home.charge();
    }
}

运行结果：

charge with EnPlugin

这样就实现了对 iphone6 进行充电。

3.3 适配器模式的应用

前面已经说了，当你想使用一个已有的类，但是这个类的接口跟你的又不一样，不能拿来直接用，这个时候你就需要一个适配器来帮你了，其主要作用就是在旧的接口、新的接口之间完成适配。
比如说，做过 Android 的同学肯定写 ListView 的适配器都写吐了吧...
适配器模式的三个特点：

适配器对象实现原有接口
适配器对象组合一个实现新接口的对象（这个对象也可以不实现一个接口，只是一个单纯的对象）
对适配器原有接口方法的调用被委托给新接口的实例的特定方法

4、装饰者模式

4.1 装饰者模式定义

装饰者模式（Decorator Pattern，有的也用 Wrapper Pattern）就是动态地把职责附加到已有对象上去，实现功能扩展。这种特性，使得装饰者模式提供了比继承更具有弹性的解决方案。
提到装饰者模式，总让我想起卞之琳的《断章》来：

你站在桥上看风景，看风景的人在楼上看你。明月装饰了你的窗子，你装饰了别人的梦。

多么有意境啊，单身狗读完会不会觉得心好累，没关系，我来拯救你！

4.2 装饰者模式类图

送你一个女朋友怎么样！想她是美国Girl？法国Girl？中国Girl？OK，没问题！你想她是哪个国家的就是哪个国家的。她们有不同的爱好或者习惯，每一个这样的女孩，都可以看作是一个 Java 类。我知道此刻你一定在想，这一个、那一个...那岂不是有很多类？这种方式没有扩展性，每当有一个新类型的女孩，就得又新建一个类，这简直就是类爆炸啊！

在这里插入图片描述
装饰者模式示例：

/**
 * @author xh
 * 抽象类 Girl
 */
abstract class Girl {
    String description = "no particular";

    public String getDescription() {
        return description;
    }
}


/**
 * @author xh
 * 中国Girl
 */
public class ChineseGirl extends Girl {
    public ChineseGirl() {
        description = "+ChineseGirl";
    }
}

/**
 * @author xh
 * 美国Girl
 */
public class AmericanGirl extends Girl {
    public AmericanGirl() {
        description = "+AmericanGirl";
    }
}

#############

/**
 * @author xh
 * 装饰者
 */
abstract class GirlDecorator extends Girl {
    @Override
    public abstract String getDescription();
}

/**
 * @author xh
 * 给美国Girl加上金发
 */
public class GoldenHair extends GirlDecorator {
    private Girl girl;

    public GoldenHair(Girl g) {
        girl = g;
    }

    @Override
    public String getDescription() {
        return girl.getDescription() + "+with golden hair";
    }
}

/**
 * @author xh
 * 加上身材高大的特性
 */
public class Tall extends GirlDecorator {
    private Girl girl;

    public Tall(Girl g) {
        girl = g;
    }

    @Override
    public String getDescription() {
        return girl.getDescription() + "+is very tall";
    }
}

###########

/**
 * @author xh
 * 测试
 */
public class Test {
    public static void main(String[] args) {
        Girl g1 = new AmericanGirl();
        System.out.println(g1.getDescription());
        GoldenHair g2 = new GoldenHair(g1);
        System.out.println(g2.getDescription());
        Tall g3 = new Tall(g2);
        System.out.println(g3.getDescription());
        // 你也可以一步到位
        // Girl g = new Tall(new GoldenHair(new AmericanGirl()));
    }
}

运行结果：

+AmericanGirl
+AmericanGirl+with golden hair
+AmericanGirl+with golden hair+is very tall

4.3 装饰者模式应用

当你需要动态地给一个对象添加功能，实现功能扩展的时候，就可以使用装饰者模式。
Java IO 类中有一个经典的装饰者模式应用， BufferedReader 装饰了 InputStreamReader 。

BufferedReader input = new BufferedReader(new InputStreamReader(System.in));

InputStreamReader(InputStream in) - InputSteamReader 读取 bytes 字节内容，然后转换成 characters 流输出。
BufferedReader(Reader in) - 从 characters 流中读取内容并缓存。

装饰者模式、适配器模式区别

关于新职责：适配器也可以在转换时增加新的职责，但其主要目的并不在此；而装饰者模式主要目的，就是给被装饰者增加新职责用的。
关于原接口：适配器模式是用新接口来调用原接口，原接口对新系统来说是不可见或者说不可用的；而装饰者模式原封不动的使用原接口，系统对装饰的对象也通过原接口来完成使用。
关于其包裹的对象：适配器是知道被适配者的详细情况的（就是那个类或那个接口）；而装饰者只知道其接口是什么，至于其具体类型（是基类还是其他派生类）只有在运行期间才知道。

5、观察者模式

5.1 观察者模式定义

一句话，观察者模式（Observer Pattern）就是一种 “发布者-订阅者” 的模式。有时也被称为“模型-视图”模式、“源-监听者”模式等。在这种模式中，由一个目标对象来管理所有依赖与它的观察者对象，并且当这个目标对象自身发生改变时，会主动向它的观察者们发出通知。

5.2 观察者模式类图

比如你最近在追一个美剧《黑袍纠察队》，假设著名在线视频网站某奇艺买下独家版权，在线更新与播放。于是你天天等啊等啊，等它的更新通知一来，你就去看那些最新的视频。

在这里插入图片描述
观察者模式示例：


/**
 * @author xh
 * Subject 主题接口
 */
public interface Subject {
    void registerObserver(Observer o);

    void removeObserver(Observer o);

    void notifyAllObservers();
}

/**
 * @author xh
 * 观察者接口
 */
public interface Observer {
    public void update(Subject s);
}

import java.util.ArrayList;

/**
 * @author xh
 * 视频网站某奇艺 实现 Subject 接口
 */
public class VideoSite implements Subject {
    // 观察者列表
    private ArrayList<Observer> userList;
    // 更新了的视频列表
    private ArrayList<String> videos;

    public VideoSite() {
        userList = new ArrayList<Observer>();
        videos = new ArrayList<String>();
    }

    @Override
    public void registerObserver(Observer o) {
        userList.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        userList.remove(o);
    }

    @Override
    public void notifyAllObservers() {
        for (Observer o : userList) {
            o.update(this);
        }
    }

    public void addVideos(String video) {
        this.videos.add(video);
        notifyAllObservers();
    }

    public ArrayList<String> getVideos() {
        return videos;
    }

    @Override
    public String toString() {
        return videos.toString();
    }
}

/**
 * @author xh
 * 实现观察者，即看视频的美剧迷们
 */
public class VideoFans implements Observer {
    private String name;

    public VideoFans(String name) {
        this.name = name;
    }

    @Override
    public void update(Subject s) {
        System.out.println(this.name + ", new videos are available! ");
        // print video list
        System.out.println(s);
    }
}


/**
 * @author xh
 * 测试
 */
public class PatterTest {
    public static void main(String[] args) {
        VideoSite vs = new VideoSite();
        vs.registerObserver(new VideoFans("LiLei"));
        vs.registerObserver(new VideoFans("HanMeimei"));
        vs.registerObserver(new VideoFans("XiaoMing"));
        // add videos
        vs.addVideos("Video 1");
        //vs.addVideos("Video 2");
    }
}

运行结果：

LiLei, new videos are available! 
[Video 1]
HanMeimei, new videos are available! 
[Video 1]
XiaoMing, new videos are available! 
[Video 1]

可能有同学会问，为什么打印出了 [Video 1] ，我们来看类 VideoSite 中的 toString() 方法返回的是 ArrayList 的 videos 对象，当 notifyAllObservers() 方法中调用 update()方法，传递 this 参数的时候，相当于传递了 videos 的值。

5.3 观察者模式应用

前面已经说了，观察者模式也可以理解为 “源-监听者” 模式，这种应用就太多了。举个简单的例子就是各种 listener，比如当你有一个按键，你肯定要给这个按键添加监听事件（listener）来完成指定动作吧，这就是一种应用。

6、单例模式

6.1 单例模式定义

单例模式（Singleton Pattern），顾名思义，就是被单例的对象只能有一个实例存在。单例模式的实现方式是，一个类能返回对象的一个引用（永远是同一个）和一个获得该唯一实例的方法（必须是静态方法）。通过单例模式，我们可以保证系统中只有一个实例，从而在某些特定的场合下达到节约或者控制系统资源的目的。

6.2 单例模式类图

在【装饰者模式】中，我们体验了拥有各种不同特性的女朋友的“酸爽”... 不过梦想很丰满，现实很骨感，最后你只能拥有一个老婆。

在这里插入图片描述
单例模式示例

1.饿汉模式

最常见、最简单的单例模式写法之一。顾名思义，“饿汉模式” 就是很 “饥渴”，所以一上来就需要给它新建一个实例。但这种方法有一个明显的缺点，那就是不管有没有调用过获得实例的方法（本例中为getWife() ），每次都会新建一个实例。

/**
 * @author xh
 * 饿汉模式
 */
public class Wife1 {
    // 一开始就新建一个实例
    private static final Wife1 wife = new Wife1();

    // 默认构造方法
    private Wife1() {
    }

    // 获得实例的方法
    public static Wife1 getWife() {
        return wife;
    }
}

2.懒汉模式

最常见、最简单的单例模式之二，跟 “饿汉模式” 是 “好基友”。再次顾名思义，“懒汉模式” 就是它很懒，一开始不新建实例，只有当它需要使用的时候，会先判断实例是否为空，如果为空才会新建一个实例来使用。

/**
 * @author xh
 * 懒汉模式
 */
public class Wife2 {
    // 一开始没有新建实例
    private static Wife2 wife;

    private Wife2() {
    }

    // 需要时再新建
    public static Wife2 getWife() {
        if (wife == null) {
            wife = new Wife2();
        }
        return wife;
    }
}

3.线程安全的懒汉模式
是不是感觉很简单？但是上面的懒汉模式却存在一个严重的问题。那就是如果有多个线程并行调用getWife() 方法的时候，还是会创建多个实例，单例模式就失效了。
Bug 来了，改改改！
简单，我们在基本的懒汉模式上，把它设为线程同步（ synchronized ）就好了。 synchronized 的作用就是保证在同一时刻最多只有一个线程运行，这样就避免了多线程带来的问题。

/**
 * @author xh
 * 懒汉模式（线程安全）
 */
public class Wife3 {
    private static Wife3 wife;
    private Wife3(){};
    public static synchronized Wife3 getWife() {
        if(wife == null) {
            wife = new Wife3();
        }
        return wife;
    }
}

4.双重检验锁（double check）

线程安全的懒汉模式解决了多线程的问题，看起来完美了。但是它的效率不高，每次调用获得实例的方法 getWife() 时都要进行同步，但是多数情况下并不需要同步操作（例如我的 wife 实例并不为空可以直接使用的时候，就不需要给 getWife() 加同步方法，直接返回 wife 实例就可以了）。所以只需要在
第一次新建实例对象的时候，使用同步方法。
不怕，程序猿总是有办法的。于是，在前面的基础上，又有了 “双重检验锁” 的方法。

/**
 * @author xh
 * 双重锁的 getWife() 方法
 */
public class Wife4 {
    private static Wife4 wife;

    private Wife4() {
    }

    public static Wife4 getWife() {
        // 第一个检验锁，如果不为空直接返回实例对象，为空才进入下一步
        if (wife == null) {
            synchronized (Wife4.class) {
                // 第二个检验锁，因为可能有多个线程进入到 if 语句内
                if (wife == null) {
                    wife = new Wife4();
                }
            }
        }
        return wife;
    }
}

你以为这终于圆满了？NO...Too young, too naive! 主要问题在于 wife = new Wife() 这句代码，因为在 JVM（Java 虚拟机）执行这句代码的时候，要做好几件事情，而 JVM 为了优化代码，有可能造成做这几件事情的执行顺序是不固定的，从而造成错误。
这个时候，我们需要给实例加一个 volatile 关键字，它的作用就是防止编译器自行优化代码。最后，我们的“双重检验锁”版本终于出炉了。

/**
 * @author xh
 * 双重锁的 getWife() 方法
 */
public class Wife4 {
    // 防止编译器自行优化代码
    private volatile static Wife4 wife;

    private Wife4() {
    }

    public static Wife4 getWife() {
        // 第一个检验锁，如果不为空直接返回实例对象，为空才进入下一步
        if (wife == null) {
            synchronized (Wife4.class) {
                // 第二个检验锁，因为可能有多个线程进入到 if 语句内
                if (wife == null) {
                    wife = new Wife4();
                }
            }
        }
        return wife;
    }
}

5.静态内部类

上面的方法，修修补补，实在是太复杂了... 而且 volatile 关键字在某些老版本的 JDK 中无法正常工作。咱们得换一种方法，即 “静态内部类”。这种方式，利用了 JVM 自身的机制来保证线程安全，因为WifeHolder 类是私有的，除了 getWife() 之外没有其它方式可以访问实例对象，而且只有在调用
getWife() 时才会去真正创建实例对象。（这里类似于 “懒汉模式”）

/**
 * @author xh
 * 静态内部类
 */
public class Wife5 {
    private static class WifeHolder {
        private static final Wife5 wife = new Wife5();
    }

    private Wife5() {
    }

    public static Wife5 getWife() {
        return WifeHolder.wife;
    }
}

6.枚举

如下，代码简直是简单得不能再简单了。我们可以通过 Wife.INSTANCE 来访问实例对象，这比getWife() 要简单得多，而且创建枚举默认就是线程安全的，还可以防止反序列化带来的问题。这么优（niu）雅（bi）的方法，来自于新版《Effective Java》这本书。这种方式虽然不常用，但是最为推荐。

/**
 * @author xh
 * 枚举
 */
public enum Wife6 {
    INSTANCE;
    // 自定义的其他任意方法
    public void whateverMethod() { }
}

6.3 单例模式应用

当你只需要一个实例对象的时候，就可以考虑使用单例模式。比如在资源共享的情况下，避免由于多个资源操作导致的性能或损耗等就可以使用单例模式。

三、总结

总结一下，回顾上面的举例：

工厂模式：女娲娘娘...
抽象工厂模式：厨房、食物、吃货...
适配器模式：港版 iphone6、充电头、转接头...
装饰者模式：好多各式各样的女朋友...
观察者模式：视频网站、美剧...
单例模式：媳妇、饿汉、懒汉...

至此，设计模式入门浅谈已经结束。

以上的示例代码，已经上传到gitee上，需者自取：

gitee地址

【设计模式】从女娲娘娘到取媳妇

一、设计模式简介

1、什么是设计模式？

2、设计模式原则

3、设计模式分类

二、常用设计模式

1、工厂模式

1.1 什么是工厂模式

1.2 工厂模式分类

1.2.1 普通工厂模式

1.2.2 多个工厂方法模式

1.2.3 静态工厂方法模式

1.2.4 工厂模式应用

2、抽象工厂模式

2.1 抽象工厂模式定义

2.2 抽象工厂模式类图

2.3 抽象工厂模式应用

3、适配器模式

3.1 适配器模式的定义

3.2 适配器模式类图

3.3 适配器模式的应用

4、装饰者模式

4.1 装饰者模式定义

4.2 装饰者模式类图

4.3 装饰者模式应用

5、观察者模式

5.1 观察者模式定义

5.2 观察者模式类图

5.3 观察者模式应用

6、单例模式

6.1 单例模式定义

6.2 单例模式类图

6.3 单例模式应用

三、总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【设计模式】从女娲娘娘到取媳妇

一、设计模式简介

1、什么是设计模式？

2、设计模式原则

3、设计模式分类

二、常用设计模式

1、工厂模式

1.1 什么是工厂模式

1.2 工厂模式分类

1.2.1 普通工厂模式

1.2.2 多个工厂方法模式

1.2.3 静态工厂方法模式

1.2.4 工厂模式应用

2、抽象工厂模式

2.1 抽象工厂模式定义

2.2 抽象工厂模式类图

2.3 抽象工厂模式应用

3、适配器模式

3.1 适配器模式的定义

3.2 适配器模式类图

3.3 适配器模式的应用

4、装饰者模式

4.1 装饰者模式定义

4.2 装饰者模式类图

4.3 装饰者模式应用

5、观察者模式

5.1 观察者模式定义

5.2 观察者模式类图

5.3 观察者模式应用

6、单例模式

6.1 单例模式定义

6.2 单例模式类图

6.3 单例模式应用

三、总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景