public class Test {
 public static void main(String[] args) {
  String a = "abc";
  String b = "abc";
  System.out.println(a==b);
 }
}

public interface Flyweight {
 //一個示意性方法，參數(shù)state是外蘊(yùn)狀態(tài)
 public void operation(String state);
}

public class ConcreteFlyweight implements Flyweight {
 private Character intrinsicState = null;
 /**
 * 構(gòu)造函數(shù)，內(nèi)蘊(yùn)狀態(tài)作為參數(shù)傳入
 * @param state
 */
 public ConcreteFlyweight(Character state){
  this.intrinsicState = state;
 }
 
 /**
 * 外蘊(yùn)狀態(tài)作為參數(shù)傳入方法中，改變方法的行為，
 * 但是并不改變對象的內(nèi)蘊(yùn)狀態(tài)。
 */
 @Override
 public void operation(String state) {
  // TODO Auto-generated method stub
  System.out.println("Intrinsic State = " + this.intrinsicState);
  System.out.println("Extrinsic State = " + state);
 }
}

public class FlyweightFactory {
 private Map<Character,Flyweight> files = new HashMap<Character,Flyweight>();
 
 public Flyweight factory(Character state){
  //先從緩存中查找對象
  Flyweight fly = files.get(state);
  if(fly == null){
   //如果對象不存在則創(chuàng)建一個新的Flyweight對象
   fly = new ConcreteFlyweight(state);
   //把這個新的Flyweight對象添加到緩存中
   files.put(state, fly);
  }
  return fly;
 }
}

public class Client {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  FlyweightFactory factory = new FlyweightFactory();
  Flyweight fly = factory.factory(new Character('a'));
  fly.operation("First Call");
  
  fly = factory.factory(new Character('b'));
  fly.operation("Second Call");
  
  fly = factory.factory(new Character('a'));
  fly.operation("Third Call");
 }
}

public interface Flyweight {
 //一個示意性方法，參數(shù)state是外蘊(yùn)狀態(tài)
 public void operation(String state);
}

public class ConcreteFlyweight implements Flyweight {
 private Character intrinsicState = null;
 /**
 * 構(gòu)造函數(shù)，內(nèi)蘊(yùn)狀態(tài)作為參數(shù)傳入
 * @param state
 */
 public ConcreteFlyweight(Character state){
  this.intrinsicState = state;
 }
 
 /**
 * 外蘊(yùn)狀態(tài)作為參數(shù)傳入方法中，改變方法的行為，
 * 但是并不改變對象的內(nèi)蘊(yùn)狀態(tài)。
 */
 @Override
 public void operation(String state) {
  // TODO Auto-generated method stub
  System.out.println("Intrinsic State = " + this.intrinsicState);
  System.out.println("Extrinsic State = " + state);
 }

}

public class ConcreteCompositeFlyweight implements Flyweight {
 
 private Map<Character,Flyweight> files = new HashMap<Character,Flyweight>();
 /**
 * 增加一個新的單純享元對象到聚集中
 */
 public void add(Character key , Flyweight fly){
  files.put(key,fly);
 }
 /**
 * 外蘊(yùn)狀態(tài)作為參數(shù)傳入到方法中
 */
 @Override
 public void operation(String state) {
  Flyweight fly = null;
  for(Object o : files.keySet()){
   fly = files.get(o);
   fly.operation(state);
  } 
 }
}

public class FlyweightFactory {
 private Map<Character,Flyweight> files = new HashMap<Character,Flyweight>();
 /**
 * 復(fù)合享元工廠方法
 */
 public Flyweight factory(List<Character> compositeState){
  ConcreteCompositeFlyweight compositeFly = new ConcreteCompositeFlyweight();
  
  for(Character state : compositeState){
   compositeFly.add(state,this.factory(state));
  }
  
  return compositeFly;
 }
 /**
 * 單純享元工廠方法
 */
 public Flyweight factory(Character state){
  //先從緩存中查找對象
  Flyweight fly = files.get(state);
  if(fly == null){
   //如果對象不存在則創(chuàng)建一個新的Flyweight對象
   fly = new ConcreteFlyweight(state);
   //把這個新的Flyweight對象添加到緩存中
   files.put(state, fly);
  }
  return fly;
 }
}

public class Client {

 public static void main(String[] args) {
  List<Character> compositeState = new ArrayList<Character>();
  compositeState.add('a');
  compositeState.add('b');
  compositeState.add('c');
  compositeState.add('a');
  compositeState.add('b');
  
  FlyweightFactory flyFactory = new FlyweightFactory();
  Flyweight compositeFly1 = flyFactory.factory(compositeState);
  Flyweight compositeFly2 = flyFactory.factory(compositeState);
  compositeFly1.operation("Composite Call");
  
  System.out.println("---------------------------------");  
  System.out.println("復(fù)合享元模式是否可以共享對象：" + (compositeFly1 == compositeFly2));
  
  Character state = 'a';
  Flyweight fly1 = flyFactory.factory(state);
  Flyweight fly2 = flyFactory.factory(state);
  System.out.println("單純享元模式是否可以共享對象：" + (fly1 == fly2));
 }
}