JAVA设计模式(12) —<结构型>享元模式(Flyweight)

1 定义：

享元模式(Flyweight)

Use sharing to support large numbers of fine-grained objects efficiently.(使用共享对象可以有效地支持大量的细粒度的对象。)

享元模式要求能够共享的对象必须是细粒度对象。

享元对象能做到共享的关键是区分了内部状态(Intrinsic State)和外部状态(Extrinsic State)。下面将对享元的内部状态和外部状态进行简单的介绍：  

     (1)  内部状态是存储在享元对象内部并且不会随环境改变而改变的状态，内部状态可以共享。如字符的内容，不会随外部环境的变化而变化，无论在任何环境下字符“a”始终是“a”，都不会变成“b”。      

    (2) 外部状态是随环境改变而改变的、不可以共享的状态。享元对象的外部状态通常由客户端保存，并在享元对象被创建之后，需要使用的时候再传入到享元对象内部。一个外部状态与另一个外部状态之间是相互独立的。如字符的颜色，可以在不同的地方有不同的颜色，例如有的“a”是红色的，有的“a”是绿色的，字符的大小也是如此，有的“a”是五号字，有的“a”是四号字。而且字符的颜色和大小是两个独立的外部状态，它们可以独立变化，相互之间没有影响，客户端可以在使用时将外部状态注入享元对象中。

       正因为区分了内部状态和外部状态，我们可以将具有相同内部状态的对象存储在享元池中，享元池中的对象是可以实现共享的，需要的时候就将对象从享元池中取出，实现对象的复用。通过向取出的对象注入不同的外部状态，可以得到一系列相似的对象，而这些对象在内存中实际上只存储一份。       享元模式定义如下： 享元模式(Flyweight Pattern)：运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象，而这些对象都很相似，状态变化很小，可以实现对象的多次复用。由于享元模式要求能够共享的对象必须是细粒度对象，因此它又称为轻量级模式，它是一种对象结构型模式。

1.1 通用类图：

  在享元模式结构图中包含如下几个角色：

      ●抽象享元类( Flyweight)：通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法<同时定义出对象的外部状态和内部状态的接口或实现>，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）。

      ● 具体享元类(ConcreteFlyweight)：它实现了抽象享元类，其实例称为享元对象；在具体享元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象<该角色中需要注意的是内部状态处理应该与环境无关，不应该出现一个操作改变了内部状态，同时修改了外部状态，这是不允许的>。

      ● 非共享具体享元类(UnsharedConcreteFlyweight)：并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象时可以直接通过实例化创建<该对象一般不会出现在享元工厂中>。

      ● 享元工厂类(FlyweightFactory)：享元工厂类用于创建并管理享元对象，它针对抽象享元类编程，将各种类型的具体享元对象存储在一个享元池中，享元池一般设计为一个存储“键值对”的集合（也可以是其他类型的集合），可以结合工厂模式进行设计；当用户请求一个具体享元对象时，享元工厂提供一个存储在享元池中已创建的实例或者创建一个新的实例（如果不存在的话），返回新创建的实例并将其存储在享元池中。

      在享元模式中引入了享元工厂类，享元工厂类的作用在于提供一个用于存储享元对象的享元池，当用户需要对象时，首先从享元池中获取，如果享元池中不存在，则创建一个新的享元对象返回给用户，并在享元池中保存该新增对象。

1.2 通用代码：

错误举例：

[java]  view plain copy

1. package _22_Flyweight;  
2. public abstract class Flyweight {  
3.     private String intrinsic;  
4.     protected String extrinsic;  
5.   
6.     public Flyweight(String intrinsic) {  
7.         this.intrinsic = intrinsic;  
8.     }  
9.   
10.     public String getIntrinsic() {  
11.         return intrinsic;  
12.     }  
13.   
14.     public abstract void operate();  
15.   
16.     public String getExtrinsic() {  
17.         return extrinsic;  
18.     }  
19.   
20.     public void setExtrinisic(String extrinsic) {  
21.         this.extrinsic = extrinsic;  
22.     }  
23. }  
24.   
25. public class ConcreteFlyweight1 extends Flyweight {  
26.     public ConcreteFlyweight1(String intrinsic) {  
27.         super(intrinsic);  
28.     }  
29.   
30.     public void operate() {  
31.     }  
32. }  
33.   
34. public class ConcreteFlyweight2 extends Flyweight {  
35.     public ConcreteFlyweight2(String intrinsic) {  
36.         super(intrinsic);  
37.     }  
38.   
39.     public void operate() {  
40.     }  
41. }  
42.   
43. public class FlyweightFactory {  
44.     private static HashMap<String, Flyweight> pool = new HashMap<String, Flyweight>();  
45.   
46.     public static Flyweight getFlyweight1(String Intrinsic) {  
47.         // 需要返回的对象  
48.         Flyweight flyweight = pool.get(Intrinsic);  
49.         if (flyweight == null) {  
50.             flyweight = new ConcreteFlyweight1(Intrinsic);  
51.             pool.put(Intrinsic, flyweight);  
52.         }  
53.         return flyweight;  
54.     }  
55.   
56.     public static int getSize() {  
57.         return pool.size();  
58.     }  
59. }  
60.   
61. public class Client {  
62.     public static void main(String args[]) {  
63.         Flyweight fly1 = FlyweightFactory.getFlyweight1("1234567890");  
64.         fly1.setExtrinisic("Pos: line=10, col=20, color = RED");  
65.         System.out.println(fly1.getExtrinsic() + " " + fly1.getIntrinsic());  
66.         Flyweight fly2 = FlyweightFactory.getFlyweight1("1234567890");  
67.         fly2.setExtrinisic("Pos: line=20, col=20, color = BLUE");  
68.         System.out.println(fly2.getExtrinsic() + " " + fly2.getIntrinsic());  
69.         System.out.println("池中数量为：" + FlyweightFactory.getSize());  
70.     }  
71. }  

结果：

Pos: line=10, col=20, color = RED 1234567890

Pos: line=20, col=20, color = BLUE 1234567890

池中数量为：1

注意上述是一个误用（错例）。

享元模式只是想将对象细粒度化，将可共享部分缓存起来，以复用。而上例中将对象的共享部分与非共享部分融合在一起是错误的，因为这样则会导致整体的复用，在一个对象未被消费时，其会被另一次复用覆盖。而这并非复用的本质。

下例正确：

[java]  view plain copy

1. package _22_Flyweight.right;  
2. public abstract class Flyweight {  
3.     private String intrinsic;  
4.   
5.     public Flyweight(String intrinsic) {  
6.         this.intrinsic = intrinsic;  
7.     }  
8.   
9.     public String getIntrinsic() {  
10.         return intrinsic;  
11.     }  
12.   
13.     public abstract void operate();  
14. }  
15.   
16. public class ConcreteFlyweightContent extends Flyweight {  
17.     public ConcreteFlyweightContent(String intrinsic) {  
18.         super(intrinsic);  
19.     }  
20.   
21.     public void operate() {  
22.     }  
23. }  
24.   
25. public class FlyweightFactory {  
26.     private static HashMap<String, Flyweight> pool = new HashMap<String, Flyweight>();  
27.   
28.     public static Flyweight getFlyweight1(String Intrinsic) {  
29.         // 需要返回的对象  
30.         Flyweight flyweight = pool.get(Intrinsic);  
31.         if (flyweight == null) {  
32.             flyweight = new ConcreteFlyweightContent(Intrinsic);  
33.             pool.put(Intrinsic, flyweight);  
34.         }  
35.         return flyweight;  
36.     }  
37.   
38.     public static int getSize() {  
39.         return pool.size();  
40.     }  
41. }  
42.   
43. public class WPS {  
44.     Flyweight fly;  
45.     List<String> formats = new ArrayList<String>();  
46.     List<Flyweight> contents = new ArrayList<Flyweight>();  
47.   
48.     public void addLine(String format, Flyweight content) {  
49.         formats.add(format);  
50.         contents.add(content);  
51.     }  
52.   
53.     public void show() {  
54.         for (int i = 0; i < formats.size(); i++) {  
55.             System.out.print(formats.get(i) + "\t\t");  
56.             System.out.println(contents.get(i).getIntrinsic());  
57.         }  
58.     }  
59. }  
60.   
61. public class Client {  
62.     public static void main(String args[]) {  
63.         WPS mydoc = new WPS();  
64.         mydoc.addLine("Pos: line=1, col=20, color = RED",  
65.                 FlyweightFactory.getFlyweight1("1234567890"));  
66.         mydoc.addLine("Pos: line=2, col=20, color = GREEN",  
67.                 FlyweightFactory.getFlyweight1("1234567890"));  
68.         mydoc.addLine("Pos: line=3, col=20, color = BLUE",  
69.                 FlyweightFactory.getFlyweight1("1234567890"));  
70.         mydoc.show();  
71.         System.out.println("池中数量为：" + FlyweightFactory.getSize());  
72.     }  
73. }  

2 优点

      享元模式的主要优点如下：

       (1) 可以极大减少内存中对象的数量，使得相同或相似对象在内存中只保存一份，从而可以节约系统资源，提高系统性能。

       (2) 享元模式的外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同的环境中被共享。

3 缺点

       享元模式的主要缺点如下：

       (1) 享元模式使得系统变得复杂，需要分离出内部状态和外部状态，这使得程序的逻辑复杂化。

       (2) 为了使对象可以共享，享元模式需要将享元对象的部分状态外部化，而读取外部状态将使得运行时间变长。

4 应用场景

    在以下情况下可以考虑使用享元模式：

       (1) 一个系统有大量相同或者相似的对象，造成内存的大量耗费。

       (2) 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中。

       (3) 在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式。

5 注意事项

暂无

6 扩展

6.1 常见的2种享元模式

标准的享元模式结构图中既包含可以共享的具体享元类，也包含不可以共享的非共享具体享元类。但是在实际使用过程中，我们有时候会用到两种特殊的享元模式：单纯享元模式和复合享元模式，下面将对这两种特殊的享元模式进行简单的介绍：

       .单纯享元模式

       在单纯享元模式中，所有的具体享元类都是可以共享的，不存在非共享具体享元类。单纯享元模式的结构如图14-6所示：

图14-6  单纯享元模式结构图

      复合享元模式

       将一些单纯享元对象使用组合模式加以组合，还可以形成复合享元对象，这样的复合享元对象本身不能共享，但是它们可以分解成单纯享元对象，而后者则可以共享。复合享元模式的结构如图14-7所示：

图14-7  复合享元模式结构图

       通过复合享元模式，可以确保复合享元类CompositeConcreteFlyweight中所包含的每个单纯享元类ConcreteFlyweight都具有相同的外部状态，而这些单纯享元的内部状态往往可以不同。如果希望为多个内部状态不同的享元对象设置相同的外部状态，可以考虑使用复合享元模式。

6.2.与其他模式的联用

       享元模式通常需要和其他模式一起联用，几种常见的联用方式如下：

       (1)在享元模式的享元工厂类中通常提供一个静态的工厂方法用于返回享元对象，使用简单工厂模式来生成享元对象。

       (2)在一个系统中，通常只有唯一一个享元工厂，因此可以使用单例模式进行享元工厂类的设计。

       (3)享元模式可以结合组合模式形成复合享元模式，统一对多个享元对象设置外部状态。

 6.3.享元模式与String类

       JDK类库中的String类使用了享元模式，我们通过如下代码来加以说明：

class Demo {        public  static void main(String args[]) {               String  str1 = "abcd";               String  str2 = "abcd";               String  str3 = "ab" + "cd";               String  str4 = "ab";               str4  += "cd";                             System.out.println(str1  == str2);               System.out.println(str1  == str3);               System.out.println(str1  == str4);                             str2  += "e";               System.out.println(str1  == str2);        } }

       在Java语言中，如果每次执行类似String str1="abcd"的操作时都创建一个新的字符串对象将导致内存开销很大，因此如果第一次创建了内容为"abcd"的字符串对象str1，下一次再创建内容相同的字符串对象str2时会将它的引用指向"abcd"，不会重新分配内存空间，从而实现了"abcd"在内存中的共享。上述代码输出结果如下：

true true false false

       可以看出，前两个输出语句均为true，说明str1、str2、str3在内存中引用了相同的对象；如果有一个字符串str4，其初值为"ab"，再对它进行操作str4 += "cd"，此时虽然str4的内容与str1相同，但是由于str4的初始值不同，在创建str4时重新分配了内存，所以第三个输出语句结果为false；最后一个输出语句结果也为false，说明当对str2进行修改时将创建一个新的对象，修改工作在新对象上完成，而原来引用的对象并没有发生任何改变，str1仍然引用原有对象，而str2引用新对象，str1与str2引用了两个完全不同的对象。

7 范例

7.1咖啡店外卖咖啡

 客户买咖啡下订单，订单只区分咖啡口味，如果下了1W个订单，而咖啡店只卖4种口味的咖啡，那么我们就没有必要生成1W个订单对象，通过享元模式我们只需要生成4个订单对象。
   这个例子举的不太好，但足以说明问题。下面是具体的代码。
  

  1、 Order.java         订单抽象类
  2、 FlavorOrder.java   订单实现类
  3、 FlavorFactory.java 订单生成工厂
  4、 Client.java        客户类、带有main方法的测试类

订单抽象类

1. public abstract class Order {     
2.    //执行卖出动作    
3.    public abstract void sell();    
4.    //获取咖啡口味    
5.    public abstract String getFlavor();  
6. }

订单实现类

1. public class FlavorOrder extends Order{ 
2.  private String flavor;
    
    public FlavorOrder(String flavor){
        this.flavor = flavor;
    }
    
    public String getFlavor(){
        return this.flavor;
    }
    public void sell(){
        System.out.println("卖出一杯 [" + flavor + "]。" );
    }
   }
   

订单生成工厂

1. public class FlavorFactory {
2.  //订单池
    private Map<String,Order> flavorPool = new HashMap<String,Order>(20);
    //静态工厂,负责生成订单对象
    private static FlavorFactory flavorFactory = new FlavorFactory();
    private FlavorFactory() {}
    public static FlavorFactory getInstance() {
      return flavorFactory;
    }
    //获得订单
    public Order getOrder(String flavor) {
      Order order = null;
      if(flavorPool.containsKey(flavor)){
        order = flavorPool.get(flavor);
      }else{
        //获得新口味订单
        order = new FlavorOrder(flavor);
        //放入对象池
        flavorPool.put(flavor, order);   
      }
      return order;
    }
    //获得已经卖出的咖啡全部口味数量
    public int getTotalFlavorsMade() {
      return flavorPool.size();
    }
   }
   

客户类、带有main方法的测试类

1. public class Client {
2. // 客户下的订单
   private static List<Order> orders = new ArrayList<Order>(100);
   // 订单对象生成工厂
   private static FlavorFactory flavorFactory;
   
   
   public static void main(String[] args) {
   // 订单生成工厂
   flavorFactory = FlavorFactory.getInstance();
   // 增加订单
   takeOrders("摩卡");
   takeOrders("摩卡");
   takeOrders("卡布奇诺");
   takeOrders("香草星冰乐");
   takeOrders("香草星冰乐");
   takeOrders("拿铁");
   takeOrders("卡布奇诺");
   takeOrders("拿铁");
   takeOrders("卡布奇诺");
   takeOrders("摩卡");
   takeOrders("香草星冰乐");
   takeOrders("卡布奇诺");
   takeOrders("摩卡");
   takeOrders("香草星冰乐");
   takeOrders("拿铁");
   takeOrders("拿铁");
   // 卖咖啡
   for (Order order : orders) {
   order.sell();
   }
   // 打印生成的订单java对象数量
   System.out.println("n客户一共买了 " + orders.size() + " 杯咖啡! ");
   // 打印生成的订单java对象数量
   System.out.println("n共生成了 " + flavorFactory.getTotalFlavorsMade()
   + " 个 FlavorOrder java对象! ");
   // 判断orders中顺序存入的第一个对象和第2个对象是否为同一个对象
   System.out.println("方法1，判断orders中顺序存入的第1个对象和第2个对象是否为同一个对象： " + orders.get(0).equals(orders.get(1)));
   System.out.println("方法2，判断orders中顺序存入的第1个对象和第2个对象是否为同一个对象： " + (orders.get(0) == orders.get(1)));
   System.out.println("方法3，判断orders中顺序存入的第2个对象和第3个对象是否为同一个对象： " + (orders.get(1) == orders.get(2)));
   System.out.println("方法4，判断orders中顺序存入的第4个对象和第5个对象是否为同一个对象： " + (orders.get(3) == orders.get(4)));
   }
   
   
   // 增加订单
   private static void takeOrders(String flavor) {
   orders.add(flavorFactory.getOrder(flavor));
   }
   }

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

卖出一杯 [摩卡]。 卖出一杯 [摩卡]。 卖出一杯 [卡布奇诺]。 卖出一杯 [香草星冰乐]。 卖出一杯 [香草星冰乐]。 卖出一杯 [拿铁]。 卖出一杯 [卡布奇诺]。 卖出一杯 [拿铁]。 卖出一杯 [卡布奇诺]。 卖出一杯 [摩卡]。 卖出一杯 [香草星冰乐]。 卖出一杯 [卡布奇诺]。 卖出一杯 [摩卡]。 卖出一杯 [香草星冰乐]。 卖出一杯 [拿铁]。 卖出一杯 [拿铁]。 n客户一共买了 16 杯咖啡!  n共生成了 4 个 FlavorOrder java对象!  方法1，判断orders中顺序存入的第1个对象和第2个对象是否为同一个对象： true 方法2，判断orders中顺序存入的第1个对象和第2个对象是否为同一个对象： true 方法3，判断orders中顺序存入的第2个对象和第3个对象是否为同一个对象： false 方法4，判断orders中顺序存入的第4个对象和第5个对象是否为同一个对象： true

       从输出结果可以看出，享元工厂只根据4种咖啡类型在内存中生成了4个实际的咖啡订单

7.2围棋棋子

Sunny软件公司欲开发一个围棋软件，其界面效果如图14-1所示： 图14-1 围棋软件界面效果图

      Sunny软件公司开发人员通过对围棋软件进行分析，发现在围棋棋盘中包含大量的黑子和白子，它们的形状、大小都一模一样，只是出现的位置不同而已。如果将每一个棋子都作为一个独立的对象存储在内存中，将导致该围棋软件在运行时所需内存空间较大，如何降低运行代价、提高系统性能是Sunny公司开发人员需要解决的一个问题。为了解决这个问题，Sunny公司开发人员决定使用享元模式来设计该围棋软件的棋子对象，那么享元模式是如何实现节约内存进而提高系统性能的呢？

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

图14-4 围棋棋子结构图

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

[java]  view plain copy

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

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

[java]  view plain copy

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

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

判断两颗黑子是否相同：true 判断两颗白子是否相同：true 棋子颜色：黑色 棋子颜色：黑色 棋子颜色：黑色 棋子颜色：白色 棋子颜色：白色

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

上例为只有内部状态的享元结构、下例为带外部状态的享元结构

Sunny软件公司开发人员通过对围棋棋子进行进一步分析，发现虽然黑色棋子和白色棋子可以共享，但是它们将显示在棋盘的不同位置，如何让相同的黑子或者白子能够多次重复显示且位于一个棋盘的不同地方？解决方法就是将棋子的位置定义为棋子的一个外部状态，在需要时再进行设置。因此，我们在图14-4中增加了一个新的类Coordinates（坐标类），用于存储每一个棋子的位置，修改之后的结构图如图14-5所示：

图14-5 引入外部状态之后的围棋棋子结构图

       在图14-5中，除了增加一个坐标类Coordinates以外，抽象享元类IgoChessman中的display()方法也将对应增加一个Coordinates类型的参数，用于在显示棋子时指定其坐标，Coordinates类和修改之后的IgoChessman类的代码如下所示：

[java]  view plain copy

1. //坐标类：外部状态类  
2. class Coordinates {  
3.     private int x;  
4.     private int y;  
5.       
6.     public Coordinates(int x,int y) {  
7.         this.x = x;  
8.         this.y = y;  
9.     }  
10.       
11.     public int getX() {  
12.         return this.x;  
13.     }  
14.       
15.     public void setX(int x) {  
16.         this.x = x;  
17.     }  
18.       
19.     public int getY() {  
20.         return this.y;  
21.     }  
22.       
23.     public void setY(int y) {  
24.         this.y = y;  
25.     }  
26. }   
27.   
28. //围棋棋子类：抽象享元类  
29. abstract class IgoChessman {  
30.     public abstract String getColor();  
31.       
32.     public void display(Coordinates coord){  
33.         System.out.println("棋子颜色：" + this.getColor() + "，棋子位置：" + coord.getX() + "，" + coord.getY() );    
34.     }  
35. }  

       客户端测试代码修改如下：

[java]  view plain copy

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

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

判断两颗黑子是否相同：true 判断两颗白子是否相同：true 棋子颜色：黑色，棋子位置：1，2 棋子颜色：黑色，棋子位置：3，4 棋子颜色：黑色，棋子位置：1，3 棋子颜色：白色，棋子位置：2，5 棋子颜色：白色，棋子位置：2，4

       从输出结果可以看到，在每次调用display()方法时，都设置了不同的外部状态——坐标值，因此相同的棋子对象虽然具有相同的颜色，但是它们的坐标值不同，将显示在棋盘的不同位置。