本章Java设计模式的结构型模式的介绍，是通过学习视频记录的笔记，欢迎留言指出错误点

1. 代理模式

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

代理模式能将客户端与目标对象分离，降低系统的耦合度

分类：

     静态代理：在类的编译期就生成

     动态代理：java运行时动态生成（又分为JDK代理和CGLib代理）

结构：

     抽象主题类：通过接口或抽象类声明真实主题和代理对象实现的业务方法（SellTickets）

     真实主题类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象（TrainStation）

     代理类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能（ProxyPoint）

优点：

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

缺点：

• 增加系统复杂度

使用场景：

• 远程（Remote）代理 本地服务通过网络请求远程服务。为了实现本地到远程的通信，需要实现网络通信，处理其中可能的异常。为良好的代码设计和可维护性，将网络通信部分隐藏起来，只暴露给本地服务的一个接口，通过该接口即可访问远程服务提供的功能，而不必过多关心通信部分的细节。
• 防火墙（Firewall）代理 将浏览器配置成使用代理功能时，防火墙就将浏览器的请求转给互联网；当互联网返回响应时，代理服务器再把它转给浏览器
• 保护（Protect or Access）代理 控制对一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限

1.1 静态代理

/**
 * 静态代理
 *  卖票接口
 */
public interface SellTickets {
    void sell();
}

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

/**
 * 代理 代理对象
 * 访问对象和目标对象的中介
 * 代售点
 */
public class ProxyPoint implements SellTickets{

    private TrainStation station = new TrainStation();

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

//测试
ProxyPoint proxyPoint = new ProxyPoint();
proxyPoint.sell();

1.2 JDK动态代理

是java提供了一个动态代理类Proxy，不是代理对象类，只是提供了一个创建代理对象的静态方法（newProxyInstance方法）来获取代理对象【必须定义接口，对接口进行代理（这个接口是SellTickets）】

ProxyFactory是代理类？

不是，代理类是程序在运行过程中动态的在内存中生成的类。

动态代理的执行流程：

• 在测试类中通过代理对象调用sele()方法
• 根据多态的特性，执行的是代理类（$Proxy0）中的sell()方法
• 代理类（$Proxy0）中的sell()方法又调用InvacationHandler接口的子实现类对象的invoke方法
• invoke方法通过反射执行了真实对象所属类（TrainStation）中的sell()方法

/**
 * 代理工厂，用来创建代理对象
 *
 * 使用Proxy获取代理对象
 *  newProxyInstance()方法参数说明：
 *      ClassLoader loader：类加载器，用于加载代理类，使用真实对象的类加载器
 *      Class[] interfaces：真实对象所实现的接口，代理模式真实对象和代理对象实现相同的接口
 *      InvocationHandler h：代理对象的调用处理程序
 *
 *  InvocationHandler的invoke()方法参数说明：
 *      Object o：代理对象
 *      Method method：对应于在代理对象上调用的接口方法的Method实例
 *      Object[] objects：代理对象调用接口方法时传递的实际参数
 *
 */
public class ProxyFactory {
    private TrainStation station = new TrainStation();

    public SellTickets getProxyObject(){
        SellTickets sellTickets = (SellTickets) Proxy.newProxyInstance(
                station.getClass().getClassLoader(),
                station.getClass().getInterfaces(),
                new InvocationHandler() {
            @Override
            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                System.out.println("代理点收取服务费用");
                return method.invoke(station,objects);//执行真实对象
            }
        });
        return sellTickets;
    }
}

//测试
ProxyFactory factory = new ProxyFactory();
SellTickets sellTickets = factory.getProxyObject();
sellTickets.sell();

1.3 CGLIB动态代理

可以为没有实现接口的类提供代理

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

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

/**
 * CGLIB动态代理
 *  intercept方法参数说明：
 *   Object o：代理对象
 *   Method method：真实对象中的方法的Method实例
 *   Object[] objects：实际参数
 *   MethodProxy methodProxy：代理对象中的方法的method实例
 */
public class ProxyFactory implements MethodInterceptor {
    private TrainStation trainStation = new TrainStation();

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

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("代理点收取服务费用（CGLIB）");
        return methodProxy.invokeSuper(o,objects);
    }
}

//测试
//创建代理工厂对象
ProxyFactory factory = new ProxyFactory();
//获取代理对象
TrainStation proxyObject = factory.getProxyObject();
proxyObject.sell();

1.4 三种代理的对比

1.4.1 JDK代理和CGLIB代理

CGLIB底层采用ASM字节码生成框架，使用字节码技术生产代理类，jdk1.6前使用java反射效率高。因为CGLIB原理是动态生产被代理类的子类所以声明的类或者方法不能被final修饰

jdk1.6 1.7时，在调用次数较少，JDK代理效率高于CGLIB代理，当大量调用才会效率低，jdk1.8时，大量也是高于的。所以有接口用JDK代理，没有接口用CGLIB代理

（效率和接口两个方面进行对比）

1.4.2 动态代理和静态代理

动态代理的最大好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理(InvocationHandler.invoke)。这样在接口方法数量比较多的时候，可以灵活处理，而不是像静态代理那样每个方法进行中转。如果接口增加一个方法，静态代理模式除了所有实现类需要实现这个方法外，所有代理代理类也需要实现此方法，会增加代码维护的复杂度，动态代理不会出现

2. 适配器模式

概念：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起功能

（例子：tf卡的内容想在只能读取sd卡的电脑读取）

分类：

类适配器模式 （耦合度高，一般较少使用）

对象适配器模式

结构：

     目标接口：当前系统业务所期待的接口，可以是抽象类或接口（SDCard）

     适配者类：是被访问和适配的现存组件库中的组件接口（TFCard）

     适配器类：是一个转化器，通过继承或引用适配器的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者（SDAdapterTF）

StreamDecoder使用适配器模式

//SD卡的接口
public interface SDCard {
    //读取SD卡方法
    String readSD();
    //写入SD卡功能
    void writeSD(String msg);
}

//SD卡实现类
public class SDCardImpl implements SDCard {
    public String readSD() {
        String msg = "sd card read a msg :hello word SD";
        return msg;
    }

    public void writeSD(String msg) {
        System.out.println("sd card write msg : " + msg);
    }
}

//电脑类
public class Computer {

    public String readSD(SDCard sdCard) {
        if(sdCard == null) {
            throw new NullPointerException("sd card null");
        }
        return sdCard.readSD();
    }
}

//TF卡接口
public interface TFCard {
    //读取TF卡方法
    String readTF();
    //写入TF卡功能
    void writeTF(String msg);
}

//TF卡实现类
public class TFCardImpl implements TFCard {

    public String readTF() {
        String msg ="tf card read msg : hello word tf card";
        return msg;
    }

    public void writeTF(String msg) {
        System.out.println("tf card write a msg : " + msg);
    }
}

/**
 * 类适配器
 *  定义适配器类（SD兼容TF）
 */
public class SDAdapterTF extends TFCardImpl implements SDCard {

    public String readSD() {
        System.out.println("adapter read tf card ");
        return readTF();
    }

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

//类适配器测试类
public class Client {
    public static void main(String[] args) {
        Computer computer = new Computer();
        SDCard sdCard = new SDCardImpl();
        System.out.println(computer.readSD(sdCard));

        System.out.println("------------");

        SDAdapterTF adapter = new SDAdapterTF();
        System.out.println(computer.readSD(adapter));
    }
}


/**
 * 对象适配器
 *  定义适配器类（SD兼容TF）
 */
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 msg) {
        System.out.println("adapter write tf card");
        tfCard.writeTF(msg);
    }
}

//对象适配器测试
TFCardImpl tfCard = new TFCardImpl();
com.project.adapter.objAdapter.SDAdapterTF adapterTF2 = new com.project.adapter.objAdapter.SDAdapterTF(tfCard);
System.out.println(computer.readSD(adapterTF2));

3. 装饰者模式

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

（例子：快餐的炒饭额外加菜，价格不一样）

结构：

     抽象构件角色：定义一个抽象接口以规范准备接收附加责任的对象（FastFood）

     具体构件角色：实现抽象构件，通过装饰角色为其添加一些职责（FriedRice FriedNoodles）

     抽象装饰角色：继承或实现抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能（Garnish）

     具体装饰角色：实现抽象装饰的相关方法，并给具体构件对象添加附加责任（Egg Bacon）

使用场景：

• 当不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展和维护时。 不能采用继承的情况主要有两类： 第一类是系统中存在大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长； 第二类是因为类定义不能继承（如final类）
• 在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
• 当对象的功能要求可以动态地添加，也可以再动态地撤销时。

BufferedInputStream，BufferedOutputStream，BufferedReader，BufferedWriter用的装饰者模式

//快餐接口
public abstract class FastFood {
    private float price;
    private String desc;

    public FastFood() {
    }

    public FastFood(float price, String desc) {
        this.price = price;
        this.desc = desc;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    public float getPrice() {
        return 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, "炒饭");
    }

    public float cost() {
        return getPrice();
    }
}

//炒面
public class FriedNoodles extends FastFood {

    public FriedNoodles() {
        super(12, "炒面");
    }

    public float cost() {
        return getPrice();
    }
}

//配料类
public abstract class Garnish extends FastFood {

    private FastFood fastFood;

    public FastFood getFastFood() {
        return fastFood;
    }

    public void setFastFood(FastFood fastFood) {
        this.fastFood = fastFood;
    }

    public Garnish(FastFood fastFood, float price, String desc) {
        super(price,desc);
        this.fastFood = fastFood;
    }
}

//鸡蛋配料
public class Egg extends Garnish {

    public Egg(FastFood fastFood) {
        super(fastFood,1,"鸡蛋");
    }

    //getPrice()：鸡蛋价格 
    //getFastFood().getPrice()：炒饭或者炒面
    public float cost() {
        return getPrice() + getFastFood().getPrice();
    }

    @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().getPrice();
    }

    @Override
    public String getDesc() {
        return super.getDesc() + getFastFood().getDesc();
    }
}

//测试类
public class Client {
    public static void main(String[] args) {
        //点一份炒饭
        FastFood food = new FriedRice();
        //花费的价格
        System.out.println(food.getDesc() + " " + food.cost() + "元");

        System.out.println("========");
        //点一份加鸡蛋的炒饭
        FastFood food1 = new FriedRice();

        food1 = new Egg(food1);
        //花费的价格
        System.out.println(food1.getDesc() + " " + food1.cost() + "元");

        System.out.println("========");
        //点一份加培根的炒面
        FastFood food2 = new FriedNoodles();
        food2 = new Bacon(food2);
        //花费的价格
        System.out.println(food2.getDesc() + " " + food2.cost() + "元");
    }
}

代理模式和装饰者区别：

同：

• 都要实现与目标类相同的业务接口
• 在两个类中都要声明目标对象
• 都可以在不修改目标类的前提下增强目标方法

不同：

• 目的不同：

     装饰者是为了增强目标对象

     静态代理是为了保护和隐藏目标对象

• 获取目标对象构建的地方不同：

     装饰者是由外界传递进来，可以通过构造方法传递

     静态代理是在代理类内部创建，以此来隐藏目标对象

4. 桥接模式

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

（例子：创建不同图形，每个图形会有不同的颜色）

结构：

     抽象化角色：定义抽象类，并包含一个对实现化对象的引用（VideoFile）

     扩展抽象化角色：抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法（AVIFile REVBBFile）

     实现化角色：定义实现化角色的接口，供扩展抽象化角色调用（OperatingSystemVersion）

     具体实现化角色：给出实现化角色接口的具体实现（Windows Mac）

使用场景：

在一个有多种可能会变化的维度的系统中，用继承方式会造成类爆炸，扩展起来不灵活。每次在一个维度上新增一个具体实现都要增加多个子类

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

//视频文件
public interface VideoFile {
    void decode(String fileName);
}

//avi文件
public class AVIFile implements VideoFile {
    public void decode(String fileName) {
        System.out.println("avi视频文件："+ fileName);
    }
}

//rmvb文件
public class REVBBFile implements VideoFile {

    public void decode(String fileName) {
        System.out.println("rmvb文件：" + fileName);
    }
}

//操作系统版本
public abstract class OperatingSystemVersion {

    protected VideoFile videoFile;

    public OperatingSystemVersion(VideoFile videoFile) {
        this.videoFile = videoFile;
    }

    public abstract void play(String fileName);
}

//Windows版本
public class Windows extends OperatingSystemVersion {

    public Windows(VideoFile videoFile) {
        super(videoFile);
    }

    public void play(String fileName) {
        videoFile.decode(fileName);
    }
}

//mac版本
public class Mac extends OperatingSystemVersion {

    public Mac(VideoFile videoFile) {
        super(videoFile);
    }

    public void play(String fileName) {
        videoFile.decode(fileName);
    }
}

//测试类
public class Client {
    public static void main(String[] args) {
        OperatingSystemVersion os = new Windows(new AVIFile());
        os.play("战狼3");
    }
}

5. 外观模式

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

（例子：通过语音直接控制智能家电的开启和关闭）

结构：

     外观角色：为多个子系统对外提供一个公共的接口（SmartAppliancesFacade）

     子系统角色：实现系统的部分功能，客户可以通过外观角色访问它（Light TV AirCondition）

使用场景：

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

//灯类
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 message) {
        if(message.contains("打开")) {
            on();
        } else if(message.contains("关闭")) {
            off();
        } else {
            System.out.println("我还听不懂你说的！！！");
        }
    }

    //起床后一键开电器
    private void on() {
        System.out.println("起床了");
        light.on();
        tv.on();
        airCondition.on();
    }

    //睡觉一键关电器
    private void off() {
        System.out.println("睡觉了");
        light.off();
        tv.off();
        airCondition.off();
    }
}

//测试类
public class Client {
    public static void main(String[] args) {
        //创建外观对象
        SmartAppliancesFacade facade = new SmartAppliancesFacade();
        //客户端直接与外观对象进行交互
        facade.say("打开家电");
        facade.say("关闭家电");
    }
}

注：tomcat是web容器，接收浏览器发送过来的请求，tomcat会将请求信息封装成ServletRequest对象

6. 组合模式

概念：又名部分整体模式，是用于把一组相似的对象当做一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。可以创建对象组的树形结构

结构：

     抽象根节点：定义系统各层次对象的共有方法和属性，可以预先定义一些默认行为和属性（MenuComponent）

     树枝结点：定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构（Menu）

     叶子结点：叶子节点对象，其下再无分支，是系统层次遍历最小的单位（MenuItem）

分类：

1. 透明组合模式： 透明组合模式中，抽象根节点角色中声明了所有用于管理成员对象的方法，比如在示例中 MenuComponent 声明了 add、remove 、getChild 方法，这样做的好处是确保所有的构件类都有相同的接口。透明组合模式也是组合模式的标准形式。 透明组合模式的缺点是不够安全，因为叶子对象和容器对象在本质上是有区别的，叶子对象不可能有下一个层次的对象，即不可能包含成员对象，因此为其提供 add()、remove() 等方法是没有意义的，这在编译阶段不会出错，但在运行阶段如果调用这些方法可能会出错（如果没有提供相应的错误处理代码）
2. 安全组合模式 在安全组合模式中，在抽象构件角色中没有声明任何用于管理成员对象的方法，而是在树枝节点 Menu 类中声明并实现这些方法。安全组合模式的缺点是不够透明，因为叶子构件和容器构件具有不同的方法，且容器构件中那些用于管理成员对象的方法没有在抽象构件类中定义，因此客户端不能完全针对抽象编程，必须有区别地对待叶子构件和容器构件

使用场景：

     文件目录显示，多级目录等树形机构数据

/**
 * 组合模式
 *  菜单组件：属于抽象根节点
 */
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 i){
        throw new UnsupportedOperationException();
    }

    //获取菜单名称
    public String getName(){
        return name;
    }

    public void print(){
        throw new UnsupportedOperationException();
    }
}

/**
 * 菜单类：属于树枝节点
 */
public class Menu extends MenuComponent{
    private List<MenuComponent> menuComponentList;

    public Menu(String name,int level) {
        this.name = name;
        this.level = level;
        menuComponentList = new ArrayList<MenuComponent>();
    }


    @Override
    public void add(MenuComponent menuComponent) {
        menuComponentList.add(menuComponent);
    }

    @Override
    public void remove(MenuComponent menuComponent) {
        menuComponentList.remove(menuComponent);
    }

    @Override
    public MenuComponent getChild(int i) {
        return menuComponentList.get(i);
    }

    @Override
    public void print() {
        for (int i=1;i<level;i++){
            System.out.println("----");
        }
        System.out.println(name);
        for (MenuComponent menuComponent : menuComponentList) {
            menuComponent.print();
        }
    }
}

/**
 * 菜单项类：属于叶子节点
 */
public class MenuItem extends MenuComponent{
    public MenuItem(String name,int level) {
        this.name = name;
        this.level = level;
    }

    @Override
    public void print() {
        for (int i=1;i<level;i++){
            System.out.println("++");
        }
        System.out.println(name);
    }
}

//测试
//创建菜单树
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 component = new Menu("系统管理",1);
//将二级菜单添加到一级菜单中
component.add(menu1);
component.add(menu2);
component.add(menu3);
//打印菜单名称(如果有子菜单一块打印)
component.print();

7. 享元模式

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

状态：

     内部状态：即不会随着环境的改变而改变的可共享部分

     外部状态：随环境改变而改变的不可共享部分。它的实现要领是区分应用中的这两种状态，并将外部状态外部化

结构：

     抽象享元角色：通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）（AbstractBox）

     具体享元角色：实现抽象享元类，称为享元对象；再具体享元类中为内部状态提供了存储空间。可以结合单例模式设计，为每一个具体享元类提供唯一的享元对象（IBox LBox OBox）非享元角色：并不是所有的抽象享元类的子类都需要备共享，不能被共享的子类可设计为非具体享元类；当需要一个非共享具体享元类对象时，可以直接通过实例化创建

     享元工厂角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检查系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，就创建一个新的享元对象（BoxFactory）

使用场景：

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

/**
 * 抽象享元角色
 */
public abstract class AbstractBox {
    public abstract String getShape();

    public void display(String color){
        System.out.println("方块形状：" + this.getShape() + " 颜色：" + color);
    }
}

/**
 * 享元模式
 *  工厂类，将该类设计为单例
 */
public class BoxFactory {
    private static HashMap<String,AbstractBox> map;

    private BoxFactory(){
        map = new HashMap<>();
        map.put("I",new IBox());
        map.put("L",new LBox());
        map.put("O",new OBox());
    }

    private static BoxFactory factory = new BoxFactory();
    //提供一个方法获取该工厂类对象
    public static BoxFactory getInstance(){
        return factory;
    }

    //根据名称获取图形对象
    public AbstractBox getShape(String name){
        return map.get(name);
    }
}

/**
 * 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";
    }
}

//测试
AbstractBox box1 = BoxFactory.getInstance().getShape("I");
box1.display("灰色");

AbstractBox box2 = BoxFactory.getInstance().getShape("L");
box2.display("绿色");

AbstractBox box3 = BoxFactory.getInstance().getShape("O");
box3.display("灰色");

AbstractBox box4 = BoxFactory.getInstance().getShape("O");
box4.display("红色");

System.out.println("两次获取到的O图形对象是否是同一个对象：" + (box3 == box4));