【设计模式】享元模式

享元模式（Flyweight）

本质：分离与共享

问题引入;如果一个程序使用了太多的对象，就会造成大量的储存开销，特别是对于大量的轻量级（细粒度）的对象。
在这种情况，我们将对象分为：外部状态和内部状态，将可以被共享（不变化）的状态作为内部状态存储在对象中。而对于外部对象，可以将其作为参数传递给对象。

通过共享内部状态、加载外部状态来实现享元模式

享元模式以共享的方式高效的支持大量细粒度的对象。

享元模式设计的重点就在分离变与不变。把一个对象的状态分成内部状态和外部状态，内部状态是不变的，外部状态是可变的。然后通过共享不变的部分，达到减少对象数量并节约内存的目的

实例——网站共享

无外部状态的享元

 class Program
    {
        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();

            Console.WriteLine("网站分类总数为 {0}", f.GetWebSiteCount());

            Console.Read();
        }
    }

    //网站工厂
    class WebSiteFactory
    {
        private Hashtable flyweights = new Hashtable();

        //获得网站分类
        public WebSite GetWebSiteCategory(string key)
        {
            if (!flyweights.ContainsKey(key))
                flyweights.Add(key, new ConcreteWebSite(key));
            return ((WebSite)flyweights[key]);
        }

        //获得网站分类总数
        public int GetWebSiteCount()
        {
            return flyweights.Count;
        }
    }

    //网站
    abstract class WebSite
    {
        public abstract void Use();
    }

    //具体的网站
    class ConcreteWebSite : WebSite
    {
        private string name = "";
        public ConcreteWebSite(string name)
        {
            this.name = name;
        }

        public override void Use()
        {
            Console.WriteLine("网站分类：" + name);
        }
    }

带外部状态的享元模式

外部状态是随环境改变而改变的，不可以共享的状态。
其外部状态必须由客户端保存，并在享元对象被创建之后再需要使用的时候传入享元对象的内部，
外部状态与内部状态是相互独立的。

 class Program
    {
        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("南海鳄神"));

            Console.WriteLine("得到网站分类总数为 {0}", f.GetWebSiteCount());

            //string titleA = "大话设计模式";
            //string titleB = "大话设计模式";

            //Console.WriteLine(Object.ReferenceEquals(titleA, titleB));


            Console.Read();
        }
    }

    //用户
    public class User
    {
        private string name;

        public User(string name)
        {
            this.name = name;
        }

        public string Name
        {
            get { return name; }
        }
    }


    //网站工厂
    class WebSiteFactory
    {
        private Hashtable flyweights = new Hashtable();

        //获得网站分类
        public WebSite GetWebSiteCategory(string key)
        {
            if (!flyweights.ContainsKey(key))
                flyweights.Add(key, new ConcreteWebSite(key));
            return ((WebSite)flyweights[key]);
        }

        //获得网站分类总数
        public int GetWebSiteCount()
        {
            return flyweights.Count;
        }
    }

    //网站
    abstract class WebSite
    {
        public abstract void Use(User user);
    }

    //具体的网站
    class ConcreteWebSite : WebSite
    {
        private string name = "";
        public ConcreteWebSite(string name)
        {
            this.name = name;
        }

        public override void Use(User user)
        {
            Console.WriteLine("网站分类：" + name + " 用户：" + user.Name);
        }
    }

何时使用

• 一个系统有大量的对象。
• 这些对象耗费大量的内存。
• 这些对象的状态中的大部分都可以外部化。
• 这些对象可以按照内部状态分成很多的组，当把外部对象从对象中剔除时，每一个组都可以仅用一个对象代替。

使用享元模式需要维护一个记录了系统已有的所有享元的表，而这需要耗费资源。因此，应当在有足够多的享元实例可供共享时才值得使用享元模式。

优缺点

优点

• 大幅度地降低内存中对象的数量，节省内存空间。

缺点:

• 享元模式使得系统更加复杂。为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。
• 享元模式将享元对象的状态外部化，而读取外部状态使得运行时间变长。

利用享元模式模拟五子棋的操作

package Flyweight;

public abstract class AbstractChess {
	protected int x;
	protected int y;

	public abstract void operate(int x, int y);
}

package Flyweight;

public class BlackChess extends AbstractChess {

	public BlackChess() {
	}

	@Override
	public void operate(int x, int y) {
		// TODO Auto-generated method stub
		this.x = x;
		this.y = y;
		System.out.println("黑棋位置坐标：(" + this.x + "," + this.y + ")");
	}

}

package Flyweight;

public class WhiteChess extends AbstractChess {

	public WhiteChess() {
	}

	@Override
	public void operate(int x, int y) {
		// TODO Auto-generated method stub
		this.x = x;
		this.y = y;
		System.out.println("白棋位置坐标：(" + this.x + "," + this.y + ")");
	}

}

package Flyweight;

import java.util.Hashtable;

public class ChessFactory {

	private Hashtable<String, AbstractChess> ht = new Hashtable<String, AbstractChess>();

	public ChessFactory() {
	}

	public AbstractChess getObject(String str) {

		AbstractChess ac = ht.get(str);
		if (ac == null) {

			switch (str) {
			case "B":
				ac = new BlackChess();
				break;
			case "W":
				ac = new WhiteChess();
				break;
			default:
				break;
			}

			ht.put(str, ac);

		}

		return ac;
	}

	public int getNum() {
		return ht.size();
	}

}

package Flyweight;

public class Main {
	public static void main(String[] args) {

		ChessFactory cf = new ChessFactory();
		AbstractChess bc1 = cf.getObject("B");
		bc1.operate(0, 1);
		AbstractChess bc2 = cf.getObject("B");
		bc2.operate(7, 10);
		AbstractChess bc3 = cf.getObject("B");
		bc3.operate(3, 11);
		System.out.println("对象共" + cf.getNum() + "个");
		AbstractChess wc1 = cf.getObject("W");
		wc1.operate(4, 0);
		AbstractChess wc2 = cf.getObject("W");
		wc2.operate(9, 7);
		AbstractChess wc3 = cf.getObject("W");
		wc3.operate(6, 15);
		System.out.println("对象共" + cf.getNum() + "个");
	}
}

UML图