【Java设计模式详解】学习笔记

设计模式相关内容

设计模式分类

创建型模式

用于描述“怎么创建对象”，它的主要特点是将对象的创建与使用分离。
GOF书中提供了单例、原型、工厂方法、抽象工厂、建造者等5种创建型模式

结构型模式

用于描述如何将类或对象按某种布局组成更大的结构。
GOF书中提供了代理、适配器、桥接、装饰、外观、享元、组合等7种结构型模式

行为型模式

用于描述类或对象之间怎样相互协作共同完成单个对象无法单独完成的任务，以及怎样分配职责。
GOF书中提供了模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等11种行为型模式

UML图

统一建模语言，是用来设计软件的可视化建模语言。它的特点是简单、统一、图形化、能表达软件设计中的动态与静态信息

表示可见性的符号
+：表示public
-：表示private
#：表示protected

属性的完整表示方式：可见性名称：类型 [ = 缺省值]
方法的完整表示方式：可见性名称（参数列表） [ ：返回值]

类之间的关系

关联关系

关联关系是对象之间的一种引用关系，用于表示一类对象与另一类对象之间的联系，并且是类与类之间最常用的一种关系，分为一般关联关系、聚合关系、和组合关系

关联关系又可以分为单向关联、双向关联、自关联

聚合关系

聚合关系是关联关系的一种，是强关联关系，是整体和部分之间的关系
聚合关系也是通过成员对象来实现的，其中成员对象是整体的一部分，但是成员对象可以脱离整体对象而独立存在，例如学校和老师，学校没了，老师可以去别的学校

组合关系

组合表示类之间的整体与部分的关系，但它是一种更强烈的聚合关系
在组合关系中，整体对象可以控制部分对象的生命周期，一旦整体对象不存在，部分对象也将不存在，部分对象不能脱离整体对象而存在，例如头和嘴的关系，头没了，嘴也就不存在了

依赖关系

依赖关系是一种使用关系，它是对象之间耦合度最弱的一种关联方式，是临时性的关联。在代码中，某个类的方法通过局部、方法的参数或者对静态方法的调用来访问另一个类（被依赖类）中的某些方法来完成一些职责

继承关系

继承关系是对象之间耦合度最大的一种关系，表示一般与特殊的关系，是父类与子类之间的关系，是一种继承关系

实现关系

实现关系是接口与实现类之间的关系。在这种关系中，类实现了接口，类中的操作实现了接口中声明的所有的抽象方法

软件设计原则

开闭原则

对扩展开放，对修改关闭。
在程序需要进行扩展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级

里氏替换原则

任何父类可以出现的地方，子类一定可以出现。
子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法

依赖倒转原则

高层模块不应该依赖底层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。
简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块之间的耦合

接口隔离原则

客户端不应该被迫依赖于它不使用的方法；一个类对另一个类的依赖应该建立在最小的接口上

迪米特法则

迪米特法则又叫最少知识原则
如果两个软件实体无需直接通信，那么就不应当发生直接的相关调用，可以同故宫第三方转发该调用。其目的时降低类之间的耦合度，提高模块的相互独立性

合成服用原则

尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现

创建者模式（5种）

单例模式

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象

饿汉模式

每个对象在没有使用之前就已经初始化了。这就可能带来潜在的性能问题：如果这个对象很大呢？没有使用这个对象之前，就把它加载到了内存中去是一种巨大的浪费


public final class EagerSingleton {
    
    private static EagerSingleton singObj = new EagerSingleton();

    private EagerSingleton() {
    }

    public static EagerSingleton getSingleInstance() {
        return singObj;
    }
}

懒汉模式

它使用了延迟加载来保证对象在没有使用之前，是不会进行初始化的。但是，通常这个时候面试官又会提问新的问题来***难一下。他会问：这种写法线程安全吗？回答必然是：不安全


public final class LazySingleton {

    private static LazySingleton singObj = null;

    private LazySingleton() {
    }

    public static LazySingleton getSingleInstance() {
        if (null == singObj ) {
            singObj = new LazySingleton();
        }
        return singObj;
    }
}

双重检查锁（Double-Checked Lock）

双重检查锁模式时一种非常好的单例实现模式，解决了单例、性能、线程安全问题，再加上volatile关键字来防止JVM底层进行指令重排操作，这样就比较完美的实现了单例模式


public final class DoubleCheckedSingleton {
	//volatile 防止JVM指令重排
    private static volatile DoubleCheckedSingletonsingObj = null;

    private DoubleCheckedSingleton() {
    }

	// 对外提供静态方法获取该对象
    public static DoubleCheckedSingleton getSingleInstance() {
        // 第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
        if (null == singObj ) {
            Synchronized(DoubleCheckedSingleton.class) {
                // 抢到锁之后再次判断是否为null
                if (null == singObj) {
                    singObj = new DoubleCheckedSingleton();
                }
            }
        }
        return singObj;
    }
}

静态内部类

这里又要提出一种新的模式——Initialization on Demand Holder. 这种方法使用内部类来做到延迟加载对象，在初始化这个内部类的时候，JLS(Java Language Sepcification)会保证这个类的线程安全。这种写法最大的美在于，完全使用了Java虚拟机的机制进行同步保证，没有一个同步的关键字


public class Singleton {
	// 私有构造方法
	private Singleton(){}

    // 定义一个静态内部类
    private static class SingletonHolder {
        public final static Singleton instance = new Singleton();
    }

    // 提供公共的访问方式
    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
}

第一次加载Singleton类时不会去初始化instance，只有第一次调用getInstance，虚拟机加载SingletonHolder并初始化instance，这样不仅能确保线程安全，也能保证Singleton类的唯一性

静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有任何加锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费

枚举方式

枚举类实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特殊性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式


public enum Singleton{
	INSTANCE;
}

破坏单例模式

破坏单例模式的方法有两种：序列化和反射

序列化的方式破坏单例模式


// 测试用序列化破坏单例模式
public class Test {

    public static void main(String[] args) throws Exception {
        writeObject2File();

        // 两次读取的对象地址不同，成功的破坏了单例模式
        readObjectFromFile();
        readObjectFromFile();
    }

    // 从文件读取数据（对象）
    public static void readObjectFromFile() throws Exception {
        // 创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("file path"));
        // 读取文件中的对象
        Singleton instance = (Singleton)ois.readObject();
        System.out.println(instance);
        // 释放资源
        ois.close();
    }

    // 向文件中写数据（对象）
    public static void writeObject2File() throws Exception {
        // 获取Singleton对象
        Singleton instance = new Singleton();
        // 创建对象输出流对象
        ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("file path"));
        // 写对象到文件中
        oos.writeObject(instance);
        // 释放资源
        oos.close();
    }
}

解决办法
在Singleton类中添加readResolve()方法，在反序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新new出来的对象


public class Singleton {
    // 私有构造方法
    private Singleton(){}

    // 定义一个静态内部类
    private static class SingletonHolder {
        public final static Singleton instance = new Singleton();
    }

    // 提供公共的访问方式
    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }

    // 当进行反序列化时，会自动调用该方法，将该方法的返回值直接返回
    public Object readResolve(){
        return SingletonHolder.instance;
    }
}

反射的方式破坏单例模式


// 测试用反射破坏单例模式
public class Test2 {
    public static void main(String[] args) {
        // 获取Singleton的字节码对象
        Class<Singleton> clazz = Singleton.class;
        // 获取无参构造方法
        Constructor cons = clazz.getDeclaredConstructor();
        // 取消访问检查
        cons.setAccessible(true);
        // 创建对象
        Singleton s1 = (Singleton)cons.newInstance();
        Singleton s2 = (Singleton)cons.newInstance();
        // 输出是false，表示破坏了单例模式
        System.out.println(s1 == s2);
    }
}

解决办法
在构造器中添加判断，如果多次调用构造器创建对象，抛出运行时异常


public class Singleton {

    private static boolean flag = false;

    // 私有构造方法
    private Singleton(){
        synchronized (Singleton.class){
            // 判断flag的值是否为true
            // true表示非第一次访问
            // false表示第一次访问
            if(flag){
                throw new RuntimeException("不能创建多个对象");
            }
            // 将flag设置为true
            flag = true;
        }
    }

    // 定义一个静态内部类
    private static class SingletonHolder {
        public final static Singleton instance = new Singleton();
    }

    // 提供公共的访问方式
    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }

    // 当进行反序列化时，会自动调用该方法，将该方法的返回值直接返回
    public Object readResolve(){
        return SingletonHolder.instance;
    }
}

JDK源码解析 - Runtime

JDK源码中的Runtime类就是使用的单例模式
在这里插入图片描述

原型模式

概述
用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象

结构
抽象原型类：规定了具体原型对象必须实现的clone方法
具体原型类：实现抽象原型类的clone方法，它是可被复制的对象
访问类：使用具体原型类中的clone方法来复制新的对象

原型模式的克隆分为浅克隆和深克隆
浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址
深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址

java中的Object类中提供的clone方法来实现浅克隆。cloneable接口是上面的类图中的抽象原型类，而实现clonebale接口的子实现类就是具体的原型类

代码示例


// 具体的原型类
public class Realizetype implements Cloneable{
    public Realizetype(){
        System.out.println("具体的原型对象创建完成");
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        System.out.println("具体原型复制成功");
        return super.clone();
    }
}

//测试
public class Client {
    public static void main(String[] args) throws Exception{
        //创建一个原型类对象
        Realizetype realizetype = new Realizetype();
        //调用Realizetype类中的clone方法进行对象的克隆
        Realizetype clone = (Realizetype)realizetype.clone();

        System.out.println(realizetype==clone);
    }
}

案例
用原型模式生成‘三好学生’奖状


//奖状类
public class Citation implements Cloneable{
    //三好学生上的姓名
    private String name;
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }

    public void show(){
        System.out.println(name+"同学：获得奖状");
    }

    @Override
    protected Citation clone() throws CloneNotSupportedException {
        return (Citation)super.clone();
    }
}

//测试
public class Client {
    public static void main(String[] args) throws Exception{
        //创建一个原型类对象
        Citation citation = new Citation();
        //克隆奖状对象
        Citation clone = (Citation)citation.clone();

        citation.setName("zhangsan");
        clone.setName("lisi");

        citation.show();
        clone.show();
    }
}

原型模式使用场景

对象的创建非常复杂，可以使用原型模式快捷的创建对象
性能和安全要求比较高

扩展（深克隆）

使用对象流的方式进行深克隆


//学生类，为了展示深克隆
public class Student implements Serializable {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

//奖状类
public class Citation implements Cloneable, Serializable {
    //三好学生上的姓名
    private Student student;
    public Student getStudent() {
        return student;
    }
    public void setStudent(Student student) {
        this.student = student;
    }
    public void show(){
        System.out.println(student.getName()+"同学：获得奖状");
    }
    @Override
    protected Citation clone() throws CloneNotSupportedException {
        return (Citation)super.clone();
    }
}

//测试
public class Client {
    public static void main(String[] args) throws Exception{
        //创建一个原型类对象
        Citation citation = new Citation();
        Student student = new Student();
        student.setName("zhangsan");
        citation.setStudent(student);

        //创建对象的流输出流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:/test.txt"));
        //将对象写入文件
        oos.writeObject(citation);
        //释放资源
        oos.close();

        //创建对象的输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:/test.txt"));
        //从文件中读取对象
        Citation citation1 = (Citation)ois.readObject();
        //释放资源
        ois.close();

        citation1.getStudent().setName("lisi");

        citation.show();
        citation1.show();
    }
}

注意：使用对象流的方式进行深克隆，相关的bean要实现序列化接口

工厂方法模式

工厂模式最大的优点就是解耦

以下几种工厂方法中，用的不变化示例代码


// 咖啡类
public abstract class Coffee {
    // 加糖
    public void addSuger(){
        System.out.println("加糖");
    }
    // 加奶
    public void addMilk(){
        System.out.println("加奶");
    }
    // 咖啡名称
    public abstract String getName();
}

//拿铁咖啡
public class LatteCoffee extends Coffee{
    // 名称
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

//美式咖啡
public class AmericanCoffee extends Coffee{
    // 名称
    @Override
    public String getName() {
        return "美式咖啡";
    }
}

简单工厂模式

抽象产品：定义了产品的规范，描述了产品的主要特性和功能
具体产品：实现或者继承抽象产品的子类
具体工厂：提供了创建产品的方法，调用者通过该方法来获取产品

代码示例


// 简单咖啡工厂类，生产咖啡
public class SimpleCoffeeFactory {
    public Coffee createCoffee(String type){
        //声明Coffee类型的变量，根据不同类型创建不同的Coffee子类对象
        Coffee coffee = null;
        if ("american".equals(type)) {
            coffee = new AmericanCoffee();
        } else if ("latte".equals(type)){
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("没有");
        }
        return coffee;
    }
}

// 咖啡店
public class CoffeeStore {
    public Coffee orderCoffee(String type){
        // 创建简单工厂
        SimpleCoffeeFactory simpleCoffeeFactory = new SimpleCoffeeFactory();
        // 调用工厂生产咖啡
        Coffee coffee = simpleCoffeeFactory.createCoffee("latte");
        // 加配料
        coffee.addMilk();
        coffee.addSuger();
        return coffee;
    }
}

// 测试类
public class Client {
    public static void main(String[] args) {
        //创建咖啡店类
        CoffeeStore coffeeStore = new CoffeeStore();
        //点餐
        Coffee coffee = coffeeStore.orderCoffee("latte");
        System.out.println(coffee.getName());
    }
}

优点：
封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在源代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展

缺点：
增加新产品时还是需要修改工厂类的代码，违反了“开闭原则”

扩展 - 静态工厂


// 简单咖啡工厂类，生产咖啡
public class SimpleCoffeeFactory {
    public static Coffee createCoffee(String type){
        //声明Coffee类型的变量，根据不同类型创建不同的Coffee子类对象
        Coffee coffee = null;
        if ("american".equals(type)) {
            coffee = new AmericanCoffee();
        } else if ("latte".equals(type)){
            coffee = new LatteCoffee();
        } else {
            throw new RuntimeException("没有");
        }
        return coffee;
    }
}

工厂方法模式

针对简单工厂的缺点，使用工厂方法模式就可以完美的解决，完全遵守开闭原则

概念：
定义一个用于创建对象的接口，让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类

结构：
抽象工厂：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品
具体工厂：主要是实现抽象工厂中的抽象方法，完成具体产品的创建
抽象产品：定义了产品的规范，描述了产品的主要特性和功能
具体产品：实现了抽象产品角色锁定义的接口，由具体工厂来创建，它同具体工厂之间一一对应

代码示例


//抽象工厂
public interface CoffeeFactory {
    //创建咖啡对象的方法
    Coffee createCoffee();
}

//美式咖啡工厂，专门生产美式咖啡
public class AmericanCoffeeFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }
}

//拿铁咖啡工厂，专门生产拿铁咖啡
public class LatteCoffeeFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }
}

// 咖啡店
public class CoffeeStore {
    private CoffeeFactory factory;

    public void setFactory(CoffeeFactory factory){
        this.factory = factory;
    }

    public Coffee orderCoffee(){
        // 调用工厂生产咖啡
        Coffee coffee = factory.createCoffee();
        // 加配料
        coffee.addMilk();
        coffee.addSuger();
        return coffee;
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        //创建咖啡店对象
        CoffeeStore store = new CoffeeStore();
        //创建工厂
        AmericanCoffeeFactory factory = new AmericanCoffeeFactory();
        store.setFactory(factory);
        //点咖啡
        Coffee coffee = store.orderCoffee();

        System.out.println(coffee.getName());
    }
}

优点：
用户只需要知道具体工厂的名称就可以得到需要的产品，无需知道产品的具体创建过程
在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无需对原工厂进行任何修改，满足开闭原则

缺点：
每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度

抽象工厂模式

概念：
是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无需指定需要产品的具体类就能得到同族的不同登基的产品的模式结构
抽象工厂模式是工厂方法模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品

结构：
抽象工厂：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品
具体工厂：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建
抽象产品：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品
具体产品：实现了抽象产品角色锁定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系

代码示例


//甜品抽象类
public abstract class Dessert {
    public abstract void show();
}

//提拉米苏
public class Trimisu extends Dessert {
    @Override
    public void show() {
        System.out.println("提拉米苏");
    }
}

//抹茶慕斯
public class MatchaMousse extends Dessert{
    @Override
    public void show() {
        System.out.println("抹茶慕斯");
    }
}

//抽象工厂
public interface DessertFactory {
    //生产咖啡
    Coffee createCoffee();
    //生产甜品
    Dessert createDessert();
}

//美式甜品工厂
public class AmericanDessertFactory implements DessertFactory {
    //美式咖啡
    @Override
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }
    //抹茶慕斯
    @Override
    public Dessert createDessert() {
        return new MatchaMousse();
    }
}

//意大利式甜品工厂
public class ItalyDessertFactory implements DessertFactory {
    //拿铁咖啡
    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }
    //提拉米苏
    @Override
    public Dessert createDessert() {
        return new Trimisu();
    }
}

//测试
public class client {
    public static void main(String[] args) {
        //创建的是意大利风味甜品工厂对象
        ItalyDessertFactory factory = new ItalyDessertFactory();
        //获取拿铁咖啡和提拉米苏
        Coffee coffee = factory.createCoffee();
        Dessert dessert = factory.createDessert();

        System.out.println(coffee.getName());
        dessert.show();
    }
}

优点
当一个产品族中的多个对象被设计成一起工作时，他能保证客户端始终只使用同一个产品族中的对象

缺点
当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改

模式扩展

简单工厂+配置文件解耦
可以通过工厂模式+配置文件的方式解除工厂对象和产品的耦合。在工厂类中加载配置文件中的全类名，并创建对象进行存储，客户端如果需要对象，直接进行获取即可

第一步：定义配置文件
为了演示方便，我们使用properties文件作为配置文件，名称为bean.properties

american=com.hupf.study.demo1.AmericanCoffee
latte=com.hupf.study.demo1.LatteCoffee

第二步：改进工厂类


public class CoffeeFactory {
    //加载配置文件，获取配置文件中配置的全类名，并创建该类的对象进行存储
    //定义容器对象存储咖啡对象
    private static Map<String, Coffee> map = new HashMap();

    static{
        //加载配置文件
        Properties p = new Properties();
        InputStream is = CoffeeFactory.class.getClassLoader().getResourceAsStream("bean.properties");

        try{
            p.load(is);
            // 遍历properties集合对象
            Set<Object> keys = p.keySet();
            for(Object key : keys){
                //根据键获取值（全类名）
                String className = p.getProperty((String) key);
                //获取字节码对象
                Class aClass = Class.forName(className);
                Coffee obj = (Coffee)aClass.newInstance();
                map.put((String)key,obj);
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }

    //根据名称获取对象
    public static Coffee createCoffee(String name){
        return map.get(name);
    }
}

//测试
public class client {
    public static void main(String[] args) {
        Coffee american = CoffeeFactory.createCoffee("american");
        System.out.println(american.getName());
    }
}

静态成员变量用来存储创建的对象（键存储的是名称，值存储的是对应的对象），而读取配置文件以及创建对象写在静态代码块中，目的就是只需要执行一次

JDK源码解析 - Collection.iterator方法

建造者模式

概述
将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示

分离了部件的构建（由Builder来负责）和装配（由Director负责）。从而可以构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况
由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象；相同的构建起，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用
建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无需知道其内部的具体构造细节

结构
抽象建造者类（Builder）：这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的对象部件的创建
具体建造者类（ConcreteBuilder）：实现Builder接口，完成复杂产品的各个部件的具体创建方法。再构造过程完后后，提供产品的实例
产品类（Product）：要创建的复杂对象
指挥者类（Director）：调用具体建造者来创建复杂对象的各个部分，再指挥者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建

创建自行车，代码示例


// 产品类，自行车
public class Bike {
    private String frame;//车架
    private String seat;//车座
    public String getFrame() {
        return frame;
    }
    public void setFrame(String frame) {
        this.frame = frame;
    }
    public String getSeat() {
        return seat;
    }
    public void setSeat(String seat) {
        this.seat = seat;
    }
    @Override
    public String toString() {
        return "Bike{" +
                "frame='" + frame + '\'' +
                ", seat='" + seat + '\'' +
                '}';
    }
}

//具体的构建者:构建膜拜单车
public class MobileBuilder extends Builder {
    @Override
    public void buildFrame() {
        bike.setFrame("碳纤维车架");
    }
    @Override
    public void buildSeat() {
        bike.setSeat("真皮车座");
    }
    @Override
    public Bike createBike() {
        return bike;
    }
}

//具体构建者：构建ofo
public class OfoBuilder extends Builder{
    @Override
    public void buildFrame() {
        bike.setFrame("铝合金车架");
    }
    @Override
    public void buildSeat() {
        bike.setSeat("橡胶车座");
    }
    @Override
    public Bike createBike() {
        return bike;
    }
}

//抽象构建者
public abstract class Builder {
    //声明Bike类型的变量，并赋值
    protected Bike bike = new Bike();
    //构建车架
    public abstract void buildFrame();
    //构建车座
    public abstract void buildSeat();
    //构建自行车
    public abstract Bike createBike();
}

//指挥者
public class Director {
    //声明builder类型的变量
    private Builder builder;
    public Director(Builder builder){
        this.builder=builder;
    }
    //组装自行车的方法
    public Bike construct(){
        builder.buildFrame();
        builder.buildSeat();
        return builder.createBike();
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        //创建指挥者对象
        Director director = new Director(new MobileBuilder());
        //让指挥者指挥组装自行车
        Bike bike = director.construct();

        System.out.println(bike.getFrame());
        System.out.println(bike.getSeat());
    }
}

注意
可以简化系统结构，把指挥者类和抽象建造者进行结合


//抽象构建者
public abstract class Builder {
    //声明Bike类型的变量，并赋值
    protected Bike bike = new Bike();
    //构建车架
    public abstract void buildFrame();
    //构建车座
    public abstract void buildSeat();
    //构建自行车
    public abstract Bike createBike();
    //组装自行车的方法
    public Bike construct(){
        builder.buildFrame();
        builder.buildSeat();
        return builder.createBike();
    }
}

说明
这样做确实简化了系统构建，但同时也加重了抽象建造者类的职责，也不是太符合单一职责原则，如果指挥者的组装方法过于复杂，建议还是封装到指挥者中

优点

建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在指挥者中对整体而言可以取得比较好的稳定性
在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象
可以更加精细的控制创建过程。将复杂的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程
建造者模式很容易扩展。如果由新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改已经测试通过的代码，因此也就不会对原有功能引入风险。符合开闭原则

缺点
建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制

使用场景
建造者（Builder）模式创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将他们组合在一起的算法却相对稳定，所以它通常在以下场合使用

创建的对象较复杂，由多个部件组成，各部件棉铃着复杂的变化，但构件间的较早顺序是稳定的
创建复杂对象的算法独立于该对象的组成部分以及他们的装配方式，即产品的构建过程和最终的表示是独立的

模式扩展

当一个类构造器需要传入很多参数时，如果创建这个类的实例，代码可读性会非常差，而且很容易引入错误，此时就可以利用建造者模式进行重构


public class Phone {
    private String cpu;
    private String screen;
    private String memory;
    private String mainborad;

    private Phone(Builder builder) {
        this.cpu=builder.cpu;
        this.screen=builder.screen;
        this.memory=builder.memory;
        this.mainborad=builder.mainborad;
    }

    public static final class Builder{
        private String cpu;
        private String screen;
        private String memory;
        private String mainborad;
        public Builder cpu(String cpu){
            this.cpu = cpu;
            return this;
        }
        public Builder screen(String screen){
            this.screen = screen;
            return this;
        }
        public Builder memory(String memory){
            this.memory = memory;
            return this;
        }
        public Builder mainborad(String mainborad){
            this.mainborad = mainborad;
            return this;
        }
        //使用构建者 创建Phobe对象
        public Phone build(){
            return new Phone(this);
        }
    }

    @Override
    public String toString() {
        return "Phone{" +
                "cpu='" + cpu + '\'' +
                ", screen='" + screen + '\'' +
                ", memory='" + memory + '\'' +
                ", mainborad='" + mainborad + '\'' +
                '}';
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        Phone phone = new Phone.Builder()
                .cpu("cpu")
                .mainborad("mainborad")
                .memory("memory")
                .screen("screen")
                .build();
        System.out.println(phone.toString());
    }
}

总结（创建者模式对比）

工厂方法模式 VS 建造者模式

工厂方法模式注重的是整体对象的创建方式；而建造者模式注重的是部件构建的过程，意在通过一步一步的精确构造创建出一个复杂的对象
我们举个简单例子来说明两者的差异，如果制造一个超人，如果使用工厂方法模式，直接产生出来的就是一个力大无穷、能够飞翔、内裤外穿的超人；而如果使用建造者模式，则需要组装手、脚、躯干等部分，然后再把内裤外穿，于是一个超人就诞生了

抽象工厂模式 VS 建造者模式

抽象工厂迷失实现对产品族的创建，一个产品家族是这样的一些列产品：具有不同分类维度的产品组合，采用抽象工厂模式则是不需要关心构建过程，只关心什么产品由什么工厂生产即可
建造者模式则是要求按照指定的蓝图建造产品，他的主要目的是通过组装零配件而产生一个新产品
如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族的产品，那么建造者模式就是一个汽车组装工厂，通过对部件的组装可以返回一辆完整的汽车

结构型模式（7种）

结构型模式描述如何将类或对象按某种布局组成更大的结构，它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者采用组合或聚合来组成对象

由于组合关系或聚合关系比继承关系耦合度低，满足“合成服用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性

结构型模式分为以下7种：

代理模式
适配器模式
装饰着模式
桥接模式
外观模式
组合模式
享元模式

代理模式

概述
由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介

java中的代理按照代理类生成时机不同又分为静态代理和动态代理。
静态代理代理类在编译期就生成
动态代理类则是Java运行时动态生成。动态代理又有JDK代理和CGLib代理两种

结构
抽象主题类（Subject）：通过接口或抽象类声明真实主题和代理对象实现的业务方法
真实主题类（Real Subject）：实现了抽象主题中的具体业务，时代理对象所代表的真实对象，是最终要引用的对象
代理类（proxy）：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能

静态代理

火车站卖票的例子


//卖火车票的接口
public interface SellTickets {
    public void sell();
}

//火车站卖票
public class TrainStation implements SellTickets{
    @Override
    public void sell() {
        System.out.println("火车站卖票");
    }
}

//代售点卖票
public class ProxyPoint implements SellTickets{
    //声明火车站类对象
    private TrainStation trainStation=new TrainStation();

    @Override
    public void sell() {
        System.out.println("代售点收取服务费");
        trainStation.sell();
    }
}

public class Client {
    public static void main(String[] args) {
        //创建代售点类对象
        ProxyPoint proxyPoint = new ProxyPoint();
        //卖票
        proxyPoint.sell();
    }
}

JDK动态代理

Java中提供了一个动态代理类Proxy，Proxy并不是我们上述所说的代理对象的类，而是提供了一个创建对象的静态方法（newProxyInstance方法）来获取代理对象


//卖火车票的接口
public interface SellTickets {
    public void sell();
}

//火车站卖票
public class TrainStation implements SellTickets{
    @Override
    public void sell() {
        System.out.println("火车站卖票");
    }
}

//获取代理对象的工厂类
public class ProxyFactory {
    //声明目标对象
    private TrainStation station = new TrainStation();
    //获取代理对象的方法
    public SellTickets getProxyObject(){
        //返回代理对象
        /**
         * classLoader:类加载器，用于加载代理类，可以通过目标对象获取类加载器
         * Class<?>[] interfaces:代理类实现的接口的字节码对象
         * InvocationHandler:代理对象的调用处理程序
         */
        SellTickets proxyObject = (SellTickets)Proxy.newProxyInstance(
                station.getClass().getClassLoader(),
                station.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     *
                     * @param proxy：代理对象。和proxyObject对象是同一个对象，在invoke方法中基本不用
                     * @param method：对接口中的方法进行封装的method对象
                     * @param args：调用方法的实际参数
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //代理类的增强
                        System.out.println("代理类收取服务费");
                        //执行目标对象的方法
                        Object invoke = method.invoke(station, args);
                        return invoke;
                    }
                }
        );
        return proxyObject;
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        //获取代理对象
        //创建代理工厂对象
        ProxyFactory proxyFactory = new ProxyFactory();
        //使用factory对象的方法获取代理对象
        SellTickets sellTickets = proxyFactory.getProxyObject();
        //调用真实对象方法
        sellTickets.sell();
    }
}

执行流程

在测试类中通过代理对象调用sell方法
根据多态的特性，执行的是代理类$Proxy中的sell方法
代理类$Proxy中的sell方法中又调用了InvocationHandler接口的子实现类对象的invoke方法
invoke方法通过反射执行了真实对象所属类中的sell方法

CGLib动态代理

CGLib是一个功能强大，高性能的代码生成包，它为没有实现接口的类提供代理，为JDk的动态代理提供了很好的补充

CGLib是第三方提供的包，所以需要引入jar包的坐标


<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.2.2</version>
</dependency>

代码示例


//火车站卖票
public class TrainStation{
    public void sell() {
        System.out.println("火车站卖票");
    }
}

//代理对象工厂，用来获取代理对象
public class ProxyFactory implements MethodInterceptor {
    //真实对象
    private TrainStation trainStation = new TrainStation();

    public TrainStation getProxyObject(){
        //创建Enhancer对象，类似于JDK代理中的Proxy类
        Enhancer enhancer = new Enhancer();
        //设置父类的字节码对象
        enhancer.setSuperclass(TrainStation.class);
        //设置回调函数
        enhancer.setCallback(this);
        //创建代理对象
        TrainStation proxyObject = (TrainStation)enhancer.create();
        return proxyObject;
    }


    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //调用目标对象的方法
        System.out.println("代售点收取服务费");
        trainStation.sell();
        return null;
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        //创建代理工厂对象
        ProxyFactory proxyFactory = new ProxyFactory();
        //获取代理对象
        TrainStation proxyObject = proxyFactory.getProxyObject();
        //调用代理对象中的sell方法卖票
        proxyObject.sell();
    }
}

三种代理的对比

JDK代理和CGLib代理

使用CGLib实现动态代理，CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，唯一需要注意的是，CGLib不能对生命为final的类或者方法进行代理，因为CGLib原理是动态生成被代理类的子类

在JDK1.8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于CGLib代理效率。所以如果有接口就使用JDK动态代理，没有接口使用CGLib代理

动态代理和静态代理

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转

如果接口增加一个方法，静态代理模式除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。而动态代理不会出现这样的问题

代理模式优点

代理模式在客户端与目标对象之间起到了一个中介作用和保护目标对象的作用
代理对象可以扩展目标对象的功能
代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度

代理模式缺点

增加了系统的复杂度

使用场景

远程代理
本地服务通过网络请求远程服务。为了实现本地到远程的通信，我们需要实现网络通信，处理其中可能的异常。为良好的代码设计和可维护性，我们将网络通信部分隐藏起来，只暴露给本地服务一个接口，通过该接口即可访问远程服务的功能，而不必过多关心通信部分代码

防火墙代理
当你将浏览器配置成使用代理功能时，防火墙就将你的浏览器的请求转给互联网；当互联网返回响应时，代理服务器再把它转给你的浏览器

保护代理
控制对一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限

适配器模式

生活中很多例子，比如充电器、读卡器，都可以抽象成适配器

将一个类的接口转换成客户希望的另一个接口，使原本由于接口不兼容而不能一起工作的哪些类能一起工作

适配器模式分为类适配器模式和对象适配器模式，前者类之间的耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少些

结构
目标接口（Target）：当前系统业务所期待的接口，它可以使抽象类接口
适配者类（Adapee）：他是被访问和适配的现存组件库中的组件接口
适配器类（Adapter）：他是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户目标接口的格式访问适配者

类适配器模式

读卡器代码示例


//适配者 接口
public interface TFCard {
    //从TF卡中读取数据
    public String readTF();
    //往TF卡中写数据
    public void writeTF(String string);
}
//适配者类
public class TFCardImpl implements TFCard{
    @Override
    public String readTF() {
        String msg = "TF Card read msg:hello world";
        return msg;
    }
    @Override
    public void writeTF(String string) {
        System.out.println("write : "+string);
    }
}

//目标接口
public interface SDCard {
    //从SD卡中读取数据
    public String readSD();
    //往SD卡中写数据
    public void writeSD(String string);
}
//目标类
public class SDCardImpl implements SDCard{
    @Override
    public String readSD() {
        String msg = "SD Card read msg:hello world";
        return null;
    }

    @Override
    public void writeSD(String string) {
        System.out.println("write : "+string);
    }
}

//计算机类
public class Computer {
    //从SD卡中读取数据
    public String readSD(SDCard sdCard){
        if(sdCard==null){
            throw new NullPointerException("不能为null");
        }
        return sdCard.readSD();
    }
}

//适配器类
public class SDAdapter extends TFCardImpl implements SDCard{
    @Override
    public String readSD() {
        System.out.println("adapter read tf card");
        return readTF();
    }

    @Override
    public void writeSD(String string) {
        System.out.println("adapter write tf card");
        writeTF(string);
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        //创建计算机对象
        Computer computer = new Computer();
        //读取SD卡中读取数据
        String msg = computer.readSD(new SDAdapter());
        System.out.println(msg);
    }
}

类适配器模式违背了合成复用原则。类适配器使客户类有一个接口规范的情况下可用，反之不可用

对象适配器模式

修改上述例子中的适配器类，不再继承适配者，而是将适配者依赖到适配器中


//适配器类
public class SDAdapterTF implements SDCard{
    //声明适配器类
    private TFCard tfCard;
    public SDAdapterTF(TFCard tfCard) {
        this.tfCard = tfCard;
    }
    @Override
    public String readSD() {
        System.out.println("adapter read tf card");
        return tfCard.readTF();
    }
    @Override
    public void writeSD(String string) {
        System.out.println("adapter write tf card");
        tfCard.writeTF(string);
    }
}

注意：还有一个适配器模式是接口适配器模式。当不希望实现一个接口中所有的方法时，可以创建一个抽象类Adpater，实现所有方法。而此时我们只需要继承该抽象类即可

应用场景

以前开发的系统存在满足新系统功能需求的类，但其接口新系统的接口不一致
使用第三方提供的组件，但组件接口定义和自己需求的接口定义不同

JDK源码解析

Reader（字符流）、InputStream（字节流）的适配使用的是就是InputStreamReader和OutputStreamWriter

InputStreamReader和OutputStreamWriter分别继承自java.io包中的Reader和writer，对他们中的抽象的未实现的方法给出实现

分析源码可以知道，InputStreamReader做了InputStream字节流类到Reader字符流之间的转换。StreadDecoder的设计实现在实际上采用了适配器模式

装饰器模式

在不改变现有对象结构的情况下，动态的给该对象增加一些职责的模式，即增加其额外功能

结构
抽象构建角色（Component）：定义一个抽象接口以规范准备接收附加责任的对象
具体构建角色（Concrete Component）：实现抽象构件，通过装饰角色为其添加一些职责
抽象装饰角色（Decorator）：继承或实现抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能
具体装饰角色（ConcreteDecorator）：实现抽象装饰的相关方法，并给具体构建对象添加附加的责任

快餐店代码示例


//快餐类(抽象构建角色)
public abstract class FastFood {
    private float price;//价格
    private String desc;//描述
    public FastFood(float price, String desc) {
        this.price = price;
        this.desc = desc;
    }
    public float getPrice() {
        return price;
    }
    public void setPrice(float price) {
        this.price = price;
    }
    public String getDesc() {
        return desc;
    }
    public void setDesc(String desc) {
        this.desc = desc;
    }
    public abstract float cost();
}

//炒饭（具体构件角色）
public class FriedRice extends FastFood{
    public FriedRice() {
        super(10,"炒饭");
    }
    @Override
    public float cost() {
        return getPrice();
    }
}

//炒面（具体构件角色）
public class FriedNoodles extends FastFood{
    public FriedNoodles() {
        super(12,"炒面");
    }
    @Override
    public float cost() {
        return getPrice();
    }
}

//装饰类（抽象装饰角色）
public abstract class Garnish extends FastFood{
    public Garnish(FastFood fastFood,float price, String desc) {
        super(price, desc);
        this.fastFood=fastFood;
    }
    //声明快餐类的变量
    private FastFood fastFood;
    public FastFood getFastFood() {
        return fastFood;
    }
    public void setFastFood(FastFood fastFood) {
        this.fastFood = fastFood;
    }
}

//鸡蛋类（具体的装饰者类）
public class Egg extends Garnish{
    public Egg(FastFood fastFood) {
        super(fastFood, 1, "鸡蛋");
    }
    @Override
    public float cost() {
        //计算价格
        return getPrice()+getFastFood().cost();
    }
    @Override
    public String getDesc() {
        return super.getDesc()+getFastFood().getDesc();
    }
}

//培根类（具体的装饰者类）
public class Bacon extends Garnish{
    public Bacon(FastFood fastFood) {
        super(fastFood, 2, "培根");
    }
    @Override
    public float cost() {
        //计算价格
        return getPrice()+getFastFood().cost();
    }
    @Override
    public String getDesc() {
        return super.getDesc()+getFastFood().getDesc();
    }
}

public class Client {
    public static void main(String[] args) {
        //点一份炒饭
        FastFood food = new FriedRice();
        //加鸡蛋
        food = new Egg(food);
        //加鸡蛋
        food = new Egg(food);

        System.out.println(food.getDesc()+" "+food.getPrice());
    }
}

优点

装饰者模式可以带来比继承更加灵活性的扩展功能，使用更加方便，可以通过组合不同的装饰着对象来获取具有不同行为状态的多样化的结果。装饰者模式比继承更具有良好的扩展性，完美的遵循开闭原则，继承是静态的附加责任，装饰着则是动态的附加责任
装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能

使用场景

当不能采用继承的方式对系统进行扩充或者采用继承不利于系统的扩展和维护
在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责
当对象的功能要求可以动态的添加，也可以再动态的撤销时

JDK源码分析
IO流中的包装类使用到了装饰者模式。BufferedInputStream，BufferedOutputStream，BufferedReader，BufferedWriter

BufferedWriter使用装饰者模式对writer子类实现类进行了增强，添加了缓冲区，提高了写数据的效率

代理和装饰者的区别

静态代理和装饰者模式的区别
相同点：
都要实现与目标类相同的业务接口
在两个类中都要声明目标对象
都可以在不修改目标类的前提下增强目标方法
不同点：
目的不同，装饰着时为了增强目标对象；静态代理时为了保护和隐藏目标对象
获取目标对象构建的地方不同，装饰者是由外界传递进来，可以通过构造方法传递；静态代理是在代理内部创建，以此来隐藏目标对象

桥接模式

将抽象与实现分离，使他们可以独立变化。他是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度

构建
抽象化角色（Abstraction）：定义抽象角色，并包含一个对实现化对象的引用
扩展抽象化角色（Refined Abstraction）：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法
实现化角色（Implementor）：定义实现化角色的接口，共扩展抽象化角色调用
具体实现化角色（Concrete Implementor）：给出实现化角色接口的具体实现

视频播放器代码示例


//视频文件，实现化角色
public interface VideoFile {
    //解码功能
    void decode(String fileName);
}

//avi视频文件，具体实现化角色
public class AVIFile implements VideoFile{
    @Override
    public void decode(String fileName) {
        System.out.println("avi视频文件："+fileName);
    }
}

//rmvb视频文件，具体实现化角色
public class RMVBFile implements VideoFile{
    @Override
    public void decode(String fileName) {
        System.out.println("rmvb视频文件："+fileName);
    }
}

//抽象的操作系统类，抽象化角色
public abstract class OperatingSystem {
    //声明videoFile变量
    protected VideoFile videoFile;
    public OperatingSystem(VideoFile videoFile) {
        this.videoFile = videoFile;
    }
    public abstract void play(String fileName);
}

//扩展抽象化角色（Mac操作系统）
public class Mac extends OperatingSystem {
    public Mac(VideoFile videoFile) {
        super(videoFile);
    }
    @Override
    public void play(String fileName) {
        videoFile.decode(fileName);
    }
}

//扩展抽象化角色（windows操作系统）
public class Windows extends OperatingSystem {
    public Windows(VideoFile videoFile) {
        super(videoFile);
    }
    @Override
    public void play(String fileName) {
        videoFile.decode(fileName);
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        //创建mac系统对象
        OperatingSystem mac = new Mac(new AVIFile());
        //使用操作系统播放视频文件
        mac.play("战狼");
    }
}

优点

桥接模式提高了系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统。如：如果现在还有一种视频文件类型wmv，我们只需要再定义一个实现VideoFile接口即可，其他类不需要发生变化
实现细节对客户透明

使用场景

当一个类存在两个独立变化的维度，且这两个维度都需要进行扩展时
当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时
当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性时。避免在两个层次之间建立静态的继承联系，通过桥接模式可以使他们在抽象层建立一个关联关系

外观模式

又名门面模式，是一种通过为多个复杂的子系统提供一个一致的接口，而使用这些子系统更加容易被访问的模式。该模式对外有一个统一接口，外部应用程序不用关心内部子系统的具体的细节，这样会大大降低应用程序的复杂度，提供了程序的可维护性。

外观模式是“迪米特法则”的典型应用

结构

外观角色（Facade）：为多个子系统对外提供一个共同的接口
子系统角色（Sub System）：实现系统的部分功能，客户可以通过外观角色访问它

代码示例

智能家电控制


//电灯类
public class Light {
    //开灯
    public void on(){
        System.out.println("打开电灯");
    }
    //关灯
    public void off(){
        System.out.println("关闭电灯");
    }
}

//电视类
public class TV {
    //开灯
    public void on(){
        System.out.println("打开电视");
    }
    //关灯
    public void off(){
        System.out.println("关闭电视");
    }
}

//空调类
public class AirCondition {
    //开灯
    public void on(){
        System.out.println("打开空调");
    }
    //关灯
    public void off(){
        System.out.println("关闭空调");
    }
}

//外观类
public class SmartAppliancesFacade {
    //聚合电灯对象、电视机对象、空调对象
    private Light light;
    private TV tv;
    private AirCondition airCondition;
    public SmartAppliancesFacade() {
        light = new Light();
        tv = new TV();
        airCondition = new AirCondition();
    }
    //通过语音控制
    public void say(String messsage){
        if (messsage.contains("打开")){
            on();
        } else if(messsage.contains("关闭")){
            off();
        } else {
            System.out.println("听不懂呀");
        }
    }
    //一件打开
    private void on(){
        light.on();
        tv.on();
        airCondition.on();
    }
    //一件关闭
    private void off(){
        light.off();
        tv.off();
        airCondition.off();
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        //创建智能音响对象
        SmartAppliancesFacade facade = new SmartAppliancesFacade();
        //控制家电
        facade.say("打开家电");
        facade.say("关闭家电");
    }
}

优点

降低了子系统与客户端之间的耦合度，使得子系统的变化不会影响调用他的客户类
对客户屏蔽了子系统组件，减少了客户处理的对象数目，并使得子系统使用起来更加容易

缺点
不符合开闭原则，修改很麻烦

使用场景

对分层结构系统构建时，使用外观模式定义子系统中每层的入口点可以简化子系统之间的依赖关系
当一个复杂的子系统很多时，外观模式可以为系统设计一个简单的接口共外界访问
当客户端与多个子系统之间存在很大的联系时，引热议外观模式可将他们分离，从而提供子系统的独立性和可移植性

组合模式

又名部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，他创建了对象组的树形结构

结构

抽象根节点（Component）：定义系统各层次对象的共有方法和属性，可以预先定义一些默认行为和属性
树枝节点（Composite）：定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构
叶子节点（Leaf）：叶子节点对象，其下再无分支，是系统层次遍历的最小单位

案例

软件菜单


//菜单组件(抽象根节点) 不管是菜单还是菜单项，都应该继承该类
public abstract class MenuComponent {
    //菜单组件的名称，层级
    protected String name;
    protected int level;
    //添加子菜单
    public void add(MenuComponent menuComponent){
        throw new UnsupportedOperationException();
    }
    //删除子菜单
    public void remove(MenuComponent menuComponent){
        throw new UnsupportedOperationException();
    }
    //获取指定的子菜单
    public MenuComponent getChild(int index){
        throw new UnsupportedOperationException();
    }
    //获取菜单或者菜单项的名称
    public String getName(MenuComponent menuComponent){
        return name;
    }
    //打印菜单名称的方法（包含子菜单和子菜单项）
    public abstract String print();
}

//菜单项类：叶子节点
public class MenuItem extends MenuComponent{
    public MenuItem(String name,int level) {
        this.name = name;
        this.level=level;
    }
    @Override
    public String print() {
        //打印菜单项的名称
        for (int i =0;i<level;i++){
            System.out.println("--");
        }
        System.out.println(name);
        return null;
    }
}

//菜单类：属于树枝节点
public class Menu extends MenuComponent{
    // 菜单可以有多个子菜单或者子菜单项
    private List<MenuComponent> menuComponentList = new ArrayList<>();
    public Menu(String name,int level) {
        this.name = name;
        this.level=level;
    }

    @Override
    public void add(MenuComponent menuComponent){
        menuComponentList.add(menuComponent);
    }
    @Override
    public void remove(MenuComponent menuComponent){
        menuComponentList.remove(menuComponent);
    }
    @Override
    public MenuComponent getChild(int index){
        return menuComponentList.get(index);
    }
    @Override
    public String getName(MenuComponent menuComponent){
        return name;
    }
    @Override
    public String print() {
        //打印菜单名称
        for (int i =0;i<level;i++){
            System.out.println("--");
        }
        System.out.println(name);
        //打印子菜单或者子菜单项名称
        for (MenuComponent component : menuComponentList) {
            component.print();
        }
        return null;
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        //创建菜单树
        MenuComponent menu1 = new Menu("菜单管理",2);
        menu1.add(new MenuItem("页面访问",3));
        menu1.add(new MenuItem("展示访问",3));
        menu1.add(new MenuItem("编辑访问",3));
        menu1.add(new MenuItem("删除访问",3));
        menu1.add(new MenuItem("新增访问",3));
        MenuComponent menu2 = new Menu("权限管理",2);
        menu2.add(new MenuItem("页面访问",3));
        menu2.add(new MenuItem("提交保存",3));
        MenuComponent menu3 = new Menu("角色管理",2);
        menu3.add(new MenuItem("页面访问",3));
        menu3.add(new MenuItem("新增角色",3));
        menu3.add(new MenuItem("修改角色",3));
        //创建一级菜单
        MenuComponent menu = new Menu("系统管理",1);
        menu.add(menu1);
        menu.add(menu2);
        menu.add(menu3);
        //打印菜单名称
        menu.print();
    }
}

组合模式的分类和优点

在使用组合模式时，根据抽象构件类的定义形式，我们可将组合模式分为透明组合模式和安全组合模式两种形式

优点

组合模式可以清楚的定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制
客户端可以一致的使用一个组合结构或其中单个对象，不必关心处理的时单个对象还是整个组合结构，简化了客户端代码
在组合模式中增加新的树枝节点和叶子节点都很方便，无需对现有类库进行任何修改，符合‘开闭原则’
组合模式为树形结构的面向对象实现提供一种灵活的解决方案，通过叶子节点和树枝节点的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单

使用场景

组合模式正是应树形结构而生，所以组合模式的使用场景就是出现树形结构的地方。比如：文件目录显示，多级目录呈现等树形结构数据的操作

享元模式

运用共享技术来有效的支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似对象的开销，从而提高系统资源的利用率

结构

享元模式中存在以下两种状态
内部状态，既不会随着环境的改变而改变的可共享部分
外部状态，指随环境改变的不可共享的部分。享元模式的实现要领就是区分应用中的两种状态，并将外部状态外部化

抽象享元角色（Flyweight）：
通常时一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）
具体享元角色（Concrete Flyweight）：
它实现了抽象享元类，称为享元对象；在具体享元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象
非享元角色（Unsharable Flyweight）：
并不是所欲的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象时可以直接通过实例化创建
享元工厂角色（Flyweight Factory）：
负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检查系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的化，则创建一个新的享元对象

示例

俄罗斯方块


//抽象享元角色
public abstract class AbstractBox {
    //获取图形的方法
    public abstract String getShape();
    //显示图形及颜色
    public void display(String color){
        System.out.println("shape:"+getShape()+" color:"+color);
    }
}

//I图形类，具体享元角色
public class IBox extends AbstractBox{
    @Override
    public String getShape() {
        return "I";
    }
}

//L图形类，具体享元角色
public class LBox extends AbstractBox{
    @Override
    public String getShape() {
        return "L";
    }
}

//O图形类，具体享元角色
public class OBox extends AbstractBox{
    @Override
    public String getShape() {
        return "O";
    }
}

//工厂类，将该类设计为单例
public class BoxFactory {
    private HashMap<String,AbstractBox> map;
    //在构造方法中进行初始化操作
    private BoxFactory() {
        map = new HashMap<>();
        map.put("I",new IBox());
        map.put("L",new LBox());
        map.put("O",new OBox());
    }
    //根据名称获取图形对象
    public AbstractBox getShape(String name){
        return map.get(name);
    }
    //提供一个方法获取该工厂类对象
    private static BoxFactory boxFactory = new BoxFactory();
    public static BoxFactory getInstance(){
        return boxFactory;
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        //获取I图形对象
        AbstractBox i = BoxFactory.getInstance().getShape("I");
        i.display("灰色");
        //获取O图形对象
        AbstractBox o = BoxFactory.getInstance().getShape("O");
        o.display("红色");
        //获取O图形对象
        AbstractBox o1 = BoxFactory.getInstance().getShape("O");
        o1.display("黑色");

        System.out.println(o==o1);
    }
}

优缺点和使用场景

优点

极大减少内存中相似或相同对象数量，节约系统资源，提供系统性能
享元模式中的外部状态相对独立，且不影响内部状态

缺点
为了使对象可以共享，需要将享元对象的部分状态外部化，分离内部状态和外部状态，使程序逻辑复杂

使用场景

一个系统有大量相同或者相似的对象，造成内存的大量耗费
对象的大部分状态可以外部化，可以将这些外部化传入对象中
在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式

JDK源码分析

Integer类使用了享元模式

行为型模式（11种）

行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配

行为型模式分为类行为模式和对象行为模式，前者采用继承机制来在类间分派行为，后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象行为模式比类行为模式具有更大的灵活性

行为型模式分为：

模板方法模式
策略模式
命令模式
职责链模式
状态模式
观察者模式
中介者模式
迭代器模式
访问者模式
备忘录模式
解释器模式

模板方法模式

定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义算法的某些特定步骤

结构


抽象类（Abstract Class）：负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成
	模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法
	基本方法：是实现算法各个步骤的方法，是模板方法的组成部分。基本方法又可以分为三种：
		抽象方法（Abstract Method）：一个抽象方法由抽象类声明、由其具体子类实现
		具体方法（Concrete Method）：一个具体方法由一个抽象类或具体类声明并实现，其子类可以进行覆盖也可以直接继承
		钩子方法（Hook Method）：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种
具体子类（Concrete Class）：实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的组成步骤

案例实现

炒菜


//模板方法，抽象类，定义模板方法和基本方法
public abstract class AbstractClass {
    //模板方法定义
    public final void cookProcess(){
        pourOil();
        heatOil();
        pourVegetable();
        pourSauce();
        fry();
    }
    public void pourOil(){
        System.out.println("倒油");
    }
    public void heatOil(){
        System.out.println("热油");
    }
    //放入食材
    public abstract void pourVegetable();
    //放入调料
    public abstract void pourSauce();
    public void fry(){
        System.out.println("炒呀炒呀");
    }
}

//子类
public class ConcreteClass_BaoCai extends AbstractClass{
    @Override
    public void pourVegetable() {
        System.out.println("放肉");
    }

    @Override
    public void pourSauce() {
        System.out.println("放辣椒");
    }
}

//子类
public class ConcreteClass_CaiXin extends AbstractClass{
    @Override
    public void pourVegetable() {
        System.out.println("放青菜");
    }

    @Override
    public void pourSauce() {
        System.out.println("放盐");
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        ConcreteClass_BaoCai c1 = new ConcreteClass_BaoCai();
        c1.cookProcess();

        ConcreteClass_CaiXin c2 = new ConcreteClass_CaiXin();
        c2.cookProcess();
    }
}

优缺点

优点

提高代码复用性，将相同部分的代码放在抽象的父类中，而将不同的代码放入不同的子类中
实现了反向控制，通过一个父类调用其子类的操作，通过对子类的具体实现扩展不同的行为，实现了反向控制，符合‘开闭原则’

缺点

对每个不同的实现都需要定义一个子类，这回导致类的个数增加，系统更加庞大，设计也更加抽象
父类中的抽象方法由子类实现，子类执行的结果会影响父类的结果，这导致一种反向的控制结构，它提高了代码阅读的难度

适用场景

算法的整体步骤很固定，但其中个别部分易变时，这时候可以使用模板方法模式，将容易变的部分抽象出来，供子类实现
需要通过子类来决定父类算法中某个步骤时候执行，实现子类对父类的反向控制

JDK源码分析

InputStream类使用了模板方法模式。在InputStream类中定义了抽象的read方法，并调用了这个抽象的read方法

策略模式

该模式定义了一些列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式树形对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分隔开来，并委派给不同的对象对这些算法进行管理

结构

抽象策略类（Strategy）：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有具体策略类所需的接口
具体策略类（Concrete Strategy）：实现了抽象策略定义的接口，提供具体的算法实现或行为
环境类（Context）：持有一个策略类的引用，最终给客户端调用

案例

促销活动


//抽象策略类
public interface Strategy {
    public void show();
}

//具体策略类,封装算法
public class StrategyA implements Strategy{
    @Override
    public void show() {
        System.out.println("满100减20");
    }
}

//具体策略类,封装算法
public class StrategyB implements Strategy{
    @Override
    public void show() {
        System.out.println("九折");
    }
}

//具体策略类,封装算法
public class StrategyC implements Strategy{
    @Override
    public void show() {
        System.out.println("满200送50代金券");
    }
}

//环境类，促销员，聚合策略
public class SalesMan {
    //聚合策略
    private Strategy strategy;
    public SalesMan(Strategy strategy) {
        this.strategy = strategy;
    }
    //由促销员展示活动内容
    public void salesManShow(){
        strategy.show();
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        //春节活动
        SalesMan salesMan1 = new SalesMan(new StrategyA());
        salesMan1.salesManShow();
        //情人节活动
        SalesMan salesMan2 = new SalesMan(new StrategyB());
        salesMan2.salesManShow();
        //店庆活动
        SalesMan salesMan3 = new SalesMan(new StrategyC());
        salesMan3.salesManShow();
    }
}

优缺点

优点

策略类之间可以自由切换，由于策略类都实现同一个接口，所以使他们之间可以自由切换
易于扩展，新增一个新的策略类只需要添加一个具体的策略类即可，基本不需要改变原有的代码，符合‘开闭原则’
避免使用多重条件选择语句（if else），充分体现面向对象设计思想

缺点

客户端必须知道所有的策略类，并自行决定使用哪一个策略类
策略模式将造成产生很多策略类，可以通过使用享元模式在一定程度上减少对象的数量

使用场景

一个系统需要动态的在集中算法中选择一种时，可将每个算法封装到策略类中
一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现，可将条件分支移入他们各自的策略类中以代替这些条件语句
系统中各算法彼此完全独立，且要求对客户隐藏具体算法的实现细节时
系统要求使用算法的客户不应该知道其操作的数据时，可使用策略模式来隐藏于算法相关的数据结构

JDK源码解析

Comparator中的策略模式，在Arrays类中有一个sort方法

命令模式

将一个请求封装为一个对象，使发出请求的责任和执行请求的之责任分隔开，这样两者之间通过命令对象进行沟通，这样方便将命令对象进行存储、传递、调用、增加与管理

结构

抽象命令类角色（Command）：定义命令的接口，声明执行的方法
具体命令角色（Concrete Command）：具体的命令，实现命令接口；通常会持有接收者，并调用接收者的功能来完成命令要执行的操作
实现者、接收者角色（Receiver）：接收者，真正执行命令的对象。任何类都可能成为一个接收者，只要他能够实现命令要求实现的相应功能
调用者、请求者角色（Invoker）：要求命令对象执行请求，通常会持有命令对象，可以持有很多的命令对象。这和使客户端真正触发命令并要求命令执行相应操作的地方，也就是说相当于使用命令对象的入口

示例代码

点餐过程


//抽象命令类
public interface Command {
    void execute();
}

//具体命令类
public class OrderCommand implements Command{
    //持有接收者对象
    private SeniorChef seniorChef;
    private Order order;
    public OrderCommand(SeniorChef seniorChef, Order order) {
        this.seniorChef = seniorChef;
        this.order = order;
    }
    @Override
    public void execute() {
        System.out.println(order.getDiningTable());
        order.getFoodDir().entrySet().forEach(x ->
                seniorChef.makeFood(x.getKey(),x.getValue())
        );
        System.out.println("finish");
    }
}

//订单类，
public class Order {
    //餐桌号码
    private int diningTable;
    //餐品及分数
    private Map<String,Integer> foodDir = new HashMap<>();
    public int getDiningTable() {
        return diningTable;
    }
    public void setDiningTable(int diningTable) {
        this.diningTable = diningTable;
    }
    public Map<String, Integer> getFoodDir() {
        return foodDir;
    }
    public void setFoodDir(String name, int num) {
        foodDir.put(name,num);
    }
}

//厨师类
public class SeniorChef {
    public void makeFood(String name,int num){
        System.out.println(name +" "+num);
    }
}

//服务员类，属于调用者角色
public class Waitor {
    //持有多个命令对象
    private List<Command> commands = new ArrayList<>();
    public void setCommand(Command cmd){
        commands.add(cmd);
    }
    //发起命令的功能
    public void orderUp(){
        System.out.println("订单来了");
        for (Command command : commands) {
            if(command!=null){
                command.execute();
            }
        }
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        //创建订单对象
        Order order1 = new Order();
        order1.setDiningTable(1);
        order1.setFoodDir("土豆丝",1);
        order1.setFoodDir("米饭",1);

        Order order2 = new Order();
        order2.setDiningTable(1);
        order2.setFoodDir("老汤干豆腐",1);
        order2.setFoodDir("米饭",1);

        //创建厨师对象
        SeniorChef seniorChef = new SeniorChef();
        //创建命令对象
        OrderCommand cmd1 = new OrderCommand(seniorChef,order1);
        OrderCommand cmd2 = new OrderCommand(seniorChef,order2);
        //创建服务员
        Waitor waitor = new Waitor();
        waitor.setCommand(cmd1);
        waitor.setCommand(cmd2);
        //服务员发起命令
        waitor.orderUp();
    }
}

优缺点

优点

降低系统的耦合度。命令模式能将调用操作的对象与实现该操作的对象解耦
增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类，它满足开闭原则，对扩展比较灵活
可以实现宏命令。命令模式可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令
方便实现Undo和Redo操作。命令模式可以与后面介绍的备忘录模式结合，实现命令的撤销与恢复

缺点

使用命令模式可能会导致某些系统有过多的具体命令类
系统结构更加复杂

使用场景

系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互
系统需求在不同的时间指定请求、将请求排队和执行请求
系统需要支持命令的撤销（Undo）操作和恢复（Redo）操作

JDK源码解析

Runnable是一个典型的命令模式，Runnable担当命令的角色，Thread充当的是调用者，start方法就是执行方法

责任链模式

又名职责链模式，为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的矗立着通过迁移对象记住其下一个对象的引用而连成一条链，当有请求发生时，可将请求沿着这条链传递，知道有对象处理它为止

结构

抽象处理者角色（Handler）：定义一个处理请求的接口，包含抽象处理方法和一个后继连接
具体处理者角色（Concrete Handler）：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否者将该请求转给它的后继者
客户类角色（client）：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程

示例代码

请假


//请假条
public class LeaveRequest {
    private String name;
    private int num;
    private String context;
    public LeaveRequest(String name, int num, String context) {
        this.name = name;
        this.num = num;
        this.context = context;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    public String getContext() {
        return context;
    }
    public void setContext(String context) {
        this.context = context;
    }
}

//组长
public class GroupLeader extends Handler {
    public GroupLeader() {
        super(0,Handler.num_one);
    }
    @Override
    protected void handlerLeave(LeaveRequest leave) {
        System.out.println(leave.getName()+" 请假"+leave.getNum()+"天 原因："+leave.getContext());
        System.out.println("组长同意");
    }
}

//部门经理
public class Manager extends Handler {
    public Manager() {
        super(Handler.num_one,Handler.num_three);
    }
    @Override
    protected void handlerLeave(LeaveRequest leave) {
        System.out.println(leave.getName()+" 请假"+leave.getNum()+"天 原因："+leave.getContext());
        System.out.println("部门经理同意");
    }
}

//总经理
public class GeneralManager extends Handler {
    public GeneralManager() {
        super(Handler.num_three,Handler.num_seven);
    }
    @Override
    protected void handlerLeave(LeaveRequest leave) {
        System.out.println(leave.getName()+" 请假"+leave.getNum()+"天 原因："+leave.getContext());
        System.out.println("总经理同意");
    }
}

//抽象处理者类
public abstract class Handler {
    protected final static int num_one = 1;
    protected final static int num_three = 3;
    protected final static int num_seven = 7;
    //该领导处理的请假天数区间
    private int numStart;
    private int numEnd;
    //声明后继者（上级领导）
    private Handler nextHandler;
    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }
    public Handler(int numStart) {
        this.numStart=numStart;
    }
    public Handler(int numStart, int numEnd) {
        this.numStart = numStart;
        this.numEnd = numEnd;
    }
    //各级领导处理请假体条的方法
    protected abstract void handlerLeave(LeaveRequest leave);
    //提交请假条
    public final void submit(LeaveRequest leave){
        //该领导进行审批
        this.handlerLeave(leave);
        if(this.nextHandler != null && leave.getNum()>this.numEnd){
            //提交给上级
            this.nextHandler.submit(leave);
        }else{
            System.out.println("流程结束");
        }
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        //创建一个请假条对象
        LeaveRequest leaveRequest = new LeaveRequest("小明", 1, "病了");
        //创建各级领导
        GroupLeader groupLeader = new GroupLeader();
        Manager manager = new Manager();
        GeneralManager generalManager = new GeneralManager();
        //设置处理链
        groupLeader.setNextHandler(manager);
        manager.setNextHandler(generalManager);
        //小明提交请假申请
        groupLeader.submit(leaveRequest);
    }
}

优缺点

优点

降低了对象之间的耦合度，该模式降低了请求发送者和接收者的耦合度
增强了系统的可扩展性，可以根据需要增加新的请求处理类，满足开闭原则
增加了给对象指派职责的灵活性，当工作流程发生变化，可以动态的改变链内的成员或者修改他们的次序，也可动态的新增或者删除责任
责任链简化了对象之间的连接，一个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，者避免了使用众多的if或者if。。。else语句
责任分担，每个类只需要处理自己该处理的工作，不能处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则

缺点

不能保证每个请求一定被处理。由于一个请求没有明确接收者，所以不能保证它一定会被处理，该请求可能一致传到链的末端都得不到处理
对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能收到一定影响
职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误而导致系统出错，如可能会造成循环调用

源码分析

在javaweb中，FilterChain是责任链（过滤器）模式的典型应用

状态模式

对有状态的对象，把复杂的’判断逻辑‘提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为

结构

环境角色（context）：也称为上下文，它定义了客户程序需要的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理
抽象状态角色（state）：定义一个接口，用以封装环境对象中的特定状态所对应的行为
具体状态角色（Context State）：实现抽象状态所对应的行为

代码示例


//抽象状态类
public abstract class LiftState {
    //声明环境角色类对象
    public Context context;
    public void setContext(Context context) {
        this.context = context;
    }
    public abstract void open();
    public abstract void close();
    public abstract void run();
    public abstract void stop();
}

//环境角色类
public class Context {
    //定义对应状态对象的常量
    public final static OpenningState opening_state = new OpenningState();
    public final static OpenningState closing_state = new OpenningState();
    public final static OpenningState running_state = new OpenningState();
    public final static OpenningState stopping_state = new OpenningState();
    //定义一个当前电梯状态变量
    private LiftState liftState;
    public LiftState getLiftState() {
        return liftState;
    }
    public void setLiftState(LiftState liftState) {
        this.liftState = liftState;
        this.liftState.setContext(this);
    }
    public void open(){
        this.liftState.open();
    }
    public void close(){
        this.liftState.close();
    }
    public void run(){
        this.liftState.run();
    }
    public void stop(){
        this.liftState.stop();
    }
}

//电梯开启 状态类
public class OpenningState extends LiftState{
    @Override
    public void open() {
        System.out.println("开启");
    }

    @Override
    public void close() {
        //设置状态
        super.context.setLiftState(Context.closing_state);
        //调用当前状态中的context中的close方法
        super.context.close();
    }

    @Override
    public void run() {
        //什么都不做
    }

    @Override
    public void stop() {
        //什么都不做
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        Context context = new Context();
        context.setLiftState(new RunningState());

        context.open();
        context.close();
        context.run();
        context.stop();
    }
}

优缺点

优点

将所有与某个状态有关的行为放到一个类中，并且可以方便的增加新的状态，只需要改变对象状态即可改变对象的行为
允许状态转换逻辑与状态对象何为议题，而不是某一个巨大的条件语句块

缺点

状态模式的使用必然会增加系统类和对象的个数
状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱
状态模式对开闭原则的支持并不太好

使用场景

当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式
一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时

观察者模式

又被称为发布订阅模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有观察者对象，是他们能够自动更新自己

结构

Subject：抽象主题（抽象被观察者），抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以由任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象
ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知
Observer：抽象观察者，时观察者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己
ConcreteObserver：具体观察者，实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态

代码示例

微信公众号


//抽象观察者
public interface Observer {
    void update(String message);
}

//具体观察者
public class WeiXinUser implements Observer{
    private String name;
    public WeiXinUser(String name) {
        this.name = name;
    }
    @Override
    public void update(String message) {
        System.out.println(name+"-"+message);
    }
}

//抽象主题
public interface Subject {
    //添加订阅者（添加观察者）
    void attach(Observer observer);
    //删除订阅者
    void detach(Observer observer);
    //通知订阅者更新信息
    void notify(String message);
}

//具体主题
public class SubscriptionSubject implements Subject{
    //定义一个集合，保存多个观察者
    private List<Observer> weixinUserList = new ArrayList<>();
    @Override
    public void attach(Observer observer) {
        weixinUserList.add(observer);
    }
    @Override
    public void detach(Observer observer) {
        weixinUserList.remove(observer);
    }
    @Override
    public void notify(String message) {
        //遍历集合
        for (Observer observer : weixinUserList) {
            observer.update(message);
        }
    }
}

public class Client {
    public static void main(String[] args) {
        //创建公众号对象
        SubscriptionSubject subject = new SubscriptionSubject();
        //订阅公众号
        subject.attach(new WeiXinUser("艾瑞利亚"));
        subject.attach(new WeiXinUser("概论"));
        subject.attach(new WeiXinUser("爱惜"));
        subject.attach(new WeiXinUser("EZ"));
        //公众号更新，发消息
        subject.notify("明天健身去");
    }
}

优缺点

优点

降低了目标与观察者之间的耦合关系，两者之间时抽象耦合关系
被观察者发送通知，所有注册的观察者都会收到信息

缺点

如果观察者非常多的话，那么所有的观察者收到被观察者发送的通知会耗时
如果被观察者有循环依赖的话，那么被观察者发送通知会使观察者循环调用，会导致系统崩溃

使用场景

对象间存在一对多关系，一个对象的状态发生改变会变化影响其他对象
当一个抽象模型有两个方面，其中一个方面依赖于另一方面时

JDK中提供的实现

在Java中，通过Observerable类（主题）和Observer接口（观察者）定义了观察者模式，只要实现他们的子类就可以编写观察者模式实例

中介者模式

又叫调停模式，定义一个中介角色来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立的改变他们之间的交互

结构

抽象中介者角色（Mediator）：他是中介者的接口，提供了同事对象注册于转发同事对象信息的抽象方法
具体中介者角色（ConcreteMediator）：实现中介者接口，定义一个List来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色
抽象同事类角色（Colleague）：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互营销那个的同事类的公共功能
具体同事类角色（Concrete Colleague）：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互

示例代码

租房子


//抽象中介者类
public abstract class Mediator {
    //沟通方法
    public abstract void constact(String message,Person person);
}

//具体中介者
public class MediatorStructure extends Mediator{
    //聚合房主和租房者
    private HouseOwner houseOwner;
    private Tenant tenant;
    public HouseOwner getHouseOwner() {
        return houseOwner;
    }
    public void setHouseOwner(HouseOwner houseOwner) {
        this.houseOwner = houseOwner;
    }
    public Tenant getTenant() {
        return tenant;
    }
    public void setTenant(Tenant tenant) {
        this.tenant = tenant;
    }
    @Override
    public void constact(String message, Person person) {
        if (person == houseOwner){
            tenant.getMessage(message);
        }else{
            houseOwner.getMessage(message);
        }
    }
}

//抽象同事类
public abstract class Person {
    protected String name;
    protected Mediator mediator;
    public Person(String name, Mediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }
}

//具体的同事角色类
public class Tenant extends Person{
    public Tenant(String name, Mediator mediator) {
        super(name, mediator);
    }
    //和中介沟通的方法
    public void constact(String message){
        mediator.constact(message,this);
    }
    //获取信息的方法
    public void getMessage(String message){
        System.out.println("租房子 "+name+" 信息"+message);
    }
}

//具体的同事角色类
public class HouseOwner extends Person{
    public HouseOwner(String name, Mediator mediator) {
        super(name, mediator);
    }
    //和中介沟通的方法
    public void constact(String message){
        mediator.constact(message,this);
    }
    //获取信息的方法
    public void getMessage(String message){
        System.out.println("房主 "+name+" 信息"+message);
    }
}

//测试
public class Client {
    public static void main(String[] args) {
        //创建中介者对象
        MediatorStructure mediator = new MediatorStructure();
        //创建租房者对象
        Tenant tenant = new Tenant("lisi", mediator);
        //创建房主对象
        HouseOwner houseOwner = new HouseOwner("zhangsan", mediator);
        //中介者要知道具体的房主和租房者
        mediator.setTenant(tenant);
        mediator.setHouseOwner(houseOwner);

        tenant.constact("我要租房");
        houseOwner.constact("我这有房子");
    }
}

优缺点

优点
松散耦合
中介者模式通过把多个同事对象之间的交互封装到中介者对象里面，从而使得同事对象之间松散耦合，基本上可以做到互补依赖。这样一来，同事对象就可以独立的变化和复用，而不再像以前那样牵一发而动全身了

集中控制交互
多个同事对象的交互，被封装在中介者对象里面集中管理，使得这些交互行为发生变化的时候，只需要修改中介者对象就可以了，当然如果时已经做好的系统，那么就扩展中介者对象，而各个同事类不需要做修改

一对多关联转变为一对一的关联
没有使用中介者模式的时候，同事对象之间的关系通常是一对多的，引入中介者对象以后，中介者对象和同事对象的关系通常变成双向的一对一，这会让对象的关系更容易理解和实现

缺点
当同事类太多时，中介者的职责将很大，他会变得复杂而庞大，以至于系统难以维护

使用场景

系统中对象之间存在负载的引用关系，系统结构混乱且难以理解
当向创建一个运行于多个类之间的对象，又不想生成新的子类时

迭代器模式

提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示

结构

抽象聚合角色（Aggreate）：定义存储、添加、删除聚合元素一级创建迭代器对象的接口
具体聚合角色（ConcreteAggregate）：实现抽象聚合类，返回一个具体迭代器的实例
抽象迭代器角色（Iterator）：定义访问和遍历聚合元素接口，通常包含hasNext、next等方法
具体迭代器角色（ConcreteIterator）：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置

代码示例

定义一个可以存储学生对象的容器对象，将遍历该容器的功能交由迭代器实现


//抽象迭代器角色
public interface StudentIterator {
    //判断时候还有元素
    boolean hasNext();
    //获取下一个元素
    Student next();
}

//具体迭代器角色
public class StudentIteratorImpl implements StudentIterator{
    private List<Student> list;
    private int index=0;
    public StudentIteratorImpl(List<Student> list) {
        this.list = list;
    }
    @Override
    public boolean hasNext() {
        return index<list.size();
    }

    @Override
    public Student next() {
        Student student = list.get(index);
        index++;
        return student;
    }
}

//抽象聚合角色
public interface StudentAggregate {
    //添加学生功能
    void addStudent(Student student);
    //删除学生功能
    void removeStudent(Student student);
    //获取迭代器对象功能
    StudentIterator getStudentIterator();
}

//具体聚合角色
public class StudentAggregateImpl implements StudentAggregate{
    private List<Student> list = new ArrayList<>();
    @Override
    public void addStudent(Student student) {
        list.add(student);
    }

    @Override
    public void removeStudent(Student student) {
        list.remove(student);
    }

    @Override
    public StudentIterator getStudentIterator() {
        return new StudentIteratorImpl(list);
    }
}

//元素
public class Student {
    private String name;
    private String number;
    public Student() {
    }
    public Student(String name, String number) {
        this.name = name;
        this.number = number;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getNumber() {
        return number;
    }
    public void setNumber(String number) {
        this.number = number;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", number='" + number + '\'' +
                '}';
    }
}

public class Client {
    public static void main(String[] args) {
        //创建聚合对象
        StudentAggregateImpl studentAggregate = new StudentAggregateImpl();
        //添加元素
        studentAggregate.addStudent(new Student("zhangsan","111"));
        studentAggregate.addStudent(new Student("lisi","222"));
        studentAggregate.addStudent(new Student("wangwu","333"));
        studentAggregate.addStudent(new Student("zhangliu","444"));
        //遍历聚合对象

        //获取迭代器对象
        StudentIterator studentIterator = studentAggregate.getStudentIterator();
        while (studentIterator.hasNext()){
            Student next = studentIterator.next();
            System.out.println(next.toString());
        }
    }
}

优缺点

优点

它支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法，我们也可以自己定义迭代器的子类以子类以支持新的遍历方式
迭代器简化了聚合类。由于引入了迭代器，在原有的聚合对象中不需要再自行提供数据遍历等方法，这样可以简化聚合类的设计
在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无需修改原有代码，满足开闭原则的要求

缺点
增加了类的个数，这在一定程度上增加了系统的复杂性

使用场景

当需要为聚合对象提供多种遍历方式时
当需要为遍历不同的聚合结构提供一个统一的接口时
当访问一个聚合对象的内容而无需暴露其内部细节的表示时

访问者模式

封装一些作用于某种数据结构中的各元素的操作，它可以在不改变这个数据结构的前提下定义作用于这些元素的操作

结构

抽象访问者角色（Visitor）：
定义了对每一个元素（Element）访问的行为，它的参数就是可以访问的元素，它的方法个数理论上来讲与元素个数是一样的，从这点不难看出，访问者模式要求元素类的个数不饿能改变
具体访问者角色（ConcreteVisitor）：
给出对每一个元素类访问时所产生的具体行为
抽象元素角色（Element）：
定义了一个接收访问者的方法，其意义是指，每一个元素都可以被访问者访问
具体元素角色（ConcreteElement）：
提供接收访问方法的具体实现，而这个具体的实现，通常情况下是使用访问者提供的访问该元素类的方法
对象结构角色（Object Structure）：
定义当中所提到的对象结构，对象结构式一个抽象表述，具体点可以理解为一个具有容器性质或者符合对象特性的类，他会含有一组元素，并且可以迭代这些元素，供访问者访问

代码示例

给宠物喂食
访问者角色：给宠物喂食的人
具体访问者角色：主人，其他人
抽象元素角色：动物
具体元素角色：猫、狗
结构对象角色：主人家


//抽象元素角色类
public interface Animal {
    //接收访问者访问的功能
    void accept(Person person);
}

//具体元素类
public class Dog implements Animal{
    @Override
    public void accept(Person person) {
        person.feed(this);
        System.out.println("汪汪汪");
    }
}

//具体元素角色类
public class Cat implements Animal{
    @Override
    public void accept(Person person) {
        person.feed(this);
        System.out.println("喵喵喵");
    }
}

//访问者角色类
public interface Person {
    //喂食
    void feed(Cat cat);
    void feed(Dog dog);
}

//具体访问者
public class Owner implements Person{
    @Override
    public void feed(Cat cat) {
        System.out.println("主人喂猫");
    }

    @Override
    public void feed(Dog dog) {
        System.out.println("主人喂狗");
    }
}

//具体访问者
public class Someone implements Person{
    @Override
    public void feed(Cat cat) {
        System.out.println("朋友喂猫");
    }

    @Override
    public void feed(Dog dog) {
        System.out.println("朋友喂狗");
    }
}

//结构对象
public class Home {
    //声明一个集合对象，用来存储元素对象
    private List<Animal> list = new ArrayList<>();
    //添加元素功能
    public void add(Animal animal){
        list.add(animal);
    }
    //
    public void action(Person person){
        for (Animal animal:list){
            animal.accept(person);
        }
    }
}

public class Client {
    public static void main(String[] args) {
        //创建home对象
        Home home = new Home();
        //添加元素
        home.add(new Cat());
        home.add(new Dog());
        //创建主人对象
        Owner owner = new Owner();
        home.action(owner);
    }
}

优缺点

优点

扩展性好，在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能
复用性好，通过访问者来定义整个对象接哦古通用的功能，从而提高复用程度
分离无关行为，通过访问者来分离无关的行为，把相关的行为封装在一起，构成一个访问者，这样每一个访问者的功能都比较单一

缺点

对象结构变化很困难，在访问者模式中，没增加一个新的元素类，都要在每一个具体访问者中增加相应的具体操作，这位被了开闭原则
违反了依赖导致原则，访问者模式依赖了具体类，而没有依赖抽象类

使用场景

对象结构相对稳定，但其擦欧总算法经常变化的程序
对象结构中的对象需要提供多种不同且不相关的操作，而且要避免让这些操作的变化影响对象的结构

备忘录模式

又叫快照模式，在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后当需要时能将该对象恢复到原先保存的状态

结构

发起人角色（Originator）：记录当前时刻的内部状态信息，提供创建备忘录数据的功能，实现其他业务共呢个，它可以访问备忘录里所有信息
备忘录角色（Memento）：负责存储发起人的内部状态，在需要的时候提供这些内部状态给发起人
管理者角色（Caretaker）：对备忘录进行管理，提供保护与获取备忘录的功能，但其不能对备忘录的内容进行访问和修改

窄接口：管理者对象看到的时备忘录的窄接口，这个窄接口只允许他把备忘录对象传给其他的对象
宽接口：与管理姐看到的窄接口相反，发起人对象可以看到一个宽接口，这个宽接口允许它读取所有的数据，一遍根据这些数据恢复这个发起人对象的内部状态

代码示例

游戏打boss
白箱备忘录模式（宽接口）


//备忘录角色类
public class RoleStateMemento {
    private int vit;
    private int atk;
    private int def;
    public RoleStateMemento() {
    }
    public RoleStateMemento(int vit, int atk, int def) {
        this.vit = vit;
        this.atk = atk;
        this.def = def;
    }
    public int getVit() {
        return vit;
    }
    public void setVit(int vit) {
        this.vit = vit;
    }
    public int getAtk() {
        return atk;
    }
    public void setAtk(int atk) {
        this.atk = atk;
    }
    public int getDef() {
        return def;
    }
    public void setDef(int def) {
        this.def = def;
    }
}

//游戏角色类（发起人角色）
public class GameRole {
    private int vit;//生命值
    private int atk;//攻击力
    private int def;//防御力
    //初始化内部状态
    public void initState(){
        this.vit=100;
        this.atk=100;
        this.def=100;
    }
    //战斗
    public void fight(){
        this.vit=0;
        this.atk=0;
        this.def=0;
    }
    //保存角色状态功能
    public RoleStateMemento saveState(){
        return new RoleStateMemento(vit,atk,def);
    }
    //恢复角色初始化状态
    public void recoverState(RoleStateMemento roleStateMemento){
        this.vit=roleStateMemento.getVit();
        this.atk=roleStateMemento.getAtk();
        this.def=roleStateMemento.getDef();
    }
    //展示状态
    public void stateDisplay(){
        System.out.println("GameRole{" +
                "vit=" + vit +
                ", atk=" + atk +
                ", def=" + def +
                '}');
    }
    public int getVit() {
        return vit;
    }
    public void setVit(int vit) {
        this.vit = vit;
    }
    public int getAtk() {
        return atk;
    }
    public void setAtk(int atk) {
        this.atk = atk;
    }
    public int getDef() {
        return def;
    }
    public void setDef(int def) {
        this.def = def;
    }
}

//管理者角色
public class RoleStateCaretaker {
    //声明RoleStateMemento类型的变量
    private RoleStateMemento roleStateMemento;
    public RoleStateMemento getRoleStateMemento() {
        return roleStateMemento;
    }
    public void setRoleStateMemento(RoleStateMemento roleStateMemento) {
        this.roleStateMemento = roleStateMemento;
    }
}

public class Client {
    public static void main(String[] args) {
        System.out.println("----大战boss前----");
        GameRole gameRole = new GameRole();
        gameRole.initState();
        gameRole.stateDisplay();
        //备份
        RoleStateCaretaker roleStateCaretaker = new RoleStateCaretaker();
        roleStateCaretaker.setRoleStateMemento(gameRole.saveState());

        System.out.println("----大战boss后----");
        gameRole.fight();
        gameRole.stateDisplay();
        System.out.println("----恢复----");
        gameRole.recoverState(roleStateCaretaker.getRoleStateMemento());
        gameRole.stateDisplay();
    }
}

黑箱备忘录模式（窄接口），实现双重接口的办法就是将备忘录类设计成发起人类的内部成员类


//备忘录接口，对外提供窄接口
public interface Memento {
}

//游戏角色类（发起人角色）
public class GameRole {
    private int vit;//生命值
    private int atk;//攻击力
    private int def;//防御力
    //初始化内部状态
    public void initState(){
        this.vit=100;
        this.atk=100;
        this.def=100;
    }
    //战斗
    public void fight(){
        this.vit=0;
        this.atk=0;
        this.def=0;
    }
    //保存角色状态功能
    public Memento saveState(){
        return new RoleStateMemento(vit,atk,def);
    }
    //恢复角色初始化状态
    public void recoverState(Memento memento){
        RoleStateMemento roleStateMemento = (RoleStateMemento)memento;
        this.vit=roleStateMemento.getVit();
        this.atk=roleStateMemento.getAtk();
        this.def=roleStateMemento.getDef();
    }
    //展示状态
    public void stateDisplay(){
        System.out.println("GameRole{" +
                "vit=" + vit +
                ", atk=" + atk +
                ", def=" + def +
                '}');
    }
    public int getVit() {
        return vit;
    }
    public void setVit(int vit) {
        this.vit = vit;
    }
    public int getAtk() {
        return atk;
    }
    public void setAtk(int atk) {
        this.atk = atk;
    }
    public int getDef() {
        return def;
    }
    public void setDef(int def) {
        this.def = def;
    }

    private class RoleStateMemento implements Memento{
        private int vit;//生命值
        private int atk;//攻击力
        private int def;//防御力
        public RoleStateMemento() {
        }
        public RoleStateMemento(int vit, int atk, int def) {
            this.vit = vit;
            this.atk = atk;
            this.def = def;
        }
        public int getVit() {
            return vit;
        }
        public void setVit(int vit) {
            this.vit = vit;
        }
        public int getAtk() {
            return atk;
        }
        public void setAtk(int atk) {
            this.atk = atk;
        }
        public int getDef() {
            return def;
        }
        public void setDef(int def) {
            this.def = def;
        }
    }
}

//管理者角色
public class RoleStateCaretaker {
    //声明RoleStateMemento类型的变量
    private Memento roleStateMemento;
    public Memento getRoleStateMemento() {
        return roleStateMemento;
    }
    public void setRoleStateMemento(Memento roleStateMemento) {
        this.roleStateMemento = roleStateMemento;
    }

}

public class Client {
    public static void main(String[] args) {
        System.out.println("----大战boss前----");
        GameRole gameRole = new GameRole();
        gameRole.initState();
        gameRole.stateDisplay();
        //备份
        RoleStateCaretaker roleStateCaretaker = new RoleStateCaretaker();
        roleStateCaretaker.setRoleStateMemento(gameRole.saveState());

        System.out.println("----大战boss后----");
        gameRole.fight();
        gameRole.stateDisplay();
        System.out.println("----恢复----");
        gameRole.recoverState(roleStateCaretaker.getRoleStateMemento());
        gameRole.stateDisplay();
    }
}

优缺点

优点

提供了一种可以恢复状态的机制。当用户需要时能够比较方便的将数据恢复到某个历史的状态
实现了内部状态的封装。除了创建它的发起人之外，其他对象都不能狗访问这些状态信息
简化了发起人类。发起人不需要管理和保存其内部状态的各个备份，所有状态信息都保存在备忘录中，并由管理者进行管理，这符合单一职责原则

缺点
资源消耗大，如果要保存的内部

使用场景

需要保存与恢复数据的场景，如玩游戏时的中间结果的存档功能
需要提供一个可回滚操作的场景，如word、记事本等软件使用Ctrl+Z组合键，还有数据库中的事务操作

解释器模式

自己定义语法

结构

抽象表达式角色（Abstract Expreession）：
定义解释器的接口，约定解释器的解释操作，主要包含解释方法interpret
终结符表达式角色（Terminal Expreession）：是抽象表达式的子类，用来实现文法中与终结符相关的操作，文法中的每一个终结符都有一个具体中介者表达式与之相对应
非终结符表达式角色（NonTerminal Expreession）：也是抽象表达式的子类，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非中介符表达式
环境角色（Context）：通常包含各个解释器需要的数据或是公共的功能，一般用来传递被所有解释器共享的数据，后面的解释器可以从这里获取这些值
客户端（Client）：主要任务是将需要分析的句子或表达式转换成使用解释器对象描述的抽象语法树，然后调用解释器的解释方法，当然也可以通过环境角色简介访问解释器的解释方法

代码示例

计算a-（b+c）


//抽象表达式类
public abstract class AbstractExpression {
    //解释的方法
    public abstract int interpret(Context context);
}

//环境角色类
public class Context {
    //定义一个map集合，用来存储变量及对应的值
    private Map<Variable,Integer> map = new HashMap<>();
    //添加变量的功能
    public void assign(Variable variable,Integer integer){
        map.put(variable,integer);
    }
    //根据变量获取对应的值
    public int getValue(Variable variable){
        return map.get(variable);
    }

}

//加法表达式类
public class Plus extends AbstractExpression{
    //+号左右的表达式
    private AbstractExpression left;
    private AbstractExpression right;
    public Plus(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }
    @Override
    public String toString() {
        return "Plus{" +
                "left=" + left +
                ", right=" + right +
                '}';
    }
    @Override
    public int interpret(Context context) {
        //将左右表达式的结果相加
        return left.interpret(context)+right.interpret(context);
    }
}

//封装变量的类
public class Variable extends AbstractExpression{
    //声明存储变量名的成员变量
    private String name;
    public Variable(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Variable{" +
                "name='" + name + '\'' +
                '}';
    }
    @Override
    public int interpret(Context context) {
        return context.getValue(this);
    }
}

public class Minus extends AbstractExpression{
    //-号左右的表达式
    private AbstractExpression left;
    private AbstractExpression right;
    public Minus(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }
    @Override
    public String toString() {
        return "Plus{" +
                "left=" + left +
                ", right=" + right +
                '}';
    }
    @Override
    public int interpret(Context context) {
        //将左右表达式的结果相加
        return left.interpret(context)-right.interpret(context);
    }
}

public class Client {
    public static void main(String[] args) {
        //创建环境对象
        Context context = new Context();
        //创建多个变量
        Variable a = new Variable("a");
        Variable b = new Variable("b");
        Variable c = new Variable("c");
        //将变量存储到环境对象中
        context.assign(a,1);
        context.assign(b,2);
        context.assign(c,3);
        //获取抽象语法树 a+b-c
        AbstractExpression expression = new Minus(a,new Plus(b,c));
        int interpret = expression.interpret(context);
        System.out.println(interpret);
    }
}

优缺点

优点

易于改变和扩展文法。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等级制来改变或扩展文法。每一条文法规则都可以表示为一个类，因此可以方便的实现一个简单的语言
实现文法较为容易。在抽象语法树中每一个表达式节点类的实现方式都是相似的，这些类的代码编写都不会特别复杂
增加新的解释表达式较为方便。如果用户需要增加新的解释表达式只需要对应增加一个新的终结符表达式或非终结符表达式类，原有表达式类代码无需修改，符合开闭原则

缺点

对于复杂文法难以维护。在解释器模式中，每一体哦啊规则至少需要定义一个类，因此如果一个语言包含太多文法规则，类的个数将会急剧增加，导致系统难以管理和维护
执行效率较低。由于在解释器模式中使用了大量的循环和递归调用，因此在解释较为复杂的句子时其速度很慢，而代码的调式过程也比较麻烦

使用场景

当语言的文法较为简单，且执行效率不是关键问题时
当问题重复出现，且可以用一种简单的语言来进行表达时
当一个语言需要解释执行，并且语言中的句子可以表示为一个抽象语法树的时候

综合练习

Spring IOC相关接口分析

BeanFactory解析

BeanFactory作为最顶层的一个接口，定义了IOC容器的基本功能规范
BeanFacory有三个重要的子接口：
ListableBeanFactory
HierarchicalBeanFactory
AutowireCapableBeanFactory
最终的默认实现类是DefaultListableBeanFactory

为什么要定义这么多接口呢
每个接口都有它的使用场合，主要是为了区分在spring内部操作过程中对象的传递和转化，对象的数据访问所做的限制，例如

ListableBeanFactory 接口表示这些Bean可列表化（存储）
HierarchicalBeanFactory 表示这些Bean是有继承关系的，也就是每个Bean可能有父Bean
AutowireCapableBeanFactory 接口定义Bean的自动装配规则

BeanFactory有一个很重要的子接口，就是ApplicationContext接口，该接口主要来规范容器中的bean对象是非延迟加载，即在创建容器对象的时候就对Bean进行初始化，存入容器中

Spring提供的IOC容器的实现：

ClasspathXmlApplicationContext：根据类路径加载xml配置文件，并创建IOC容器
FileSystemXmlApplicationContext：根据系统路径加载xml配置文件，并创建IOC容器
AnnotationConfigApplicationContext：加载注解类配置，并创建IOC容器

BeanDefinition解析

Bean对象在Spring实现中是以BeanDefinition来描述的

BeanDefinitionReader解析

BeanDefinitionReader 用于解析Spring配置文件，来获取Bean对象

BeanDefinitionRegistry解析

BeanDefinitionReader 用来解析Bean定义，并封装到BeanDefinition 对象，而我们定义的配置文件中定义了很多bean标签，这些bean解析出来发在BeanDefinition的注册中心，而该注册中心顶层接口就是BeanDefinitionRegistry

自定义SpringIOC


<beans>
	<bean id="userService" class="com.xx.UserServiceImpl">
		<property name="userDao" ref="userDao"></property>
	</bean>
	<bean id="userDao" class="com.xx.userDao"></bean>
</beans>

定义bean相关的pojo

定义PropertyValue类，对应bean标签中的property标签对象


/**
 * 用来封装bean标签下的property标签的属性
 * name属性
 * ref属性
 * value属性
 */
public class PropertyValue {
    private String name;
    private String ref;
    private String value;
    public PropertyValue() {
    }
    public PropertyValue(String name, String ref, String value) {
        this.name = name;
        this.ref = ref;
        this.value = value;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getRef() {
        return ref;
    }
    public void setRef(String ref) {
        this.ref = ref;
    }
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
}

一个bean标签可以有多个property 子标签，所以再定义一个MutablePropertyValues 类，用来存储并管理多个PropertyValue 对象


/**
 * 用来存储和管理多个PropertyValue对象
 */
public class MutablePropertyValues implements Iterable<PropertyValue> {
    //定义list对象，用来存储PropertyValue对象
    private final List<PropertyValue> propertyValues;
    public MutablePropertyValues(){
        propertyValues = new ArrayList<>();
    }
    public MutablePropertyValues(List<PropertyValue> propertyValues) {
        if (propertyValues == null) {
            this.propertyValues = new ArrayList<>();
        } else {
            this.propertyValues = propertyValues;
        }
    }
    //获取所有的PropertyValue对象，返回以数组的形式
    public PropertyValue[] getPropertyValues(){
        return propertyValues.toArray(new PropertyValue[0]);
    }
    //根据name属性值获取PropertyValue对象
    public PropertyValue getPropertyValue(String propertyName){
        for (PropertyValue propertyValue : propertyValues){
            if(propertyValue.getName().equals(propertyName)){
                return propertyValue;
            }
        }
        return null;
    }
    //判断集合是否为空
    public boolean isEmpty(){
        return propertyValues.isEmpty();
    }
    //添加PropertyValue对象
    public MutablePropertyValues addPropertyValue(PropertyValue propertyValue){
        //判断集合中存储的propertyValue对象是否和传递进来的重复
        for (int i = 0; i < propertyValues.size(); i++) {
            PropertyValue propertyValue1 = propertyValues.get(i);
            if(propertyValue.getName().equals(propertyValue1.getName())){
                propertyValues.set(i,propertyValue);
                return this;
            }
        }
        propertyValues.add(propertyValue);
        return this;
    }
    //判断是否有指定name属性值的对象
    public boolean contains(String propertyName){
        return getPropertyValue(propertyName)!=null;
    }
    //获取迭代器对象
    @Override
    public Iterator<PropertyValue> iterator() {
        return propertyValues.iterator();
    }
}

BeanDefinition 类用来封装bean信息的，主要包括id，class，property等属性和标签


/**
 * 用来封装bean标签数据
 * id属性
 * class属性
 * property子标签
 */
public class BeanDefinition {
    private String id;
    private String className;
    private MutablePropertyValues mutablePropertyValues;
    public BeanDefinition(){
        mutablePropertyValues = new MutablePropertyValues();
    }
    public BeanDefinition(String id, String className, MutablePropertyValues mutablePropertyValues) {
        this.id = id;
        this.className = className;
        this.mutablePropertyValues = mutablePropertyValues;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public MutablePropertyValues getMutablePropertyValues() {
        return mutablePropertyValues;
    }

    public void setMutablePropertyValues(MutablePropertyValues mutablePropertyValues) {
        this.mutablePropertyValues = mutablePropertyValues;
    }
}

定义注册表相关类

创建BeanDefinitionRegistry接口，定义了注册表的相关操作，如下：


/**
 * 注册表对象类，注册表的相关操作
 */
public interface BeanDefinitionRegistry {
    //注册BeanDefinition对象到注册表中
    void registerBeanDefinition(String beanName,BeanDefinition beanDefinition);

    //从注册表中删除指定名称的BeanDefinition对象
    void removeBeanDefinition(String beanName) throws Exception;

    //根据名称从注册表中获取BeanDefinition对象
    BeanDefinition getBeanDefinition(String beanName) throws Exception;

    //判断注册表中是否包含指定名称的BeanDefinition对象
    boolean containsBeanDefinition(String beanName);

    //获取注册表中BeanDefinition对象的个数
    int getBeanDefinitionCount();

    //获取注册表中所有的BeanDefinition的名称
    String[] getBeanDefinitionName();
}

SimpleBeanDefinitionRegistry 类实现BeanDefinitionRegistry接口，定义Map集合作为注册表容器


public class SimpleBeanDefinitionRegistry implements BeanDefinitionRegistry{
    private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();

    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
        beanDefinitionMap.put(beanName,beanDefinition);
    }

    @Override
    public void removeBeanDefinition(String beanName) throws Exception {
        beanDefinitionMap.remove(beanName);
    }

    @Override
    public BeanDefinition getBeanDefinition(String beanName) throws Exception {
        return beanDefinitionMap.get(beanName);
    }

    @Override
    public boolean containsBeanDefinition(String beanName) {
        return beanDefinitionMap.containsKey(beanName);
    }

    @Override
    public int getBeanDefinitionCount() {
        return beanDefinitionMap.size();
    }

    @Override
    public String[] getBeanDefinitionName() {
        return beanDefinitionMap.keySet().toArray(new String[0]);
    }
}

定义解析器相关类

BeanDefinitionReader接口，用来解析配置文件并在注册表中注册bean的信息


public interface BeanDefinitionReader {
    //获取注册表对象
    BeanDefinitionRegistry getRegistry();
    //加载配置文件并在注册表中进行注册
    void loadBeanDefinitions(String configLocation) throws Exception;
}

XmlBeanDefinitionReader 类是专门用来解析xml配置文件的，该类实现BeanDefinitionReader接口并实现接口中的两个功能


/**
 * 对xml配置文件进行解析
 */
public class XmlBeanDefinitionReader implements BeanDefinitionReader{
    //声明注册表对象
    private BeanDefinitionRegistry registry;

    public XmlBeanDefinitionReader() {
        this.registry = new SimpleBeanDefinitionRegistry();
    }

    @Override
    public BeanDefinitionRegistry getRegistry() {
        return registry;
    }

    @Override
    public void loadBeanDefinitions(String configLocation) throws Exception {
        //使用dom4j进行xml配置文件的解析
        SAXReader reader = new SAXReader();
        //获取类路径下的配置文件
        InputStream is = XmlBeanDefinitionReader.class.getClassLoader().getResourceAsStream(configLocation);
        Document document = reader.read(is);
        //根据Document对象获取根标签对象
        Element rootElements = document.getRootElement();
        //获取根标签下的所有的bean标签
        List<Element> beanElements = rootElements.element("bean");
        //遍历集合
        for(Element element : beanElements){
            String id = element.attributeValue("id");
            String className = element.attributeValue("class");
            BeanDefinition beanDefinition = new BeanDefinition();
            beanDefinition.setId(id);
            beanDefinition.setClassName(className);

            //创建
            MutablePropertyValues mutablePropertyValues = new MutablePropertyValues();

            //获取bean标签下所有的property对象
            List<Element> propertyElements = rootElements.element("property");
            for(Element pElement : propertyElements){
                String name = pElement.attributeValue("name");
                String ref = pElement.attributeValue("ref");
                String value = pElement.attributeValue("value");
                PropertyValue propertyValue = new PropertyValue(name, ref, value);
                mutablePropertyValues.addPropertyValue(propertyValue);
            }
            //将MutablePropertyValues对象封装到beanDefinition对象中
            beanDefinition.setMutablePropertyValues(mutablePropertyValues);
            //将beanDefinition注册到注册表中
            registry.registerBeanDefinition(id,beanDefinition);
        }
    }
}

IOC容器相关类

BeanFactory接口
在该接口中定义IOC容器的统一规范即获取bean对象


public interface BeanFactory {
    //根据bean对象的名称获取bean对象
    Object getBean(String name) throws Exception;
    //根据Bean对象的名称获取bean对象，并进行类型转换
    <T> T getBean(String name,Class<? extends T>clazz) throws  Exception;
}

ApplicationContext接口
该接口的所有的子实现类对bean对象的创建都是非延时的，所以在该接口中定义refresh方法


/**
 * 定义非延时加载功能
 */
public interface ApplicationContext extends BeanFactory{
    void refresh() throws Exception;
}

AbstractApplicationContext 类

作为ApplicationContext 接口的子类，所以该类也是非延时加载，所以需要在该类中定义一个map集合，作为bean对象存储的容器
声明BeanDefinitionReader 类型的变量，用来进行xml配置文件的解析，符合单一职责原则。BeanDefinitionReader 类型的对象创建交由子类实现，因为只有子类明确到底创建BeanDefinitionReader 哪个子类实现对象


/**
 * ApplicationContext接口的子实现类
 * 用于立即加载
 */
public abstract class AbstractApplicationContext implements ApplicationContext{
    protected BeanDefinitionReader beanDefinitionReader;
    //用来存储bean对象的容器
    protected Map<String,Object> singletonObjects = new HashMap<>();
    //声明配置文件路径的变量
    protected String configLocation;
    @Override
    public void refresh() throws Exception {
        //加载BeanDefinition对象
        beanDefinitionReader.loadBeanDefinitions(configLocation);
        //初始化bean
        finishBeanInitialization();
    }

    //bean的初始化
    private void finishBeanInitialization() throws Exception{
        //获取注册表对象
        BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
        //获取beanDefinition对象
        String[] beanNames = registry.getBeanDefinitionName();
        for (String beanName : beanNames){
            //进行bean的初始化
            getBean(beanName);
        }
    }
}

ClassPathXmlApplicationContext 类
该类主要是加载类路径下的配置文件，并进行bean对象的创建，主要完成以下功能：

在构造方法中，创建BeanDefinitionReader对象
在构造方法中，调用refresh方法，用于进行配置文件加载、创建bean对象并存储到容器中
重写父接口中的getBean方法，并实现依赖注入操作


/**
 * IOC容器具体的子实现类
 * 用于加载类路径下的xml格式的配置文件
 */
public class ClassPathXmlApplicationContext extends AbstractApplicationContext {

    public ClassPathXmlApplicationContext(String configLocation){
        this.configLocation=configLocation;
        //构建解析器对象
        beanDefinitionReader = new XmlBeanDefinitionReader();
        try{
            refresh();
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    //根据bean对象的名称获取bean对象
    public Object getBean(String name) throws Exception{
        //判断对象容器中是否包含指定名称bean对象
        Object o = singletonObjects.get(name);
        if(o != null){
            return o;
        }
        //获取beanDefinition对象
        BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
        BeanDefinition beanDefinition = registry.getBeanDefinition(name);
        //获取bean中的class
        String className = beanDefinition.getClassName();
        //反射创建对象
        Class<?> aClass = Class.forName(className);
        Object o1 = aClass.newInstance();
        //进行依赖注入
        MutablePropertyValues mutablePropertyValues = beanDefinition.getMutablePropertyValues();
        for (PropertyValue propertyValue : mutablePropertyValues){
            String pName = propertyValue.getName();
            String pValue = propertyValue.getValue();
            String pRef = propertyValue.getRef();
            if(pRef!=null && "".equals(pRef)){
                //获取依赖的bean对象
                Object bean = getBean(pRef);
                //拼接方法名
                String methodName = StringUtils.getSetterMethodName(pName);
                //获取所有的方法对象
                Method[] methods = aClass.getMethods();
                for (Method method:methods){
                    if(methodName.equals(method.getName())){
                        method.invoke(o1,bean);
                    }
                }
            }
            if(pValue!=null && "".equals(pValue)){
                //拼接方法名
                String methodName = StringUtils.getSetterMethodName(pName);
                Method method = aClass.getMethod(methodName,String.class);
                method.invoke(o1,pValue);
            }
        }

        //在返回对象前，加入容器
        singletonObjects.put(name,o1);
        return o1;
    }

    public <T> T getBean(String name,Class<? extends T> clazz) throws Exception{
        Object bean = getBean(name);
        if(bean == null){
            return null;
        }
        return clazz.cast(bean);
    }
}

总结

posted @ 2022-04-03 17:22 胡鹏飞阅读(34) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 【Java框架常用注解】

· SpringIoc 实现原理

· 设计模式-创建者模式

· 23种设计模式之创建者模式（二）

· 设计模式2——创建者模式

阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 从HTTP原因短语缺失研究HTTP/2和HTTP/3的设计差异
· 三行代码完成国际化适配，妙~啊~

公告

Live2D

欢迎阅读『【Java设计模式详解】学习笔记』

昵称：胡鹏飞
园龄： 5年10个月
粉丝： 0
关注： 1

+加关注

2025年3月

日

一

二

三

四

五

六

随笔档案

2022年4月(100)

天生逆鳞

【Java设计模式详解】学习笔记

设计模式相关内容

设计模式分类

创建型模式

结构型模式

行为型模式

UML图

类之间的关系

关联关系

聚合关系

组合关系

依赖关系

继承关系

实现关系

软件设计原则

开闭原则

里氏替换原则

依赖倒转原则

接口隔离原则

迪米特法则

合成服用原则

创建者模式（5种）

单例模式

饿汉模式

懒汉模式

双重检查锁（Double-Checked Lock）

静态内部类

枚举方式

破坏单例模式

序列化的方式破坏单例模式

反射的方式破坏单例模式

JDK源码解析 - Runtime

原型模式

扩展（深克隆）

工厂方法模式

简单工厂模式

扩展 - 静态工厂

工厂方法模式

抽象工厂模式

模式扩展

JDK源码解析 - Collection.iterator方法

建造者模式

模式扩展

总结（创建者模式对比）

工厂方法模式 VS 建造者模式

抽象工厂模式 VS 建造者模式

结构型模式（7种）

代理模式

静态代理

JDK动态代理

CGLib动态代理

三种代理的对比

JDK代理和CGLib代理

动态代理和静态代理

代理模式优点

代理模式缺点

使用场景

适配器模式

类适配器模式

对象适配器模式

应用场景

JDK源码解析

装饰器模式

代理和装饰者的区别

桥接模式

使用场景

外观模式

结构

代码示例

使用场景

组合模式

结构

案例

组合模式的分类和优点

使用场景

享元模式

结构

示例

优缺点和使用场景