享元模式(Flyweight、FlyweightFactory)(围棋棋子共享)

　　（使用共享对象可有效地支持大量的细粒度的对象。）

　　假设开发一个围棋程序，围棋程序的围棋的棋子包含了颜色、大小、位置等信息。在定义一个棋盘容器来存放这些棋子。 我们可以发现，棋盘的成员变量包含了一个棋子所有的属性，我们需要为每一个颜色大小开辟内存来储存这些信息，而一盘棋需要上百个棋子，这种实现方法占得空间太大了。

我们可以发现棋子的颜色形状等信息都是相同的，我们称这些是可以共享的属于内在的属性，还有位置信息无法共享称为外在属性

因此，可以这样设计，只需定义两颗棋子对象，一颗黑棋与一颗白棋，者两个对象包含棋子得到内在属性。再将外在属性（位置）提取出来放在单独的容器中。

这就是享元模式。

享元模式中通常会出现工厂模式，需要创建一个享元工厂来负责维护一个享元池，用来存储具有相同内部状态的享元对象。

单纯享元结构： 所有的享元对象都是可以共享的。

复合享元模式：将一些单纯享元使用合成模式加以复合，形成复合享元对象。这样的复合享元对象本身不能共享，但是他们可以分解成单纯享元对象，而后者则可以共享。

抽象享元类：

 public abstract class Flyweight {
   private  String shape = null;
   private String color = null;
   private  int size = 0;

   public Flyweight(String shape, String color, int size) {
     super();
     this.shape = shape;
     this.color = color;
     this.size = size;
 }

 public String getShape() {
     return shape;
 }

 public String getColor() {
     return color;
 }

 public void setColor(String color) {
     this.color = color;
 }

 public void setShape(String shape) {
     this.shape = shape;
 }

 public int getSize() {
     return size;
 }

 public void setSize(int size) {
     this.size = size;
 }

 public abstract void show(String externstate);
 }

具体享元类：

 public class ConcreteFlyweight extends Flyweight{

     public ConcreteFlyweight(String shape, String color, int size) {
         super(shape, color, size);

     }

     @Override
     public void show(String externstate) {
         System.out.println("color:"+getColor());
 //        System.out.println(" shape:"+getShape()+" size:"+getSize());
         System.out.println(" 外部状态： "+externstate);
     }

 }

享元工厂类：

 import java.util.HashMap;
 import java.util.Map;

 public class FlyweightFactory {
 private static FlyweightFactory flyweightFactory = new FlyweightFactory();
 private static final  String white = "white";
 private static final String black = "black";
 private static Map<String,Flyweight> map = new HashMap<String, Flyweight>();
 private FlyweightFactory() {
     System.out.println("构造方法被调用！");
 }
 static public FlyweightFactory getInstance() {
     return flyweightFactory;
 }
 static public Flyweight getFlyweight(String key) {
     if (map.get(key)!=null) {
          return map.get(key);
     }
     else if (key.equals(white)) {
         //不可将初始化棋子放入构造器  会造成指针混乱
         map.put(white,new ConcreteFlyweight("圆", "white", 5));
         return map.get(key);
     }else if (key.equals(black)) {
         map.put(black,new ConcreteFlyweight("圆", "black", 5));
         return map.get(key);
     }{
         System.out.println("无此享元对象");
         return     null;
     }

 }
 }

用户测试类：

 public class FlyweightPattern {

     public static void main(String[] args) {

      FlyweightFactory flyweightFactory =   FlyweightFactory.getInstance();
      //可以将此对象的引用传入容器再在容器内添加位置信息，容器内只是引用有多份，而占内存的棋子只有一个黒子一个白子
      Flyweight f1 = flyweightFactory.getFlyweight("white");
      f1.show("x = 1,y = 2");//
      Flyweight f2 = flyweightFactory.getFlyweight("black");
      f2.show("x = 2,y = 3");
     }

 }