设计模式-结构型模式

结构性模式描述如何将类或对象按某种布局组成更大的结构。

分为：
    类结构型模式：采用继承机制来组织接口和类
    对象结构型模式：采用组合或聚合来组合对象。耦合度更低，满足合成复用原则

一、代理模式

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

java中的代理按照代理类生成时机不同分为静态代理和动态代理。
静态代理：代理类在编译期生成
动态代理：在运行时动态生成。又分为JDK代理和CGLib代理

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

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

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

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("这里是代售点,需要10块钱服务费");
        station.sell();
    }
}

public class Client {

    public static void main(String[] args) {
        ProxyPoint proxyPoint = new ProxyPoint();
        proxyPoint.sell();
    }

}

2.JDK动态代理

java中提供了一个动态代理类Proxy，Proxy中提供了 newProxyInstance() 来获取代理对象

执行流程：
在测试类中通过对象调用sell()方法
根据多态的特性，执行的是代理类($Proxy0)中的sell()方法
代理类($Proxy0)中的sell()方法中又调用了InvocationHandler接口的自实现类对象的invake方法
invake方法通过反射执行了真实对象所属类(TrainStation)中的sell()方法

/**
 * 抽象主题类 : 买火车票的接口
 */
public interface SellTickets {

    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 loader : 类加载器,用于加载代理类,可以通过目标对象获取类加载器
         * Class[] interfaces : 代理类实现的接口的字节码对象
         * InvocationHandler h : 代理对象的调用处理程序
         */
        SellTickets proxyInstance = (SellTickets) Proxy.newProxyInstance(
            station.getClass().getClassLoader(),
            station.getClass().getInterfaces(),
            new InvocationHandler() {
                /**
                 * proxy : 代理对象 和proxyInstance是同一个对象,在invoke中基本不用
                 * method : 对接口中的方法进行封装的method对象
                 * args : 调用方法的实际参数
                 * 返回值 : 方法的返回值
                 */
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("代售点收取10块钱服务费");
                    //执行目标对象的方法
                    Object obj = method.invoke(station, args);
                    return obj;
                }
            }
        );
        return proxyInstance;
    }

}

public class Client {

    public static void main(String[] args) {
        //获取代理对象
        ProxyFactory factory = new ProxyFactory();
        SellTickets proxy = factory.getProxyObject();
        proxy.sell();
    }

}

3.CGLib动态代理

需要引入第三方jar包

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

CGLib底层采用ASM字节码生成框架，使用字节码技术

/**
 * 代理对象工厂
 */
public class ProxyFactory implements MethodInterceptor {

    private TrainStation station = new TrainStation();

    public TrainStation getProxyObject() {
        //类似于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("代售点坑人");
        //调用目标对象的方法
        Object obj = method.invoke(station, objects);
        return obj;
    }
}

/**
 * 真实主题类 : 火车站类
 */
public class TrainStation{

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

}

public class Client {

    public static void main(String[] args) {
        //创建代理工厂对象
        ProxyFactory factory = new ProxyFactory();
        //获取代理对象
        TrainStation proxy = factory.getProxyObject();
        //调用代理对象中的sell卖票
        proxy.sell();
    }

}

4.三种代理对比

JDK和CGLIB：
CGLIB底层采用ASM字节码生成框架，使用字节码技术生成代理类，在JDK1.6之前比使用java反射效率要高。
但是CGLIB不能对声明为final的类或者方法进行代理，因为CGLIB原理是动态生成被代理类的子类。
在JDK1.8的时候，JDK的效率高于CGLIB。
所以如果有接口就使用JDK代理，没有的话使用CGLIB代理

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

二、适配器模式

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

分类：
    类适配器：耦合度较高，要求了解现有组件库中的相关组件的内部结构，所以应用相对较少
    对象适配器：

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

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

1.类适配器模式

实现方式：定义一个适配器类来实现当前系统的业务接口，同时又继承现有组件库中已经存在的组件

违背了合成复用原则，在客户类有一个接口规范的情况下可以使用，如果没有就不能使用

/**
 * 目标接口
 */
public interface SDCard {

    String readSD();

    void writeSD(String msg);
}

/**
 * 具体类
 */
public class SDCardImpl implements SDCard{

    @Override
    public String readSD() {
        return "从SD卡读取数据";
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("向SD卡写入数据 : " + msg);
    }
}

/**
 * 适配者类的接口
 */
public interface TFCard {

    String read();

    void write(String msg);

}

/**
 * 适配者类
 */
public class TFCardImpl implements TFCard{

    @Override
    public String read() {
        return "TFCard读取了数据";
    }

    @Override
    public void write(String msg) {
        System.out.println("TFCard写入了数据 : " + msg);
    }
}

/**
 * 适配器类
 */
public class SDAdapterTF extends TFCardImpl implements SDCard{

    @Override
    public String readSD() {
        System.out.println("adapter read TFCard");
        return read();
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("adapter write TFCard");
        write(msg);
    }
}

/**
 * 计算机类
 */
public class Computer {

    //从SD卡中读取数据
    public String readSD(SDCard sdCard){
        if (sdCard == null){
            throw new NullPointerException("SDCard is not null");
        }
        return sdCard.readSD();
    }

}

public class Client {

    public static void main(String[] args) {
        Computer computer = new Computer();
        String s = computer.readSD(new SDCardImpl());
        System.out.println(s);
        System.out.println("================");
        String msg = computer.readSD(new SDAdapterTF());
        System.out.println(msg);
    }

}

2.对象适配器模式

不再去继承适配者类，而且聚合

/**
 * 适配器类
 */
public class SDAdapterTF implements SDCard {

    //声明适配者类
    private TFCard tfCard;

    public SDAdapterTF(TFCard tfCard){
        this.tfCard = tfCard;
    }

    @Override
    public String readSD() {
        System.out.println("adapter read TFCard");
        return tfCard.read();
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("adapter write TFCard");
        tfCard.write(msg);
    }
}

三、装饰者模式

指在不改变现有对象结构的情况下，动态地给该对象增加一些功能的模式

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

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

使用场景：
       1.当不能采用继承的方式对系统进行扩展或者采用继承不利于系统扩展和维护时
       不能采用继承：系统中存在大量独立的扩展，为支持每一种组合将产生大量的子类
                   类被定义为final
       2.在不影响其它对象的情况下，以动态、透明的方式给单个对象添加职责
       3.当对象的功能要求可以动态地添加，也可以动态地撤销时
      

/**
 * 抽象构件角色 ：快餐类
 */
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 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{

    private static final float price = 10;
    private static final String desc = "炒饭";

    public FriedRice(){
        super(price,desc);
    }

    @Override
    public float cost() {
        return super.getPrice();
    }
}

/**
 * 具体构件角色 ：炒面
 */
public class FiredNoodles extends FastFood{

    private static final float price = 12;
    private static final String desc = "炒面";

    public FiredNoodles(){
        super(price,desc);
    }

    @Override
    public float cost() {
        return super.getPrice();
    }
}

/**
 * 抽象装饰角色
 */
public abstract class Garnish extends FastFood{

    //声明快餐类的变量
    private FastFood fastFood;

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

    public FastFood getFastFood() {
        return fastFood;
    }

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

/**
 * 具体装饰者角色
 */
public class Egg extends Garnish{

    private static final float price = 1;
    private static final String desc = "鸡蛋";

    public Egg(FastFood fastFood){
        super(price,desc,fastFood);
    }

    @Override
    public float cost() {
        //计算价格
        return price + super.getFastFood().cost();
    }

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

/**
 * 具体装饰者角色
 */
public class Bacon extends Garnish{

    private static final float price = 3;
    private static final String desc = "培根";

    public Bacon(FastFood fastFood){
        super(price,desc,fastFood);
    }

    @Override
    public float cost() {
        //计算价格
        return price + super.getFastFood().cost();
    }

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

public class Test {

    public static void main(String[] args) {
        //炒饭
        FastFood food = new FriedRice();
        System.out.println(food.getDesc() + "  " + food.cost() + "元");

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

        //加鸡蛋
        food = new Egg(food);
        System.out.println(food.getDesc() + "  " + food.cost() + "元");

        System.out.println("---------------------");
        //再加鸡蛋
        food = new Egg(food);
        System.out.println(food.getDesc() + "  " + food.cost() + "元");

        System.out.println("---------------------");
        //再加培根
        food = new Bacon(food);
        System.out.println(food.getDesc() + "  " + food.cost() + "元");
    }

}

静态代理和装饰者的区别

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

四、桥接模式

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

结构：
    抽象化角色：定义抽象类，并包含一个对实现化对象的引用
    扩展抽象化角色：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法
    实现化角色：定义实现化角色的接口，供扩展抽象化角色调用
    具体实现化角色：给出实现化角色接口的具体实现
    
优点：
    1.提高了系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统
    2.实现细节对客户透明
    
使用场景：
       1.当一个类存在两个独立变化的维度，且这两个维度都需要进行扩展时
       2.当一个系统不希望使用继承或其它多层次继承导致类的个数急剧增加时
       3.当一个系统需要在构件的抽象化和具体角色之间增加更多的灵活性时。避免在两个层次之间建立静态的继
         承联系，通过桥接模式可以使他们在抽象层建立一个关联关系

/**
 * 实现化角色
 */
public interface VideoFile {

    //解码
    void decode(String fileName);

}

/**
 * 具体实现化角色
 */
public class AVIFile implements VideoFile{

    @Override
    public void decode(String fileName) {
        System.out.println("avi视频文件 : " + fileName);
    }
}

/**
 * 具体实现角色
 */
public class RMVBFile implements VideoFile{

    @Override
    public void decode(String fileName) {
        System.out.println("rmvb视频文件 : " + fileName);
    }
}

/**
 * 抽象化角色
 */
public abstract class OpratingSystem {

    public VideoFile videoFile;

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

    public abstract void play(String fileName);

}

/**
 * 扩展抽象化角色
 */
public class Windows extends OpratingSystem{

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

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

/**
 * 扩展抽象化角色
 */
public class Mac extends OpratingSystem{

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

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

public class Test {

    public static void main(String[] args) {
        OpratingSystem system = new Mac(new AVIFile());
        system.play("飞升.avi");
    }

}

五、外观模式

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

结构：
    外观角色：为多个子系统对外提供一个公共的接口
    子系统角色：实现系统的部分功能，外部可以通过外观角色访问它
    
优点：
    1.降低了子系统和客户端之间的耦合度，使得子系统的变化不会影响调用它的类
    2.对客户屏蔽了子系统组件，减少了客户处理的对象的数目，并使得子系统使用起来更加容易
    
缺点：
    不符合开闭原则，修改很麻烦
    
使用场景：
       1.对分层结构系统构建时，使用外观模式定义子系统中每层的入口点可以简化子系统之间的依赖关系
       2.当一个复杂系统的子系统很多时，外观模式可以为系统设计一个简单的接口供外界访问
       3.当客户端与多个子系统之间存在很大的联系时，引入外观模式可将它们分离，
         从而提高子系统的独立性和可移植性

/**
 * 子系统角色
 */
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 msg){
        if (msg.contains("打开")){
            this.on();
        } else if (msg.contains("关闭")) {
            this.off();
        } else {
            System.out.println("请说出正确指令");
        }
    }

    private void on(){
        light.on();
        airCondition.on();
        tv.on();
    }

    private void off(){
        light.off();
        airCondition.off();
        tv.off();
    }
}

public class Test {

    public static void main(String[] args) {
        SmartAppliancesFacade smart = new SmartAppliancesFacade();
        smart.say("把他们打开");
        System.out.println("----------------");
        smart.say("把他们关闭");
    }

}

六、组合模式

用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次

结构：
    抽象根节点：定义系统各层次对象的共有方法和属性，可以预先定义一些默认行为和属性
    树枝节点：定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构
    叶子节点：叶子节点对象，其下再无分支，是系统层次遍历的最小单位
    
分类：根据抽象构建类的定义形式，可以将组合模式分为透明组合模式和安全组合模式两种形式
1.透明组合模式：
  抽象根节点角色中声明了所有用于管理成员对象的方法，这样做的好处是确保所有的构件类都有相同的接口，
  是组合模式的标准形式。
  透明模式的缺点是不够安全，因为叶子对象和容器对象在本质上是有区别的，叶子对象不可能有下一个层次的对象，
  即不可能包含成员对象，因此为其提供某些方法是没有意义的，这在编译阶段不会出错，
  但是在运行阶段如果调用这些方法可能会出错。
2.安全组合模式：
  在抽象构件角色中没有声明任何用于管理成员对象的方法，而是在树枝节点类中声明这些方法。
  缺点是不够透明，因为叶子构件和容器构件具有不同的方法，且容器构件中那些用于管理成员对象的方法没有
  在抽象构件中定义，因此在客户端不能完全针对抽象编程，因此有区别的对待叶子构件和容器构建。

优点：
    1.组合模式可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，他让客户端忽略了层次的差异，
      方便对整个层次结构进行控制
    2.客户端可以一致的使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合，
      简化了客户端代码
    3.在组合模式中增加新的树枝节点和叶子节点都很方便，无须对现有类库进行任何修改
    4.组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子节点和树枝节点的递归组合，
      可以形成复杂的树形结构，但对树形结构的控制却非常简单
    
使用场景：
       在出现树形结构的地方，比如：文件目录显示、多级目录呈现等

/**
 * 抽象根节点
 */
public abstract class MenuComponent {

    public String name;
    public 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(){
        return name;
    }

    //打印菜单名称(包含子菜单和子菜单项)
    public abstract void print();

}

/**
 * 树枝节点
 */
public class Menu extends MenuComponent{

    //菜单可以有多个子菜单或者子菜单项
    private List<MenuComponent> list = new ArrayList<>();

    public Menu(String name,int level){
        this.name = name;
        this.level = level;
    }

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

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

    @Override
    public MenuComponent getChild(int index) {
        return list.get(index);
    }

    @Override
    public void print() {
        //打印菜单名称
        for (int i = 0;i < level;i++){
            System.out.print("-");
        }
        System.out.println(name + "->");

        //打印子菜单或者子菜单项名称
        for (MenuComponent menuComponent : list) {
            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 = 0;i < level;i++){
            System.out.print("-");
        }
        System.out.println(name);
    }
}

public class Test {

    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));

        //创建1级菜单
        MenuComponent component = new Menu("系统管理",1);

        //将2级菜单添加到1级菜单中
        component.add(menu1);
        component.add(menu2);
        component.add(menu3);

        //打印菜单名称
        component.print();
    }

}

七、享元模式

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

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

结构：
    抽象享元角色：通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界
                提供享元对象的内部数据(内部状态)，同时也可以通过这些方法来设置外部数据(外部状态)
    具体享元角色：它实现了抽象享元类，称为享元对象；在具体享元类中为内部状态提供了存储空间。
                通常可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象
    非享元角色：并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；
               当需要一个非共享具体享元类的对象时可以直接通过实例化创建
    享元工厂角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检查系统中是否存在
                符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象
    
优点：
    极大减少了内存中相似或者相同对象的数量，节约系统资源，提高系统性能
    享元模式中的外部状态相对独立，且不影响内部状态
    
缺点：
    为了使对象可以共享，需要将享元对象的部分状态外部化，分离内部状态和外部状态，使程序逻辑复杂
    
使用场景：
       一个系统有大量相同或者相似的对象，造成内存的大量耗费
       对象的大部分状态都可以外部化，可以将这些外部状态传入对象中

/**
 * 抽象享元角色
 */
public abstract class AbstractBox {

    //获取图形
    public abstract String getShape();

    //显示图形及颜色
    public void disPlay(String color){
        System.out.println("方块形状: " + getShape() + " , 颜色: " + color);
    }

}

/**
 * 具体享元角色
 */
public class IBox extends AbstractBox{

    @Override
    public String getShape() {
        return "I";
    }
}

/**
 * 具体享元角色
 */
public class JBox extends AbstractBox{

    @Override
    public String getShape() {
        return "J";
    }
}

/**
 * 具体享元角色
 */
public class OBox extends AbstractBox{

    @Override
    public String getShape() {
        return "O";
    }
}

/**
 * 享元工厂角色
 * 设计为单例 采用饿汉式
 */
public class BoxFactory {

    private Map<String,AbstractBox> map;

    private static BoxFactory factory = new BoxFactory();

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

    public static BoxFactory getInstance(){
        return factory;
    }

    //根据名称获取图形对象
    public AbstractBox getShape(String name){
        if (!map.containsKey(name)){
            throw new NullPointerException("工厂中没有当前对象,请先创建该对象");
        }
        return map.get(name);
    }

}

public class Test {

    public static void main(String[] args) {
        AbstractBox box = BoxFactory.getInstance().getShape("I");
        box.disPlay("黑色");
    }

}