设计模式之-----享元模式

今天学习享元模式，所谓享元，就是通过与其他类似对象共享数据来减小内存占用。也就是说在一个系统中如果有多个相同的对象，那么只共享一份就可以了，不必每个都去实例化一个对象。像我们平时用的word等软件，如果每个字符都要单独占一块内存，那估计我们打开一本小说，内存就撑爆了，电脑中把一个字放到内存中，如果要使用这个字，那就直接引用这个字的内存地址就可以了，而不必每次都要实例化一遍这个字，那样太浪费资源了。

学习这个模式之前要搞清楚两个概念：内部状态和外部状态。

内部状态：即不变的部分，每个对象都能共享的状态就是内部状态。

外部状态：外部状态由客户端去决定，对象之间不可以共享的部分叫做外部状态。

我们来看看代码实现，看看这个模式由几部分组成，这个例子用了日常生活中买果汁的例子，我们和店家说要什么口味的果汁，店家最终给我们什么口味的。

先看包结构

首先来定义要被共享的对象的抽象接口

package com.flyweight.flyweight.intf;

/**
 * 贩卖果汁的接口，定义了一个卖果汁的方法
 * @author ZHENGWEI
 * @date 2015-8-13
 */
public interface SellJuice {

	/**
	 * 卖出果汁的方法
	 */
	public void sale();
}

然后是实现类，也就是真正要被共享的类

package com.flyweight.flyweight.impl;

import com.flyweight.flyweight.intf.SellJuice;

/**
 * 具体卖出果汁的实现类，这个类作为一个具体的享元角色
 * @author ZHENGWEI
 * @date 2015-8-13
 */
public class SellJuiceImpl implements SellJuice{

	private String flavor;// 果汁的具体口味
	
	public SellJuiceImpl(String flavor) {
		super();
		this.flavor = flavor;
	}

	/**
	 * 卖出果汁的具体方法
	 */
	public void sale() {
		System.out.println("卖出了一杯果汁，口味是："+this.flavor);
	}

}

然后是一个工厂方法，这个工厂方法我感觉和单例模式有些相似，在实际项目中可以将二者做一个结合

package com.flyweight.flyweight.factory;

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

import com.flyweight.flyweight.impl.SellJuiceImpl;
import com.flyweight.flyweight.intf.SellJuice;

/**
 * 
 * @author ZHENGWEI
 * @date 2015-8-13
 */
public class FlyWeightFactory {
	
	private Map<String, SellJuice> SellJuiceFactoryMap = new HashMap<String, SellJuice>();
	
	/**
	 * 工厂方法，返回享元实例
	 * @param key
	 * @return
	 */
	public SellJuice factory(String key){
		if(!SellJuiceFactoryMap.containsKey(key)){
			SellJuiceFactoryMap.put(key, new SellJuiceImpl(key));
		}
		return SellJuiceFactoryMap.get(key);
	}
	
	/**
	 * 获取当前对象池的大小
	 */
	public void getObjectSize(){
		System.out.println("当前一共存在："+SellJuiceFactoryMap.size()+"个对象");
	}
}

最后是测试类

package com.flyweight.main;

import java.util.ArrayList;
import java.util.List;

import com.flyweight.flyweight.factory.FlyWeightFactory;
import com.flyweight.flyweight.intf.SellJuice;

public class FlyWeightMain {

	public static void main(String[] args) {
		List<String> flavorList = new ArrayList<String>();
		
		// 添加口味
		flavorList.add("苹果味");
		flavorList.add("苹果味");
		flavorList.add("橘子味");
		flavorList.add("苹果味");
		flavorList.add("桃子味");
		
		// 实例化工厂
		FlyWeightFactory flyWeightFactory = new FlyWeightFactory();
		SellJuice sellJuice;
		for(String flavor : flavorList){
			sellJuice = flyWeightFactory.factory(flavor);
			sellJuice.sale();
		}
		
		System.out.println("订单数量一共是："+flavorList.size()+"杯");
		flyWeightFactory.getObjectSize();
	}

}

然后来看看结果

显而易见，订单数量和存在的对象并不相等，也就是说，相同口味的果汁，内部对象是一样的，这样就达到了节约资源的目的。

我们来看看享元模式的缺点：
（1）享元模式使得系统更加复杂。为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。
（2）享元模式将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长。

优点就是节约内存，当有大量对象开销的时候，这种优势是显而易见的，同时，享元模式对后期的维护也有一定程度上的帮助