震惊！小猪的设计模式初涉总结！纯干货~

知识点总结

描述性文字

      今年一月初有了离职的念头后，就盘算着把设计模式给过一遍，索性就
开了一个新的系列：《如何让孩子爱上设计模式》，在编写过程中经历了
旧项目重构，离职交接，写简历，投简历，面试，搬家等阶段，零零星星，
总算是坚持写完，自己也是收获颇多，至少面试的时候别人问你用过了解
什么设计模式，不是绞尽脑汁的憋出那么几个烂大街的，单例，建造者...
当然只是对各种设计模式有了一个初步的了解，灵活运用还得在实践和阅读
优秀源码中去慢慢体会！和《Git大法好》系列一样，《如何让孩子爱上设计模式》
同样是想让初学者更好更快的去理解每种模式，依旧本着通熟易懂的理念去编写，
这也意味着有很多废话，所以总结提取里面的精华，基本套路显得非常重要，
遂有此文。描述文字大概就这些，想到再写，本文会一直更新，如果文字
有描述错误或写得不好的地方欢迎指出，万分感激~

本文在线版（排版更佳，优先更新）：https://www.zybuluo.com/coder-pig/note/658810
本文不收取任何费用，欢迎转载，请勿将本文用于商业用途，
想了解更多内容可见：http://blog.csdn.net/coder_pig
如果本文对你学习设计模式有一定帮助，不妨小额打赏下小猪，你的鼓励是我不断写
博客的动力，当然实在囊中羞涩，但又很想支持小猪的话，点个赞，留个言也行，
万分感谢~

微信： 支付宝：

如有什么疑问欢迎加群：421858269 反馈，谢谢~

1.面向对象的三大特性

1）封装（Encapsulation）

隐藏对象的具体实现细节，通过共有方法暴露对象的功能。
内部结构可以自由修改，同时可对成员进行更加精确的控制
(比如在setter方法中加值合法判断)

2）继承（Inheritance）

使用已经存在的类作为基础类（父类），在此基础上建立新类（子类），
子类既可复用父类的功能，也能进行扩展，从而实现代码复用。
另外，Java不能像C++那样同时继承多个父类，只能树形的继承，
比如：Man -> Human -> Animal，或通过接口和内部类实现多继承。

另外，关于继承还需注意以下几点：

• 1.子类拥有父类非private的属性与方法
• 2.构造方法只能调用，不能实现，子类默认调用父类的无参构造方法，
  如果父类没有无参的构造方法，需要使用super显式调用！
• 3.慎用继承，要考虑是否需要从子类向父类进行向上转型！

3）多态（Polymorphism）

定义：一个类实例的相同方法在不同的情形下有不同的表现形式

分为以下两种：

• 编译时多态（OverLoading）—— 方法重载
• 运行时多态（OverRidding）—— 继承 + 方法重写 + 向上转型(父类引用指向子类对象)

运行时多态(动态绑定，new后面什么类型，动态类型就是什么类型)
示例如下：

class Animal() { fun show() { println("动物") }}
class People：Animal() { fun show() { println("人类") }}
//下述代码打印结果：人类
Animal animal = new People()
animal.show()

2.类与类间的关系

口诀：鸡湿衣冠剧组(继承，实现，依赖，关联，聚合，组合)

继承和实现就不说了，后面四个只是 语意层次 的区别
两个类的相关程度，依赖 < 关联 < 聚合 < 组合

依次的UML类图标记：

• 继承/泛化（Generalization）： 子类 父类

• 实现（Realization）：实现类 接口

• 依赖（Dependency）：不持有引用，具体表现：局部变量，函数参数，
  返回值使用 依赖类，比如大佬依赖于递茶小弟；

• 关联（Association）：持有引用，具体表现：成员变量，
  箭头指向被关联类，可双向，一对多或多对多：
  

• 聚合（Aggregation）：成员变量，关联是处于同一层次的，而聚合则
  是整体和局部层次的，比如：社团 和 小弟，另外即使没有了社团，
  小弟们依旧可以到别的地方搞事情。
  

• 组合（Composition）：与聚合类似，程度更加强烈，共生死，组合类
  负责被组合类的生命周期，比如： 社团 和 大佬，如果没了社团，
  大佬也就就不能存在了。
  

3.面向对象七大原则

• 单一职责原则（Single Responsibility Principle）
  每一个类应该专注于做一件事情。 即：高内聚，低耦合。

• 开闭原则（Open Close Principle）
  一个对象对扩展开放，对修改关闭。即：对类的改动
  是通过增加代码进行的，而不是修改现有代码。

• 里氏替换原则（Liskov Substitution Principle）
  在任何父类出现的地方都可以用它的子类来替代。

• 依赖倒置原则（Dependence Inversion Principle）
  要依赖于抽象，不要依赖于具体实现。

• 接口隔离原则（Interface Segregation Principle）
  应当为客户端提供尽可能小的单独的接口，而不是提供大的总的接口。

• 迪米特原则（Law Of Demeter）
  一个对象应当尽量少地与其他对象之间发生相互作用，使得系统功能模块相对独立。

• 组合/聚合复用原则（Composite/Aggregate Reuse Principle）
  尽量使用组合/聚合的方式，而不是使用继承。

23种设计模式

• 创建型（5种）：主要用于处理对象的创建，实例化对象：
  单例，建造者，原型，工厂方法，抽象工厂

• 结构型（7种）：处理类或对象间的组合
  适配器，装饰者，结合，桥接，外观，享元，代理

• 行为型（11种）：描述类或对象怎样进行交互和职责分配
  策略，观察者，迭代器，命令，备忘录，中介者，解释器，访问者，责任链，状态，模板方法

一. 单例模式（Singleton Pattern）

作用：保证 类在内存中 的 对象唯一性。

适用场景：

• 1.避免创建多个实例浪费资源
• 2.避免多个实例因多次调用而出现错误
• 3.一般写工具类，线程池，缓存，数据库会用到。

套路(三个要点)：

• 1.不允许在类外new对象 —— 构造方法私有化
• 2.在类中创建对象 —— 通过new在本类中创建一个实例
• 3.对外提供获取该实例的方法 —— 定义公有方法返回创建的实例

饿汉与懒汉的区别

前者在类装载时就实例化，后者只有在第一次被使用时才实例化。
(饿汉的优点是避免线程同步问题，缺点是即使没用到这个实例还是会加载)
(懒汉的优点是实现了懒加载，但需要解决线程安全问题！)

7种单例套路：

1）饿汉式，没有实现懒加载~

public class Singleton() {
    private static Singleton instance = new Singleton();
    private Singleton(){ }
    public static Singleton getInstance() { 
        return instance;  
    }
}
//获取单例对象
Singleton mSingleton = Singleton.getInstance();

2）懒汉式

虽然达到了懒加载，但是却存在线程安全问题，比如有两个线程都
刚好执行完if(instance == null)，接着准备执行instance = new Singleton()
语句，这样的结果会导致我们实例化了两个Singleton对象，
为了解决线程不安全问题，可以对getInstance()方法加锁。

public class Singleton {
    private static Singleton instance = null;
    private Singleton() { }
    private static Singleton getInstance() {
        if(instance == null) { 
            instance = new Singleton(); 
        }
        return instance;
    }
}

3）懒汉式加锁版

为getInstance方法加锁虽然保证了线程安全，但是每次执行getInstance()
都需要同步，而实例化对象只需要执行一次就够了，后面获取该示例，
应该直接return就好了，方法同步效率太低，一种改进后的写法是：
synchronized (Singleton.class) { instance = new Singleton(); }
但是，这样写依然是线程不安全的，如果你还是想用懒汉式的话，推荐
双重检查锁定（DCL，Double Check Lock）。

public class Singleton {
    private static Singleton instance = null;
    private Singleton() { }
    private static synchronized Singleton getInstance() {
        if(instance == null) { 
            instance = new Singleton(); 
        }
        return instance;
    }
}

4）懒汉式双重校验锁（DCL）

代码中进行了两次if检查，这样就可以保证线程安全，初始化一次后，
后面再次访问时，if检查，直接return 实例化对象。volatile是1.5后
引入的，volatile关键字会屏蔽Java虚拟机所做的一些代码优化，会导
致系统运行效率降低，而更好的写法是使用静态内部类来实现单例！

public class Singleton{
    private static volatile Singleton instance = null;
    private Singleton() { }
    public static Singleton getInstance() {
        if(instance == null) {
            synchronized(Singleton.class) {
                if(instance == null) instance = new Singleton();
            }
        }
        return instance;
    }
 }

5）静态内部类实现单例（推荐）

和饿汉式类似，都是通过类加载机制来保证初始化实例的
时候只有一个线程，从而避免线程安全问题，饿汉式的
Singleton类被加载时，就会实例化，而静态内部类这种，
当Singleton类被加载时，不会立即实例化，调用getInstance()
方法才会装载SingletonHolder类，从而完成Singleton的实例化。

public class Singleton {
    private Singleton() { }
    private static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton()
    }
}

6）枚举实现单例

INSTANCE即为SingletonEnum类型的引用，得到它就可以调用
枚举中的方法。既避免了线程安全问题，还能防止反序列化
重新创建新的对象，但是失去了类的一些特性，而且没有延时加载。

public enum SingletonEnum {
    INSTANCE;
    private Singleton instance;
    SingletonEnum() { 
        instance = new Singleton();
    }
    public Singleton getInstance() { 
        return instance; 
    }
}
//调用方式
SingletonEnum.INSTANCE.method();

7）容器实现单例

将多种单例类型注入到一个统一的管理类中，在使用时根据key获取对象
对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使
用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用
户隐藏了具体实现，降低了耦合度。

public class SingletonManager {
    private static Map<String,Object> objMap = new HashMap<String,Object>();
    private Singleton(){ }
    public static void registerService(String key,Object instance) {
        if(!objMap.containsKey(key)) {
            objMap.put(key,instance);
        }
    }
    public static Object getService(String key) {
        return objMap.get(key);
    }
}

二. 建造者模式（Builder Pattern）

将 复杂对象的构建与表示分离 开来，使得同样的构建过程可以
创建不同的表示，缺点是可能产生多余的创建者与构建过程对象，
消耗内存，不适用于内部建造顺序不稳定，变化复杂的对象，
可能导致需要创建很多具体的建造者来实现这些变化。
例子：玩游戏创建角色时的自定义，不同的搭配生成不同的角色。

四个角色与UML类图

示例代码：

//产品类
class Character {
    private String sex;
    private String face;
    private String clothes;
    void setSex(String sex) { this.sex = sex;}
    void setFace(String face) { this.face = face; }
    void setClothes(String clothes) { this.clothes = clothes;}
    String showMsg() { return "你创建了一个穿着 " + clothes + " 一副 " + face + " 的" + sex + "ヾ(≧▽≦*)o 戳菊狂笑~"; }
}
//抽象Builder接口
interface Builder {
    void setSex(String sex);
    void setFace(String face);
    void setClothes(String clothes);
    Character build();
}
//Builder接口实现类
class ConcreteBuilder implements Builder {
    private Character mCharacter = new Character();
    @Override public void setSex(String sex) { mCharacter.setSex(sex); }
    @Override public void setFace(String face) { mCharacter.setFace(face); }
    @Override public void setClothes(String clothes) { mCharacter.setClothes(clothes); }
    @Override public Character build() {return mCharacter;}
}
//装配过程类
class Director {
    private Builder mBuilder = null;
    Director(Builder builder) { this.mBuilder = builder; }
    Character createCharacter(String sex, String face, String clothes) {
        this.mBuilder.setSex(sex);
        this.mBuilder.setFace(face);
        this.mBuilder.setClothes(clothes);
        return mBuilder.build();
    }
}
//客户端调用类
public class Game {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        Character character =  director.createCharacter("基佬","硬汉脸","死库水");
        System.out.println(character.showMsg());
    }
}

输出结果：

三. 原型模式（Prototype Pattern）

下面两种场景可以考虑使用原型模式：

• 1.当初始化类对象需要消耗非常多资源，或者说要进行繁琐
  的数据准备或者权限，如果想简化创建，可以使用原型模式。
• 2.一个对象提供给其他对象访问，而各个调用者可能都需要
  修改对象的值，可以考虑使用原型模式克隆多个对象供调用者
  使用（保护性拷贝）

三个角色与UML类图

Java中 == 与equals的区别

• ==，基本数据类型(int,long等)，比较存储的值是否相等
  对比的是引用类型，比较的是所指对象地址是否相等

• equals，不能用于比较基本数据类型，如果没对equals()方法进行
  重写，比较的是指向的对象地址，如果想要比较对象内容，需要自行重写
  方法，做相应的判断！！！！String调equals是可以判断内容是否一样，是
  因为对equals()方法进行了重写，具体可参见源码！

克隆需要满足的三个条件

• 1.x.clone()!=x ，即 不是同一对象
• 2.x.clone().getClass == x.getClass()，即 对象类型一致
• 3.如果对象obj的equals()方法定义恰当的话，那么
  obj.clone().equals(obj) == true应当是成立的。(推荐，不强制)

Java中如何使用

Prototype原型类(想被克隆的类)实现Cloneable接口，重写clone()方法。

ConcretePrototype cp1 = new ConcretePrototype(); 
ConcretePrototype cp2 = (ConcretePrototype)cp1.clone();

需注意：

• 1.执行克隆方法，不会调用构造方法
• 2.克隆会生成的新的对象成员，但指向的却是同一个内存地址！
• 3.克隆前后数据类型一致！
• 4.克隆的时候，类中基本数据类型的属性会新建，但是引用类型的
  只会生成个新的引用变量，引用变量的地址依旧指向同一个内存地址！

实现深拷贝的两种套路：

这种只新建基本类型数据，不新建引用类型数据，称为浅拷贝，
如果连引用类型数据也新建的话，则称为深拷贝。

两个套路：

1.引用类型也实现Cloneable接口，如果属性的类型也是对象，
那么需要一直递归的克隆下去
2.序列化，属性的类型是引用类型的话，需要实现Serializable接口，
然后自己写个方法来在里面完成对象转二进制流与二进制流转
对象的方法，然后返回克隆后的对象！

具体代码见：3.Prototype Pattern

四.工厂方法模式（Factory Method Pattern）

关于三种工厂模式，其实理解起来非常简单，只是把对象的创建放到一个
特定的类中，相比起我们直接new对象，这种套路会写多几个类，但是
却拥有更好的扩展性，而且当创建的对象发生改变，可以减少一定的修改量。
(想想你在项目中有一个类在多处都new了，现在需要对这个类的构造
方法，或者相关参数做些修改，你需要找到每个new这个类的地方进行
修改，而如果你把工作都丢给一个工厂类，你可能只需要修改这个类)
另外，简介下这几种工厂模式的区别：

• 简单工厂模式：最简单的直接把new对象丢到一个工厂类中；
• 工厂方法模式：对工厂类进行抽象，实现具体工厂类以创建不同对象；
• 抽象工厂模式：当工厂需要创建多种相互关联或依赖的对象，有两个名
  产品等级结构与产品族，具体是什么的自己看~

简单工厂模式的三个角色：

代码示例：

abstract class Tea {
    public abstract void 加奶茶();
    public abstract void 加料();
}
class YeGuoTea extends Tea{
    @Override public void 加奶茶() { System.out.println("加了一把奶茶");}
    @Override public void 加料() {System.out.println("加了一把椰果");}
}
class ZhenZhuTea  extends Tea{
    @Override public void 加奶茶() { System.out.println("加了一把奶茶");}
    @Override public void 加料() {System.out.println("加了一把珍珠");}
}
public class Me {
    public static Tea makeTea(int type) {
        System.out.println("==============");
        Tea tea = type == 0 ? new ZhenZhuTea() : new YeGuoTea();
        tea.加奶茶();
        tea.加料();
        return tea;
    }
}
public class Store {
    public static void main(String[] args) {
        for (int i = 0;i < 3;i++) {
            Tea tea = Me.makeTea(buyTea()); //小猪制作奶茶
        }
    }
    /* 模拟用户下单，0代表要珍珠奶茶，1代表要椰果奶茶 */
    private static int buyTea() {
        return new Random().nextInt(2);
    }
}

输出结果：

工厂方法模式(静态工厂)：

其实就是在简单工厂模式基础上，把工厂创建不同产品的内部逻辑抽取出来，
生成一个抽象工厂，再创建具体工厂类，生产不同的产品。

UML类图

代码示例：

//工厂接口/抽象类
abstract class MakeTea {
    abstract Tea 小猪带特效的奶茶制作工艺();
}
//工厂实现类1
class ZhenZhuMakeTea extends MakeTea {
    @Override
    Tea 小猪带特效的奶茶制作工艺() {
        System.out.println("====== 珍珠小弟炮制港式珍珠奶茶 ======");
        Tea tea = new ZhenZhuTea();
        tea.加奶();
        tea.加茶();
        tea.加料();
        tea.打包();
        return tea;
    }
}
//工厂实现类2
class YeGuoMakeTea extends MakeTea {
    @Override
    Tea 小猪带特效的奶茶制作工艺() {
        System.out.println("====== 椰果小弟炮制日式椰果奶茶 ======");
        Tea tea = new YeGuoTea();
        tea.加奶();
        tea.加茶();
        tea.加料();
        tea.打包();
        return tea;
    }
}
//客户端调用
public class StoreS {
    public static void main(String[] args) {
        //初始化两个小弟
        ZhenZhuMakeTea zhenzhu = new ZhenZhuMakeTea();
        YeGuoMakeTea yeguo = new YeGuoMakeTea();
        for (int i = 0;i < 3;i++) {
            Tea tea = buyTea() == 0 ? zhenzhu.小猪带特效的奶茶制作工艺() 
                : yeguo.小猪带特效的奶茶制作工艺();
        }
    }
    /* 模拟用户下单，0代表要珍珠奶茶，1代表要椰果奶茶 */
    private static int buyTea() {
        return new Random().nextInt(2);
    }
}

输出结果：

另外还可以通过反射简洁生产过程，直接传入产品的类类型，
生成对应的产品，示例如下：

abstract class SMakeTea {
    public abstract <T extends Tea> T 小猪带特效的奶茶制作工艺(Class<T> clz);
}
class SMe extends SMakeTea {
    @Override
    public <T extends Tea> T 小猪带特效的奶茶制作工艺(Class<T> clz) {
        System.out.println("==============");
        Tea tea = null;
        try {
            tea = (Tea) Class.forName(clz.getName()).newInstance();
            tea.加奶();
            tea.加茶();
            tea.加料();
            tea.打包();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) tea;
    }
}
public class SStore {
    public static void main(String[] args) {
        SMe me = new SMe();
        me.小猪带特效的奶茶制作工艺(ZhenZhuTea.class);
        me.小猪带特效的奶茶制作工艺(YeGuoTea.class);
    }
}

六. 抽象工厂模式（Abstract Factory Pattern）

代码示例

//抽象产品类1
abstract class Drink {
    public abstract void drink();
}
//抽象产品类2
abstract class Snack {
    public abstract void snack();
}
//具体产品类们
class MilkTea extends Drink {
    @Override public void drink() { System.out.println("一杯奶茶"); }
}
class Juice extends Drink {
    @Override public void drink() { System.out.println("一杯果汁"); }
}
class HandGrab extends Snack {
    @Override public void snack() { System.out.println("一个手抓饼"); }
}
class FishBall extends Snack {
    @Override public void snack() { System.out.println("一碗鱼蛋"); }
}
//抽象工厂类
abstract class MakeFood {
    abstract Drink createMakeDrink();
    abstract Snack createMakeSnack();
}
//具体工厂类1
class FirstXiaoDi extends MakeFood {
    @Override public Drink createMakeDrink() { return new MilkTea(); }
    @Override public Snack createMakeSnack() { return new HandGrab(); }
}
//具体工厂类2
class SecondXiaoDi extends MakeFood {
    @Override public Drink createMakeDrink() { return new Juice(); }
    @Override public Snack createMakeSnack() { return new FishBall(); }
}
//客户端调用
public class Store {
    public static void main(String[] args) {
        //初始化两个小弟
        MakeFood xiaodi1 = new FirstXiaoDi();
        MakeFood xiaodi2 = new SecondXiaoDi();
        for(int i = 0;i < 4 ;i++) {
            System.out.println("====== 根据订单配餐： ======");
            Drink drink = buyDrink() == 0 ?
                xiaodi1.createMakeDrink() : xiaodi2.createMakeDrink();
            Snack snack = buySnack() == 0 ? 
                xiaodi1.createMakeSnack() : xiaodi2.createMakeSnack();
            drink.drink();
            snack.snack();
        }
    }
    /* 模拟用户点饮料，0代表要奶茶，1代表要果汁 */
    private static int buyDrink() { return new Random().nextInt(2); }
    /* 模拟用户点小吃，0代表要手抓饼，1代表要鱼蛋 */
    private static int buySnack() { return new Random().nextInt(2); }
}

输出结果：

两个名词(产品等级结构与产品族)

• 产品等级结构（继承）：
  比如这里的抽象类是Drink(饮料)，子类有
  奶茶，果汁，然后抽象饮料与具体饮料构成了一个产品等级
  结构，抽象饮料是父类，具体饮料是其子类。

• 产品族
  同一工厂生产的，位于不同产品等级结构的一组产品，比如这里
  的奶茶和果汁属于饮料结构的一组产品，而手抓饼和鱼蛋则
  属于小吃结构的一组产品。

四个角色与UML类图

抽象工厂模式适用于创建的对象有多个相互关联或依赖的产品族
抽象工厂模式隔离具体类的生成，接口与实现分离，增加新的产品族很方便；
但是扩展新的产品等级结构麻烦，需要修改抽象工厂，具体工厂类也要更改。

七. 适配器模式（Adapter Pattern）

两个彼此间没太大关联的类，想进行交互完成某些事情，不想直接
去修改各自的接口，可以添加一个中间类，让他来协调两个类
间的关系，完成相关业务，这种模式就叫适配器模式。

然后分为：类适配器 和 对象适配器 两种，前者和适配者是继承关系，
后者与适配者则是引用关系。

对象适配器支持传入一个被适配器对象，因此可以做到对多种被适
配接口进行适配。而类适配器直接继承，无法动态修改，所以一般情况
下对象适配器使用得更多！（Java不支持多重继承！！！）

对象适配器例子(用得较多)

/* 目标接口 */
interface Chinese {
    void speakChinese(String string);
}
/* 需要适配的类 */
class English {
    void speakEnglish(String string) { System.out.println("【英语】" + string); }
}
/* 适配器 */
class Translator implements Chinese{
    private English english = new English();
    Translator(English english) { this.english = english; }
    @Override public void speakChinese(String string) { english.speakEnglish(string); }
}
/* 客户端调用 */
public class Client {
    public static void main(String[] args) {
        Chinese chinese = new Translator(new English());
        chinese.speakChinese("那你很棒棒哦！");
    }
}

输出结果：

类适配器例子

/* 类适配器 */
class ClassTranslator extends English implements Chinese {
    @Override public void speakChinese(String string) { speakEnglish(string); }
}
/* 客户端调用 */
public class ClientC {
    public static void main(String[] args) {
        ClassTranslator translator = new ClassTranslator();
        translator.speakChinese("你也很好啊！");
    }
}

输出结果：

除此之外还有个缺省适配器模式的名词，简单点说就是不需要实现接口中
提供的所有方法时，先写一个抽象类实现这个接口，然后为每个方法提供一个
默认实现（空方法），然后选择性覆盖某些方法实现需求，又称单接口适配器模式。

八.装饰者模式（Decorator Pattern）

动态的给对象添加一些额外的职责，就增加功能来说，装饰者
模式比起生成子类更加灵活！就是想替代多重层继承的模式。
其实就是一层套一层。

代码示例

/* 抽象组件 */
abstract class Tea {
    private String name = "茶";
    public String getName() { return name; }
    void setName(String name) { this.name = name; }
    public abstract int price();
}
/* 具体组件 */
class MilkTea extends Tea {
    MilkTea() { setName("奶茶"); }
    @Override public int price() { return 5; }
}
class LemonTea extends Tea{
    LemonTea() { setName("柠檬茶"); }
    @Override public int price() { return 3; }
}
/* 抽象装饰类 */
abstract class Decorator extends Tea{
    public abstract String getName();
}
/* 具体装饰类 */
class ZhenZhu extends Decorator {
    Tea tea;
    ZhenZhu(Tea tea) { this.tea = tea; }
    @Override public String getName() { return "珍珠" + tea.getName(); }
    @Override public int price() { return 2 + tea.price(); }
}
class YeGuo extends Decorator{
    //...
}
class JinJu extends Decorator{
    //...
}
class HongDou extends Decorator{
    //...
}
/* 客户端调用 */
public class Store {
    public static void main(String[] args) {
        Tea tea1 = new MilkTea();
        System.out.println("你点的是：" + tea1.getName() + " 价格为：" + tea1.price());
        Tea tea2 = new LemonTea();
        tea2 = new JinJu(tea2);
        System.out.println("你点的是：" + tea2.getName() + " 价格为：" + tea2.price());
        Tea tea3 = new MilkTea();
        tea3 = new ZhenZhu(tea3);
        tea3 = new YeGuo(tea3);
        tea3 = new HongDou(tea3);
        tea3 = new JinJu(tea3);
        System.out.println("你点的是：" + tea3.getName() + " 价格为：" + tea3.price());
    }
}

输出结果：

九.组合模式（Composite Pattern）

部分-整体模式，把具有 相似的一组对象 当做一个对象处理，
用一种 树状的结构 来组合对象，再提供统一的方法去访问相似的对象，
以此忽略掉对象与对象容器间的差别。

根节点，枝结点，叶子结点 三个名词需要理解，
类比上图，根节点是菜单，枝结点是饮料菜单和小吃菜单，
叶子结点是奶茶，果汁，手抓饼和鱼蛋！

代码示例

/* 抽象组件 */
abstract class AbstractMenu {
    public abstract void add(AbstractMenu menu);
    public abstract AbstractMenu get(int index);
    public abstract String getString();
}
/* 容器组件 */
class Menu extends AbstractMenu {
    private String name;
    private String desc;
    private List<AbstractMenu> menus = new ArrayList<>();
    Menu(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    @Override public void add(AbstractMenu menu) { menus.add(menu); }
    @Override public AbstractMenu get(int index) { return menus.get(index); }
    @Override public String getString() {
        StringBuilder sb = new StringBuilder("\n【菜单】：" + name + " 信息：" + desc + "\n");
        for (AbstractMenu menu: menus) { sb.append(menu.getString()).append("\n"); }
        return sb.toString();
    }
}
/* 叶子组件 */
class MilkTea extends AbstractMenu {
    private String name;
    private String desc;
    private int price;
    MilkTea(String name, String desc, int price) {
        this.name = name;
        this.desc = desc;
        this.price = price;
    }
    @Override public void add(AbstractMenu menu) { /*未使用*/ }
    @Override public AbstractMenu get(int index) { return null; }
    @Override public String getString() {
        return " - 【奶茶】* " + name + " 标注：" + desc + " 价格：" + price;
    }
}
class MilkTea extends AbstractMenu {
    //...
}
class HandCake  extends AbstractMenu {
    //...
}
class FishBall  extends AbstractMenu {
    //...
}
/* 客户端调用 */
public class Store {
    public static void main(String[] args) {
        AbstractMenu mainMenu = new Menu("大菜单", "包含所有子菜单");
        AbstractMenu drinkMenu = new Menu("饮品菜单", "都是喝的");
        AbstractMenu eatMenu = new Menu("小吃菜单", "都是吃的");
        AbstractMenu milkTea = new MilkTea("珍珠奶茶", "奶茶+珍珠", 5);
        AbstractMenu juice = new Juice("鲜榨猕猴桃枝", "无添加即榨", 8);
        AbstractMenu ball = new FishBall("咖喱鱼蛋", "微辣", 6);
        AbstractMenu cake = new HandCake("培根手抓饼", "正宗台湾风味", 8);
        drinkMenu.add(milkTea);
        drinkMenu.add(juice);
        eatMenu.add(ball);
        eatMenu.add(cake);
        mainMenu.add(drinkMenu);
        mainMenu.add(eatMenu);
        System.out.println(mainMenu.getString());
    }
}

输出结果：

十.桥接模式（Bridge Pattern）

基于单一职责原则，如果系统中的类存在多个变化的维度，
通过该模式可以将这几个维度分离出来， 然后进行独立扩展。
这些分离开来的维度，通过在抽象层持有其他维度的引用来进行关联，
就好像在两个维度间搭了桥一样，所以叫桥接模式。

代码示例(变化的三个维度：配餐，扒类)

/* 抽象部分 */
abstract class Rations {
    abstract String rations();
}
/* 扩展抽象部分 */
class Rice extends Rations {
    @Override public String rations() { return "饭"; }
}
class Spaghetti extends Rations {
    @Override public String rations() { return "意粉"; }
}
/* 实现部分 */
abstract class Steak {
    Rations rations;
    Steak(Rations rations) { this.rations = rations; }
    abstract String sale();
}
/* 具体实现部分 */
class BeefSteak extends Steak{
    BeefSteak(Rations rations) { super(rations); }
    @Override public String sale() { return "牛扒"+ (rations == null ? "" : rations.rations()); }
}
class PorkSteak extends Steak {
    PorkSteak(Rations rations) { super(rations); }
    @Override public String sale() { return "猪扒"+ (rations == null ? "" : rations.rations()); }
}
/* 客户端调用 */
public class Restaurant {
    public static void main(String[] args) {
        System.out.println("\n" + new Date(System.currentTimeMillis()));
        System.out.println("==================");
        Steak steak1 = new BeefSteak(new Rice());
        System.out.println("卖出了一份：" + steak1.sale());
        Steak steak2 = new PorkSteak(new Spaghetti());
        System.out.println("卖出了一份：" + steak2.sale());
        Steak steak3 = new PorkSteak(null);
        System.out.println("卖出了一份：" + steak3.sale());
         System.out.println("==================");
}

输出结果：

十一.外观模式（Facade Pattern）

要求一个子系统的外部与内部的通信必须通过一个统一的对象进行，
外观模式提供一个高层次的接口，使得子系统更易于使用。
(其实就是封装，用于解决类与类间的依赖关系，比如本来是：
玩家依赖于：Q，A，E，R等键位对象，现在变成只依赖与脚本对象
从而降低了类间的耦合度。)

代码示例

/* 子系统 */
class A {
    String a() { return "A"; }
}
class Q { /* ... */ }
class Space { /* ... */ }
class LeftClick { /* ... */ }
/* 外观类 */
class JiaoBen {
    A a;
    Q q;
    LeftClick leftClick;
    Space space;
    JiaoBen() {
        a = new A();
        leftClick = new LeftClick();
        q = new Q();
        space = new Space();
    }
    String 锐雯() {
        StringBuilder sb = new StringBuilder();
        sb.append(q.q()).append(" + ");
        sb.append(space.space()).append(" + ");
        sb.append(a.a()).append(" + ");
        sb.append(leftClick.leftClick()).append(" + ");
        sb.append(q.q()).append(" + ");
        sb.append(space.space()).append(" + ");
        sb.append(a.a()).append(" + ");
        sb.append(leftClick.leftClick()).append(" + ");
        sb.append(q.q()).append(" + ");
        sb.append(space.space()).append(" + ");
        sb.append(a.a()).append(" + ");
        sb.append(leftClick.leftClick()).append("\n");
        return sb.toString();
    }
}
/* 客户端调用 */
public class XLoLer {
    public static void main(String[] args) {
        JiaoBen jiaoBen = new JiaoBen();
        System.out.println("=== 锐雯一键光速QA ===\n" + jiaoBen.锐雯());
    }
}

输出结果：

十二. 享元模式（Flyweight Pattern）

当存在多个相同对象时，可以使用享元模式减少相同对象创建引起的内存消耗，
提高程序性能。说到共享，还分内部状态与外部状态。

内部状态：固定不变可共享的的部分，存储在享元对象内部，比如例子中的花色
外部状态：可变不可共享的部分，一般由客户端传入享元对象内部，比如例子里的大小。

示例代码

/* 抽象对象的父类 */
abstract class Card {
    abstract void showCard(String num);  //传入外部状态参数，大小
}
/* 具体享元对象 */
public class SpadeCard extends Card{
    public SpadeCard() { super(); }
    @Override public void showCard(String num) { System.out.println("黑桃：" + num); }
}
public class HeartCard extends Card { /* ... */ }
public class ClubCard extends Card { /* ... */ }
public class DiamondCard extends Card { /* ... */ }
/* 享元工厂 */
public class PokerFactory {
    static final int Spade = 0;  //黑桃
    static final int Heart  = 1; //红桃
    static final int Club  = 2; //梅花
    static final int Diamond  = 3;   //方块
    public static Map<Integer, Card> pokers = new HashMap<>();
    public static Card getPoker(int color) {
        if (pokers.containsKey(color)) {
            System.out.print("对象已存在，对象复用...");
            return pokers.get(color);
        } else {
            System.out.print("对象不存在，新建对象...");
            Card card;
            switch (color) {
                case Spade: card = new SpadeCard(); break;
                case Heart: card = new HeartCard(); break;
                case Club: card = new ClubCard(); break;
                case Diamond: card = new DiamondCard(); break;
                default: card = new SpadeCard(); break;
            }
            pokers.put(color,card);
            return card;
        }
    }
/* 客户端调用 */
public class Player {
    public static void main(String[] args) {
        for (int k = 0; k < 10; k ++){
            Card card = null;
            //随机花色
            switch ((int)(Math.random()*4)) {
                case 0: card = PokerFactory.getPoker(PokerFactory.Spade); break;
                case 1: card = PokerFactory.getPoker(PokerFactory.Heart); break;
                case 2: card = PokerFactory.getPoker(PokerFactory.Club); break;
                case 3: card = PokerFactory.getPoker(PokerFactory.Diamond); break;
            }
            if(card != null) {
                //随机大小
                int num = (int)(Math.random()*13 + 1);
                switch (num) {
                    case 11: card.showCard("J"); break;
                    case 12: card.showCard("Q"); break;
                    case 13: card.showCard("K"); break;
                    default: card.showCard(num+""); break;
                }
            }
        }
    }
}

输出结果：

十三.代理模式（Proxy Pattern）

引用代理对象的方式来访问目标对象，简单点说，就是在调用某个对象
时加了一层，然后你可以在这一层做些手脚，比如权限控制，或者附加操作等。

代码示例

/* 抽象对象 */
public interface FetchGoods {
    public void fetchShoes();
}
/* 真实对象 */
public class Custom implements FetchGoods{
    @Override public void fetchShoes() { System.out.println("拿货"); }
}
/* 代理对象 */
public class Agent implements FetchGoods{
    @Override public void fetchShoes() {
        Custom custom = new Custom();
        custom.fetchShoes();
        this.callCustom();
    }
    public void callCustom() { System.out.println("通知顾客过来取件！"); }
}
/* 客户端调用 */
public class Client {
    public static void main(String[] args) {
        Agent agent = new Agent();
        agent.fetchShoes();
    }
}

输出结果：

十四.策略模式（Strategy Pattern）

定义一系列的算法，把每个算法封装起来，并使得他们可以相互替换，
让算法独立于使用它的客户而变化。 一般用来替换if-else，个人感觉是
面向过程与面向对象思想的过渡。

代码示例：(面向过程与面向对象的简易计算器)

面向过程简易计算器

public class Calculator {
    public static void main(String[] args) {
        System.out.println("计算：1 + 1 = " + compute("+", 1, 1));
        System.out.println("计算：1 - 1 = " + compute("-", 1, 1));
        System.out.println("计算：1 * 1 = " + compute("*", 1, 1));
        System.out.println("计算：1 ? 1 = " + compute("/", 1, 1));
    }
    public static float compute(String operator, int first, int second) {
        switch (operator) {
            case "+": return first + second;
            case "-": return first - second;
            case "*": return first * second;
            case "/": return first / second;
            default: return 0.0f;
        }
    }
}

面向对象(策略模式)简易计算器

/* 抽象策略类 */
public interface Compute {
    String compute(int first, int second);
}
/* 具体策略类 */
public class Add implements Compute{
    @Override public String compute(int first, int second) {
        return "输出结果：" + first + " + " + second + " = " + (first + second);
    }
}
public class Sub implements Compute{ /* ... */ }
public class Mul implements Compute{ /* ... */ }
public class Div implements Compute{ /* ... */ }
/* 上下文环境类 */
public class Context {
    private Compute compute;
    public Context() { compute = new Add(); }
    public void setCompute(Compute compute) { this.compute = compute; }
    public void calc(int first, int second) { 
        System.out.println(compute.compute(first, second)); 
    }
}
/* 客户端调用 */
public class Client {
    public static void main(String[] args) {
        Context context = new Context();
        context.setCompute(new Add());
        context.calc(1,2);
        context.setCompute(new Sub());
        context.calc(3,4);
        context.setCompute(new Mul());
        context.calc(5,6);
        context.setCompute(new Div());
        context.calc(7,8);
    }
}

输出结果：

十五.观察者模式(Observer Pattern)

定义对象见的一种一对多的依赖关系，当一个对象的状态发生改变时，
所有依赖于它的对象都得到通知并且自动更新。

当对象间存在一对多关系的时候，使用观察者模式，当一个对象
(被观察者)被修改时，会自动通知它的依赖对象们(观察者)。

这个模式基本都应该用过和听说过，关于概念就不多解释了，有兴趣看原文去~

代码示例：

/* 抽象观察者 —— 昆虫类 */
public interface Insect {
    void work();
    void unWork();
}
/* 具体观察者 —— 蜜蜂类 */
public class Bee implements Insect{
    private int bId;    //蜜蜂编号
    public Bee(int bId) { this.bId = bId; }
    @Override public void work() { System.out.println("蜜蜂"+ bId + "采蜜"); }
    @Override public void unWork() { System.out.println("蜜蜂"+ bId + "回巢"); }
}
/* 抽象被观察者（注册，移除，通知观察者） —— 植物类 */
public interface Plant {
    public void registerInsect(Insect insect);
    public void unregisterInsect(Insect insect);
    public void notifyInsect(boolean isOpen);
}
/* 具体被观察者（定义一个集合存储观察者，实现相关方法） —— 花朵类 */
public class Flower implements Plant {
    private boolean state;
    private List<Insect> insects = new ArrayList<>();
    public boolean isState() { return state; }
    @Override public void registerInsect(Insect insect) { insects.add(insect); }
    @Override public void unregisterInsect(Insect insect) { insects.remove(insect); }
    @Override public void notifyInsect(boolean isOpen) {
        state = isOpen;
        if (state) {
            System.out.println("花开");
            for (Insect insect : insects) { insect.work(); }
        } else {
            System.out.println("花闭");
            for (Insect insect : insects) { insect.unWork(); }
        }
    }
}
/* 客户端调用 */
public class Client {
    public static void main(String[] args) {
        //创建被观察者
        Plant flower = new Flower();
        //创建三个观察者
        Insect bee1 = new Bee(1);
        Insect bee2 = new Bee(2);
        Insect bee3 = new Bee(3);
        //注册观察者
        flower.registerInsect(bee1);
        flower.registerInsect(bee2);
        flower.registerInsect(bee3);
        //改变被观察者状态，先开后合
        flower.notifyInsect(true);
        System.out.println("=== 太阳从东边到西边... ===");
        flower.notifyInsect(false);
        //最后解除注册
        flower.unregisterInsect(bee1);
        flower.unregisterInsect(bee2);
        flower.unregisterInsect(bee3);
    }
}