设计模式12——结构型模式之享元模式

定义：享元模式(Flyweight Pattern)，运用共享技术有效地支持大量细粒度的对象。

类型：结构型模式。

适用情况：

1. 一个应用程序有大量的对象。
2. 对象的大多数状态都是外部的。
3. 如果删除对象的外部状态，可以和相对较少的共享对象取代很多组对象。
4. 应用程序不依赖对象的标识，即应用程序依赖于对象的抽象接口。

概述：

        Flyweight，原意为“轻量级选手”的意思。翻译者将它意为享元模式，是意译，力求能够直观地表现出此模式的目的。享，共享之意。元，基本单元的意思。享元，也就是共享基本单元，也即GoF所言的运用共享技术有效地支持大量细粒度的对象。

        享元模式的重点在于将对象的“内部状态”和“外部状态”抽象出来，内部状态存储在享元对象中，而外部状态在外部存储。这个才是享元模式的关键，网上很多文章根本没有讲透这一点。

         下面举一个示例。有一棋盘上的围棋正好是大量细粒度的对象。我们将材质、形状、制作工艺抽象为内部状态， 而围棋在棋盘上的位置是标识每一棋子的标记，故棋子的位置抽象为外部状态。而棋子只有白黑两种颜色，如果存储在外部状态里，会存两种颜色很多次。故这里，白棋、黑棋作为两个对象存在。

类图：

参与者：

1. Client，调用ChessBoard得到具体的棋子对象。
2. Chessboard，管理棋子的生成以及存储棋子的外部状态，即每个棋子的具体位置。

3. Weiqi，围棋抽象类，即享元对象，抽象出一些内部状态来。

4. WhiteWeiqi、BlackWeiqi，两个派生出的不同颜色的围棋，实现颜色接口。

示例代码：

// Flyweight类

public abstract class Weiqi
{
    // 内部状态
    // ...............
    // private int nSize;

    public abstract Color GetColor();

}

// 具体的Flyweight类

public class WhiteWeiqi : Weiqi    {
        public override Color GetColor()
        {
            Console.WriteLine("White");
            return Color.White;
        }
    }

    public class BlackWeiqi : Weiqi
    {
        public override Color GetColor()
        {
            Console.WriteLine("Black");
            return Color.Black;
        }
    }

// FlyweightFactory类

public class Blessboard    {
       private List<Point> listWhite = new List<Point>();
       private List<Point> listBlack = new List<Point>();
       private WhiteWeiqi wWeiqi;
       private BlackWeiqi bWeiqi;

       public Blessboard()
       {
           wWeiqi = new WhiteWeiqi();
           bWeiqi = new BlackWeiqi();
       }

       public Weiqi Produce(bool bWthite, Point pt)
       {
           if (bWthite)
           {
               listWhite.Add(pt);

               return bWeiqi;
           }
           else
           {
               listBlack.Add(pt);

               return bWeiqi;
           }
       }

       public Weiqi GetProduce(Point pt)
       {
           foreach (Point p in listWhite)
           {
               if (p.Equals(pt))
               {
                   return wWeiqi;
               }
           }

           foreach (Point p in listBlack)
           {
               if (p.Equals(pt))
               {
                   return bWeiqi;
               }
           }

           return null;
       }
   }

// Client类

class Program    {
        static void Main(string[] args)
        {
            Blessboard bloard = new Blessboard();

            // 生成棋子
            bloard.Produce(true, new Point(1, 3));
            bloard.Produce(false, new Point(2, 3));
            bloard.Produce(true, new Point(1, 4));
            bloard.Produce(false, new Point(2, 4));

            // 查询棋子黑白
            Weiqi weiqi = bloard.GetProduce(new Point(2, 4));
            Color color = weiqi.GetColor();

            weiqi = bloard.GetProduce(new Point(1, 4));
            color = weiqi.GetColor();
        }
    }

 

注意：如果是C++，抽象类一定要注意析构函数一定要是虚函数。

优缺点：

1. 优点，减少内存的使用。

2. 缺点，加大了结构的复杂度，需要单独管理外部状态。

参考资料：

1. 《设计模式——可复用面向对象软件基础》

2. 《大话设计模式》

3. 《Head First设计模式》