实现对象的复用——享元模式（三）

14.3 完整解决方案

为了节约存储空间，提高系统性能，Sunny公司开发人员使用享元模式来设计围棋软件中的棋子，其基本结构如图14-4所示：

实现对象的复用——享元模式（三） - 图1

图14-4 围棋棋子结构图

在图14-4中，IgoChessman充当抽象享元类，BlackIgoChessman和WhiteIgoChessman充当具体享元类，IgoChessmanFactory充当享元工厂类。完整代码如下所示：

  1. import java.util.*;  
  3. //围棋棋子类：抽象享元类  
  4. abstract class IgoChessman {  
  5.     public abstract String getColor();  
  7.     public void display() {  
  8.         System.out.println("棋子颜色：" + this.getColor());    
  9.     }  
  10. }  
  12. //黑色棋子类：具体享元类  
  13. class BlackIgoChessman extends IgoChessman {  
  14.     public String getColor() {  
  15.         return "黑色";  
  16.     }     
  17. }  
  19. //白色棋子类：具体享元类  
  20. class WhiteIgoChessman extends IgoChessman {  
  21.     public String getColor() {  
  22.         return "白色";  
  23.     }  
  24. }  
  26. //围棋棋子工厂类：享元工厂类，使用单例模式进行设计  
  27. class IgoChessmanFactory {  
  28.     private static IgoChessmanFactory instance = new IgoChessmanFactory();  
  29.     private static Hashtable ht; //使用Hashtable来存储享元对象，充当享元池  
  31.     private IgoChessmanFactory() {  
  32.         ht = new Hashtable();  
  33.         IgoChessman black,white;  
  34.         black = new BlackIgoChessman();  
  35.         ht.put("b",black);  
  36.         white = new WhiteIgoChessman();  
  37.         ht.put("w",white);  
  38.     }  
  40.     //返回享元工厂类的唯一实例  
  41.     public static IgoChessmanFactory getInstance() {  
  42.         return instance;  
  43.     }  
  45.     //通过key来获取存储在Hashtable中的享元对象  
  46.     public static IgoChessman getIgoChessman(String color) {  
  47.         return (IgoChessman)ht.get(color);    
  48.     }  
  49. }

编写如下客户端测试代码：

  1. class Client {  
  2.     public static void main(String args[]) {  
  3.         IgoChessman black1,black2,black3,white1,white2;  
  4.         IgoChessmanFactory factory;  
  6.         //获取享元工厂对象  
  7.         factory = IgoChessmanFactory.getInstance();  
  9.         //通过享元工厂获取三颗黑子  
  10.         black1 = factory.getIgoChessman("b");  
  11.         black2 = factory.getIgoChessman("b");  
  12.         black3 = factory.getIgoChessman("b");  
  13.         System.out.println("判断两颗黑子是否相同：" + (black1==black2));  
  15.         //通过享元工厂获取两颗白子  
  16.         white1 = factory.getIgoChessman("w");  
  17.         white2 = factory.getIgoChessman("w");  
  18.         System.out.println("判断两颗白子是否相同：" + (white1==white2));  
  20.         //显示棋子  
  21.         black1.display();  
  22.         black2.display();  
  23.         black3.display();  
  24.         white1.display();  
  25.         white2.display();  
  26.     }  
  27. }

编译并运行程序，输出结果如下：

  1. 判断两颗黑子是否相同：true
  2. 判断两颗白子是否相同：true
  3. 棋子颜色：黑色
  4. 棋子颜色：黑色
  5. 棋子颜色：黑色
  6. 棋子颜色：白色
  7. 棋子颜色：白色

从输出结果可以看出，虽然我们获取了三个黑子对象和两个白子对象，但是它们的内存地址相同，也就是说，它们实际上是同一个对象。在实现享元工厂类时我们使用了单例模式和简单工厂模式，确保了享元工厂对象的唯一性，并提供工厂方法来向客户端返回享元对象。