大话设计模式之享元模式

 享元模式：

运用共享技术有效得支持大量细粒度得对象

/**
 * 所有 具体享元类得超类或者接口，通过这个接口，FlyWieght可以接受并作用于外部状态。
 * */
abstract class FlyWieght {
public abstract void operation(int value);
}

/**
 * 继承或者实现  FlyWieght，并且为内部状态增加存储空间
 * */
public class ConFlyWeight extends FlyWieght{

	@Override
	public void operation(int value) {
		// TODO Auto-generated method stub
		System.out.println("具体得FlyWieght："+value);
	}

}

/** 
 * UnConFlyWeight 指那些不需要共享得   FlyWieght  类，因为FlyWieght接口共享成为可能，但它并不强制共享
 * */
public class UnConFlyWeight extends FlyWieght{

	@Override
	public void operation(int value) {
		// TODO Auto-generated method stub
		System.out.println("不需要共享得 FlyWieght："+value);
	}

}

/**
 * FlyWeightFactory 是一个享元 工厂，用来创建并管理  FlyWieght对象，它主要是用来 确保合理地共享
 * FlyWieght ，当用户 请求一个 FlyWieght 时，FlyWeightFactory 对象提供一个 已创建得实例或者
 * 创建一个（如果不存在得话）
 * */

import java.util.HashMap;

public class FlyWeightFactory {
       HashMap<String, ConFlyWeight> map=new HashMap<>();
//       初始化工厂时,先生成3个实例
       public FlyWeightFactory() {
    	  map.put("X", new ConFlyWeight()) ;
    	  map.put("Y", new ConFlyWeight()) ;
    	  map.put("Z", new ConFlyWeight()) ;
       }
   public FlyWieght getFlyweight(String key) {
	return map.get(key);
	   
   }    
}

/**
 * 客户端
 * */
public class Test1 {
public static void main(String[] args) {
//	代码外部状态
	int value=22;
	 FlyWeightFactory flyWeightFactory = new FlyWeightFactory();
	 FlyWieght flyweight = flyWeightFactory.getFlyweight("X");
	 flyweight.operation(--value);
	 FlyWieght flyweight1 = flyWeightFactory.getFlyweight("Y");
	 flyweight1.operation(--value);
	 FlyWieght flyweight2 = flyWeightFactory.getFlyweight("Z");
	 flyweight2.operation(--value);
	 UnConFlyWeight unConFlyWeight = new UnConFlyWeight();
	 unConFlyWeight.operation(--value);
}
}

 用需求来理解:
做网站，100个类似得网站

/**
 * 用户
 */
public class User {

	private String name;

	public String getName() {
		return name;
	}

	public User(String name) {

		this.name = name;
	}
}

/**
 * 网站抽象类
 * */
abstract class WebSite {
// 方法 需要传递 用户 （User）/对象
	public  abstract void use(User user);

}

public class ConWebSite extends WebSite{
private String name="";
 public ConWebSite(String name) {
	 this.name=name;
}
	@Override
	public void use(User user) {
		// TODO Auto-generated method stub
		System.out.println("网站分类："+name+ "用户："+user.getName());
	}

}

/**
 * 网站工厂
 * */
public class WebSiteFactory {
    HashMap<String, ConWebSite> map=new HashMap<>();
// 获得网站分类
    
    public WebSite getWebSite(String key) {
    	if (!map.containsKey(key)) {
			map.put(key, new ConWebSite(key));
		}
    	return map.get(key);	
    }
//    获得 网站分类总数
    public int getWebSiteCount() {
    	return map.size();
    }
}

/**
 * 客户端代码
 * */
public class Test2 {
	public static void main(String[] args) {
		 WebSiteFactory webSiteFactory = new WebSiteFactory();
		 
		 WebSite webSite = webSiteFactory.getWebSite("产品展示");
		 webSite.use(new User("锦锦"));
		 
		 WebSite webSite1 = webSiteFactory.getWebSite("产品展示");
		 webSite1.use(new User("巧"));
		 
		 WebSite webSite2 = webSiteFactory.getWebSite("产品展示");
		 webSite2.use(new User("乔"));
		 
		 WebSite webSiteA = webSiteFactory.getWebSite("博客");
		 webSiteA.use(new User("乔"));
		 
		 WebSite webSiteB= webSiteFactory.getWebSite("博客");
		 webSiteB.use(new User("巧"));
		 
		 WebSite webSiteC= webSiteFactory.getWebSite("博客");
		 webSiteC.use(new User("锦锦"));
	}
}

享元模式应用：
如果 一个应用程序使用了大量得对象，而大量得这些对象 造成了很大得存储开销时 就应该考虑使用，还有就是
对象得大多数状态可以外部状态，如果删除对象得外部状态，那么可以用相对较少得 共享对象取代 很多组 对象，
此时可以考虑使用享元模式。
因为 用了享元模式，所以有了共享对象，实例总数大大减少了，、。
  围棋 只有 黑白 2个颜色，所以
 理解举例：围棋围棋 只有 黑白 2个颜色，所以颜色是 棋子的内部状态，而各个棋子之间得差别 主要就是 位置的不同
，所以方位坐标应该是棋子得外部 状态。
，一盘棋理论上 有361 个空位可以放棋子，那如果用常规得面向对象编程，每盘其 都可能
200或300个棋子对象产生，一玩 台服务器 就很难支持更多得玩家 玩 围棋游戏了，毕竟内存空间还是有限得。
如果用 享元模式处理棋子，那么棋子对象 可以减少到只有2个实例。