享元模式实例五子棋

小鱼儿 2023-10-06 10:51 46阅读 0赞

享元模式，以共享的方式高效地支持大量的细粒度对象。通过复用内存中已存在的对象，降低系统创建对象实例的性能消耗。享元的英文是Flyweight，表示特别小的对象，即细粒度对象。

我们借用五子棋游戏来说明这一模式。

UML  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1NzE5NjEz_size_16_color_FFFFFF_t_70]  
代码：

创建抽象棋子一AbstractChessman

package com.demo.flyweight.object;
    public abstract class AbstractChessman {
        
      // 棋子坐标
      protected int x;
      protected int y;
      // 棋子类别（黑|白）
      protected String chess;
      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 + ")");
      }
    }

3.2 创建黑子一BlackChessman

package com.demo.flyweight.object;
    public class BlackChessman extends AbstractChessman {
        
      /**
       * 构造方法 初始化黑棋子
       */
      public BlackChessman() {
        
        super("●");
        System.out.println("--BlackChessman Construction Exec!!!");
      }
      // 点坐标设置
      @Override
      public void point(int x, int y) {
        
        this.x = x;
        this.y = y;
        // 显示棋子内容
        show();
      }
    }

3.3 创建白子一WhiteChessman

package com.demo.flyweight.object;
    public class WhiteChessman extends AbstractChessman {
        
      /**
       * 构造方法 初始化白棋子
       */
      public WhiteChessman() {
        
        super("○");
        System.out.println("--WhiteChessman Construction Exec!!!");
      }
      // 点坐标设置
      @Override
      public void point(int x, int y) {
        
        this.x = x;
        this.y = y;
        // 显示棋子内容
        show();
      }
    }

3.4 创建棋子工厂一FiveChessmanFactory

package com.demo.flyweight.factory;
    import java.util.Hashtable;
    import com.demo.flyweight.object.AbstractChessman;
    import com.demo.flyweight.object.BlackChessman;
    import com.demo.flyweight.object.WhiteChessman;
    public class FiveChessmanFactory {
        
      // 单例模式工厂
      private static FiveChessmanFactory fiveChessmanFactory = new FiveChessmanFactory();
      // 缓存存放共享对象
      private final Hashtable<Character, AbstractChessman> cache = new Hashtable<Character, AbstractChessman>();
      // 私有化构造方法
      private FiveChessmanFactory() {
        
      }
      // 获得单例工厂
      public static FiveChessmanFactory getInstance() {
        
        return fiveChessmanFactory;
      }
      /**
       * 根据字符获得棋子
       *
       * @param c
       *      （B：黑棋 W：白棋）
       * @return
       */
      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:
            break;
          }
          // 为防止 非法字符的进入 返回null
          if (abstractChessman != null) {
        
            // 放入缓存
            this.cache.put(c, abstractChessman);
          }
        }
        // 如果缓存中存在 棋子对象则直接返回
        return abstractChessman;
      }
    }

3.5 客户端实现一Client

package com.demo;
    import java.util.Random;
    import com.demo.flyweight.factory.FiveChessmanFactory;
    import com.demo.flyweight.object.AbstractChessman;
    /**
     * 主应用程序
     *
     * @author
     */
    public class Client {
        
      /**
       * @param args
       */
      public static void main(String[] args) {
        
        // 创建五子棋工厂
        FiveChessmanFactory fiveChessmanFactory = FiveChessmanFactory
            .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 = fiveChessmanFactory.getChessmanObject('B');
            break;
          // 获得白棋
          case 1:
            abstractChessman = fiveChessmanFactory.getChessmanObject('W');
            break;
          }
          if (abstractChessman != null) {
        
            abstractChessman.point(i, random.nextInt(15));
          }
        }
      }
    }

1.  运行结果

--WhiteChessman Construction Exec!!!
    
    ○(0,2)
    
    ○(1,6)
    
    --BlackChessman Construction Exec!!!
    
    ●(2,3)
    
    ○(3,14)
    
    ○(4,13)
    
    ○(5,8)
    
    ●(6,14)
    
    ●(7,0)
    
    ●(8,3)
    
    ○(9,8)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1NzE5NjEz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200611113806937.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1NzE5NjEz,size_16,color_FFFFFF,t_70