设计模式学习笔记（16）——享元模式实现

一、网站类

class WebSite{
	private String name="";
	public WebSite(String name) {
		this.name=name;
	}
	public void Use() {
		System.out.println("网站分类："+name);
	}
}
public class Main{
	public static void main(String[] args){
		WebSite fx=new WebSite("产品展示"); fx.Use();
		WebSite fy=new WebSite("产品展示"); fy.Use();
		WebSite fz=new WebSite("产品展示"); fz.Use();
		WebSite fl=new WebSite("博客"); fl.Use();
		WebSite fm=new WebSite("博客"); fm.Use();
		WebSite fn=new WebSite("博客"); fn.Use();
		}
}

运行结果
二、享元模式

import java.util.HashMap;

abstract class Flyweight{
	public String intrinsic;
	protected final String extrinsic;
	public Flyweight(String extrinsic) {
		this.extrinsic=extrinsic;
	}
	public abstract void operate(int extrinsic);
	public String getIntrisic() {
		return intrinsic;
	}
	public void setIntrinsic(String intrinsic) {
		this.intrinsic=intrinsic;
	}
}

class ConcreteFlyweight extends Flyweight{
	public ConcreteFlyweight(String extrinsic) {
		super(extrinsic);
		// TODO Auto-generated constructor stub
	}
public void operate(int extrinsic) {
		System.out.println("具体Flyweight:"+extrinsic);
	}
}

class UnsharedConcreteFlyweight extends Flyweight{
	public UnsharedConcreteFlyweight(String extrinsic) {
		super(extrinsic);
	}
 
	@Override
	public void operate(int extrinsic) {
		// TODO Auto-generated method stub
		System.out.println("不共享的具体Flyweight:"+extrinsic);
	}
}

class FlyweightFactory{
	
	private static HashMap<String,Flyweight>pool=new HashMap<String,Flyweight>();

public static Flyweight getFlyweight(String extrinsic) {
	Flyweight flyweight=null;
	if(pool.containsKey(extrinsic)) {
		flyweight=pool.get(extrinsic);
		System.out.println("已有"+extrinsic+"直接从池中取");
	}else {
		flyweight=new ConcreteFlyweight(extrinsic);
		pool.put(extrinsic, flyweight);
		System.out.println("创建"+extrinsic+"并从池中取出");
	}
	return flyweight;
}
}
public class Main{
	public static void main(String[] args){
		int extrinsic=22;
		FlyweightFactory f=new FlyweightFactory();
		Flyweight flyweightX=f.getFlyweight("X");
		flyweightX.operate(--extrinsic);
		Flyweight flyweightY=f.getFlyweight("Y");
		flyweightY.operate(--extrinsic);
		Flyweight flyweightZ=f.getFlyweight("Z");
		flyweightZ.operate(--extrinsic);
		Flyweight flyweightReX=f.getFlyweight("X");
		flyweightReX.operate(--extrinsic);
		Flyweight unsharedFlyweight=new UnsharedConcreteFlyweight("X");
		unsharedFlyweight.operate(--extrinsic);
		}
}

运行结果：Flyweight类，它是所有具体享元类的超类或接口，通过这个接口，Flyweight可以接受并作用于外部状态。
ConcreteFlyweight继承Flyweight超类或实现Flyweight接口，并为内部状态增加存储空间。
UnsharedConcreteFlyweight是指那些不需要共享的Flyweight子类。因为Flyweight接口使共享成为可能，但他并不强制共享。
FlyweightFactory,是一个享元工厂，用来创建并管理Flyweight对象。它主要是用来确保合理地共享Flyweight,当用户请求一个Flyweight时，FlyweightFactory对象提供一个已创建的实例或者创建一个（如果不存在的话）。
三、网站共享代码

import java.util.HashMap;

abstract class WebSite{
	public abstract void Use();
}
class ConcreteWebSite extends WebSite{
	private String name="";
	public ConcreteWebSite(String name) {
		this.name=name;
	}
	public void Use() {
		System.out.println("网站分类："+name);
	}
}
class WebSiteFactory{
	private static HashMap<String,WebSite>flyweights=new HashMap<String,WebSite>();
	public WebSite GetWebSiteCategory(String key) {
		if(!flyweights.containsKey(key)) {
			WebSite flyweight=new ConcreteWebSite(key);
			flyweights.put(key, flyweight);
		}
		return (flyweights.get(key));
	}
	public int GetWebSiteCount(){
	return flyweights.size();
}
}
public class Main{
	public static void main(String[] args){
		WebSiteFactory f=new WebSiteFactory();
		WebSite fx=f.GetWebSiteCategory("产品展示"); fx.Use();
		WebSite fy=f.GetWebSiteCategory("产品展示"); fy.Use();
		WebSite fz=f.GetWebSiteCategory("产品展示"); fz.Use();
		WebSite fl=f.GetWebSiteCategory("博客"); fl.Use();
		WebSite fm=f.GetWebSiteCategory("博客"); fm.Use();
		WebSite fn=f.GetWebSiteCategory("博客"); fn.Use();
		System.out.println("网站分类总数为"+f.GetWebSiteCount());
		}
}

没有体现实体对象之间不同

import java.util.HashMap;
class User{
	private String name;
	User(String name){
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name=name;
	}
}
abstract class WebSite{
	public abstract void Use(User user);
}
class ConcreteWebSite extends WebSite{
	private String name="";
	public ConcreteWebSite(String name) {
		this.name=name;
	}
	public void Use(User user) {
		System.out.println("网站分类："+name+"用户："+user.getName());
	}
}
class WebSiteFactory{
	private static HashMap<String,WebSite>flyweights=new HashMap<String,WebSite>();
	
	public WebSite GetWebSiteCategory(String key) {
		if(!flyweights.containsKey(key)) {
			WebSite flyweight=new ConcreteWebSite(key);
			flyweights.put(key, flyweight);
		}
		return (flyweights.get(key));
	}
	public int GetWebSiteCount(){
	return flyweights.size();
}
}
public class Main{
	public static void main(String[] args){
		WebSiteFactory f=new WebSiteFactory();
		WebSite fx=f.GetWebSiteCategory("产品展示"); 
		fx.Use(new User("小菜"));
		WebSite fy=f.GetWebSiteCategory("产品展示"); 
		fy.Use(new User("大鸟"));
		WebSite fz=f.GetWebSiteCategory("产品展示"); 
		fz.Use(new User("娇娇"));
		WebSite fl=f.GetWebSiteCategory("博客"); 
		fl.Use(new User("老顽童"));
		WebSite fm=f.GetWebSiteCategory("博客");
		fm.Use(new User("桃谷六仙"));
		WebSite fn=f.GetWebSiteCategory("博客");
		fn.Use(new User("南海神通"));
		System.out.println("网站分类总数为"+f.GetWebSiteCount());
		}
}

四、享元模式的应用
如果一个应用程序使用了大量的对象，而大量的这些对象造成了很大的存储开销时就应该考虑使用；还有就是对象的大多数状态可以外部状态，如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象，此时可以考虑使用享元模式。