设计模式系列-桥接模式，享元模式

桥接模式

定义：将抽象和实现解耦，使得两者可以独立地变化。

角色：
Implementor——实现化角色：它是接口或者抽象类，定义角色必需的行为和属性。

ConcreteImplementor——具体实现化角色：它实现接口或抽象类定义的方法和属性。

Abstraction——抽象化角色：它的主要职责是定义出该角色的行为，同时保存一个对实现化角色的引用，该角色一般是抽象类。

RefinedAbstraction——修正角色：它引用实现化角色对抽象化角色进行修正。

    public interface Implementor {
         //基本方法
         public void doSomething();
         public void doAnything();
    }

    public class ConcreteImplementor1 implements Implementor{
         public void doSomething(){
                 //业务逻辑处理
         }
         public void doAnything(){
                 //业务逻辑处理
         }
    }

    public class ConcreteImplementor2 implements Implementor{
         public void doSomething(){
                 //业务逻辑处理
         }
         public void doAnything(){
                 //业务逻辑处理
         }
    }

    public abstract class Abstraction {
         //定义对实现化角色的引用
         private Implementor imp;
         //约束子类必须实现该构造函数
         public Abstraction(Implementor _imp){
                 this.imp = _imp;
         }
         //自身的行为和属性
         public void request(){
                 this.imp.doSomething();
         }
         //获得实现化角色
         public Implementor getImp(){
                 return imp;
         }
    }

    public class RefinedAbstraction1 extends Abstraction {
         //覆写构造函数
         public RefinedAbstraction1(Implementor _imp){
                 super(_imp);
         }

         @Override
         public void request(){
                 super.request();
         }
    }

    public class RefinedAbstraction2 extends Abstraction {
         //覆写构造函数
         public RefinedAbstraction2(Implementor _imp){
                 super(_imp);
         }
         //修正父类的行为
         @Override
         public void request(){
                 super.request();
                 super.getImp().doAnything();
         }
    }

    public class Client {
         public static void main(String[] args) {
                 //定义一个实现化角色
                 Implementor imp = new ConcreteImplementor1();
                 //定义一个抽象化角色
                 Abstraction abs = new RefinedAbstraction1(imp);
                 //执行行文
                 abs.request();
         }
    }

优点：

抽象和实现分离，优秀的扩充能力，客户不用关心细节的实现，它已经由抽象层通过聚合关系完成了封装。

享元模式

定义：使用共享对象可有效地支持大量的细粒度的对象。

Flyweight——抽象享元角色: 它简单地说就是一个产品的抽象类，同时定义出对象的外部状态和内部状态的接口或实现。

ConcreteFlyweight——具体享元角色: 具体的一个产品类，实现抽象角色定义的业务。

FlyweightFactory——享元工厂: 职责非常简单，就是构造一个池容器，同时提供从池中获得对象的方法。

    //抽象享元角色
    public abstract class Flyweight {
         //内部状态
         private String intrinsic;
         //外部状态
         protected final String Extrinsic;
         //要求享元角色必须接受外部状态
         public Flyweight(String _Extrinsic){
                 this.Extrinsic = _Extrinsic;
         }
         //定义业务操作
         public abstract void operate();
         //内部状态的getter/setter
         public String getIntrinsic() {
                 return intrinsic;
         }
         public void setIntrinsic(String intrinsic) {
                 this.intrinsic = intrinsic;
         }
    }

    //具体享元角色
    public class ConcreteFlyweight1 extends Flyweight{
         //接受外部状态
         public ConcreteFlyweight1(String _Extrinsic){
                 super(_Extrinsic);
         }
         //根据外部状态进行逻辑处理
         public void operate(){
                 //业务逻辑
         }
    }

    //享元工厂
    public class FlyweightFactory {
         //定义一个池容器
         private static  HashMap pool= new HashMap();
         //享元工厂
         public static Flyweight getFlyweight(String Extrinsic){
                 //需要返回的对象
                 Flyweight flyweight = null;
                 //在池中没有该对象
                 if(pool.containsKey(Extrinsic)){
                         flyweight = pool.get(Extrinsic);
                 }else{
                         //根据外部状态创建享元对象
                         flyweight = new ConcreteFlyweight1(Extrinsic);
                         //放置到池中
                         pool.put(Extrinsic, flyweight);
                 }
                 return flyweight;
         }
    }

使用场景：

系统中存在大量的相似对象。

需要缓冲池的场景。