举个例子说明享元模式，一个咖啡店有几种口味的咖啡（拿铁、摩卡、卡布奇诺等等），如果这家店接到分订单要几十杯咖啡。那么显然咖啡的口味就可以设置成共享的，而不必为每一杯单独生成。

1. package com.source;
   
2. import java.util.ArrayList;
   
3. import java.util.HashMap;
   
4. import java.util.List;
   
5. import java.util.Map;
   
6. 
   
7. abstract class Order {
   
8. // 执行卖出动作
   
9. public abstract void sell();
   
10. }
    
11. 
    
12. class FlavorOrder extends Order {
    
13. public String flavor;
    
14. 
    
15. // 获取咖啡口味
    
16. public FlavorOrder(String flavor) {
    
17. this.flavor = flavor;
    
18. }
    
19. 
    
20. @Override
    
21. public void sell() {
    
22. // TODO Auto-generated method stub
    
23. System.out.println("卖出一份" + flavor + "的咖啡。");
    
24. }
    
25. }
    
26. 
    
27. class FlavorFactory {
    
28. private Map<String, Order> flavorPool = new HashMap<String, Order>();
    
29. 
    
30. // 静态工厂,负责生成订单对象
    
31. private static FlavorFactory flavorFactory = new FlavorFactory();
    
32. 
    
33. private FlavorFactory() {
    
34. }
    
35. 
    
36. public static FlavorFactory getInstance() {
    
37. return flavorFactory;
    
38. }
    
39. 
    
40. public Order getOrder(String flavor) {
    
41. Order order = null;
    
42. 
    
43. if (flavorPool.containsKey(flavor)) {// 如果此映射包含指定键的映射关系，则返回 true
    
44. order = flavorPool.get(flavor);
    
45. 
    
46. } else {
    
47. order = new FlavorOrder(flavor);
    
48. flavorPool.put(flavor, order);
    
49. }
    
50. return order;
    
51. }
    
52. 
    
53. public int getTotalFlavorsMade() {
    
54. return flavorPool.size();
    
55. }
    
56. }
    
57. 
    
58. public class Client {
    
59. // 客户下的订单
    
60. private static List<Order> orders = new ArrayList<Order>();
    
61. 
    
62. // 订单对象生成工厂
    
63. private static FlavorFactory flavorFactory;
    
64. 
    
65. // 增加订单
    
66. private static void takeOrders(String flavor) {
    
67. orders.add(flavorFactory.getOrder(flavor));
    
68. }
    
69. 
    
70. public static void main(String[] args) {
    
71. // 订单生成工厂
    
72. flavorFactory = FlavorFactory.getInstance();
    
73. 
    
74. // 增加订单
    
75. takeOrders("摩卡");
    
76. takeOrders("卡布奇诺");
    
77. takeOrders("香草星冰乐");
    
78. takeOrders("香草星冰乐");
    
79. takeOrders("拿铁");
    
80. takeOrders("卡布奇诺");
    
81. takeOrders("拿铁");
    
82. takeOrders("卡布奇诺");
    
83. takeOrders("摩卡");
    
84. takeOrders("香草星冰乐");
    
85. takeOrders("卡布奇诺");
    
86. takeOrders("摩卡");
    
87. takeOrders("香草星冰乐");
    
88. takeOrders("拿铁");
    
89. takeOrders("拿铁");
    
90. 
    
91. // 卖咖啡
    
92. for (Order order : orders) {
    
93. order.sell();
    
94. }
    
95. 
    
96. // 打印生成的订单java对象数量
    
97. System.out.println("\n客户一共买了 " + orders.size() + " 杯咖啡! ");
    
98. 
    
99. // 打印生成的订单java对象数量
    
100. System.out.println("共生成了 " + flavorFactory.getTotalFlavorsMade()
     
101. + " 个 FlavorOrder java对象! ");
     
102. }
     
103. }
     
104. 
     

复制代码

结论：
卖出一份摩卡的咖啡。
卖出一份卡布奇诺的咖啡。
卖出一份香草星冰乐的咖啡。
卖出一份香草星冰乐的咖啡。
卖出一份拿铁的咖啡。
卖出一份卡布奇诺的咖啡。
卖出一份拿铁的咖啡。
卖出一份卡布奇诺的咖啡。
卖出一份摩卡的咖啡。
卖出一份香草星冰乐的咖啡。
卖出一份卡布奇诺的咖啡。
卖出一份摩卡的咖啡。
卖出一份香草星冰乐的咖啡。
卖出一份拿铁的咖啡。
卖出一份拿铁的咖啡。

客户一共买了 15 杯咖啡!
共生成了 4 个 FlavorOrder java对象!

正如输入结果对比所示，把口味共享极大减少了对象数目，减小了内存消耗。

优缺点：
1）享元模式使得系统更加复杂。为了使对象可以共享，需要将一些状态外部化，这使得程序的逻辑复杂化。
2）享元模式将享元对象的状态外部化，而读取外部状态使得运行时间稍微变长。

优化一下：将口味用变量来表示，这样就不用在takeOrders("香草星冰乐");方法里填重复的字符串了