结构型设计模式
简要定义
以共享的方式高效的支持大量的细粒度对象,通过复用内存中存在的对象, 降低系统创建对象实例的性能消耗.
享元模式分析
类图
20160329095258720.png
享元模式用来 减少大量实例化相似对象时的性能消耗. 在这些对象中有些信息是共享的, 有些是不能共享的, 这就涉及到享元模式的两种状态: 内蕴状态和外蕴状态, 这两种状态是相互独立的状态, 彼此没有关联
- 内蕴状态 : 享元对象的内蕴状态是不会随环境的改变而改变的，是存储在享元对象内部的状态信息，因此内蕴状态是可以共享的，对于任何一个享元对象来讲，它的值是完全相同的。
- 外蕴状态: 享元对象的第二类状态就是外蕴状态，它会随着环境的改变而改变，因此是不可以共享的状态，对于不同的享元对象来说，它的值可能是不同的。享元对象的外蕴状态必须由客户端保存，在享元对象被创建之后，需要使用的时候再传入到享元对象内部.
具体实现
以五子棋为例, 棋子的坐标为外蕴状态
//棋子超类
public abstract class AbstractChessman {
//棋子类别
protected String chess;
//棋子坐标
protected int x;
protected int y;
//构造方法
public AbstractChessman(String chess){
this.chess = chess;
}
//坐标设置
public abstract void point(int x,int y);
//显示棋子信息
public void show(){
System.out.println(this.chess+"("+this.x+","+this.y+")");
}
}
//黑棋子类 白子同理
public class BlackChessman extends AbstractChessman {
public BlackChessman(){
super("●");
System.out.println("--一颗黑棋子诞生了！--");
}
@Override
public void point(int x, int y) {
this.x = x;
this.y = y;
this.show();
}
}
//棋子工厂类, 以单例模式实现
//该类用来生产棋子对象实例, 并放入缓存中, 下次在获得棋子对象时就从缓存当中获得
public class ChessmanFactory {
//单例模式
private static ChessmanFactory chessmanFactory = new ChessmanFactory();
//缓存共享对象
private final Hashtable<Character, AbstractChessman> cache = new Hashtable<Character, AbstractChessman>();
//构造方法私有化
private ChessmanFactory(){
}
//获得单例工厂对象
public static ChessmanFactory getInstance(){
return chessmanFactory;
}
/*
* 根据字母获得棋子
*/
public AbstractChessman getChessmanObject(char c){
//从缓存中获得棋子对象实例
AbstractChessman abstractChessman = this.cache.get(c);
//判空
if (abstractChessman==null) {
//说明缓存中没有该棋子对象实例，需要创建
switch (c) {
case 'B':
abstractChessman = new BlackChessman();
break;
case 'W':
abstractChessman = new WhiteChessman();
break;
default:
System.out.println("非法字符，请重新输入！");
break;
}
//如果有非法字符，那么对象必定仍为空，所以再进行判断
if (abstractChessman!=null) {
//放入缓存
this.cache.put(c, abstractChessman);
}
}
//如果缓存中存在棋子对象则直接返回
return abstractChessman;
}
}
//客户端 测试类
public class Test {
public static void main(String[] args) {
//创建工厂
ChessmanFactory chessmanFactory = ChessmanFactory.getInstance();
//随机数，用于生成棋子对象
Random random = new Random();
int radom = 0;
AbstractChessman abstractChessman = null;
//随机获得棋子
for (int i = 0; i < 10; i++) {
radom = random.nextInt(2);
switch (radom) {
case 0:
//获得黑棋子
abstractChessman = chessmanFactory.getChessmanObject('B');
break;
case 1:
//获得黑棋子
abstractChessman = chessmanFactory.getChessmanObject('W');
break;
}
if (abstractChessman!=null) {
abstractChessman.point(i, random.nextInt(15));
}
}
}
}
享元模式的优缺点
享元模式的优点显而易见, 它能大量降低系统中对象的数量, 但这样做所付出的代价是很高的:
- 享元模式使得系统更加复杂。为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。
- 享元模式将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长。
