- 浏览: 65714 次
- 性别:
- 来自: 上海
最新评论
-
java苹果+番茄:
已经修改,感谢大家提的意见;有一年多没进来了,很惭愧;以后一定 ...
java设计模式笔记链接地址汇总 -
youthon:
命令(Command)模式【行为模式第九篇】的链接应为http ...
java设计模式笔记链接地址汇总 -
youthon:
你给的链接只有你自己才能打开,你改改吧
java设计模式笔记链接地址汇总 -
shaozhi_jinni:
[b][/b][i][/i][u][/u]引用引用
[img ...
模板方法(Template Method)模式【行为模式第十篇】 -
Tank03:
慢慢的走~
android开发学习中(已经学会了几个小玩意),兴趣大增
亨元(Flyweight Pattern)模式
1、亨元模式的用意
亨元模式是对象的结构模式。亨元模式以共享的方式高效地支持大量的细粒度对象。
亨元模式能做到共享的关键是区分内蕴状态和外蕴状态
一个内蕴状态是存储在亨元对象内部的,并且是不会随环境改变而有所不同的。因此,一个亨元可以具有内蕴状态并可以共享。
一个外蕴状态是随环境改变而改变的、不可以共享的状态。亨元对象的外蕴状态必须由客户端保存,并在亨元对象被创建之后,
在需要使用的时候再传入到亨元对象内部。
外蕴状态不可以影响亨元对象的内蕴状态的,它们是相互独立的。
2、亨元模式的种类
根据所涉及的亨元对象的北部表象,亨元模式可以分为单纯亨元模式和复合亨元模式两种形式。
3、亨元模式的实现:
1)单纯亨元模式涉及的角色
1-抽象亨元角色:此角色是所有的具体亨元类的超类,为这些规定出需要实现的公共接口,那些需要外蕴状态的操作
可以通过方法的参数传入。抽象亨元的接口使得亨元变得可能,但是并不强制子类实行共享,因此并非所有的亨元
对象都是可以共享的
2-具体亨元角色:实现抽象亨元角色所规定的接口。如果有内蕴状态的话,必须负责为内蕴状态提供存储空间。
亨元对象的内蕴状态必须与对象所处的周围环境无关,从而使得亨元对象可以在系统内共享。有时候具体亨元角色
又叫做单纯具体亨元角色,因为复合亨元角色是由单纯具体亨元角色通过复合而成的
3-复合亨元角色:复合亨元角色所代表的对象是不可以共享的,但是一个复合亨元对象可以分解成为多个本身是单纯亨元
对象的组合。复合亨元角色又称做不可共享的亨元对象。
4-亨元工厂角色:本角色负责创建和管理亨元角色。本角色必须保证亨元对象可以被系统适当地共享。
当一个客户端对象请求一个亨元对象的时候,亨元工厂角色需要检查系统中是否已经有一个符合要求的亨元对象,
如果已经有了,亨元工厂角色就应当提供这个已有的亨元对象;如果系统中没有一个适当的亨元对象的话,
亨元工厂角色就应当创建一个新的合适的亨元对象。
5-客户端角色:本角色还需要自行存储所有亨元对象的外蕴状态。
4、模式的实现
1)使用不变模式实现亨元角色
亨元模式里的亨元对象不一定非得是不变对象,但是很多的亨元对象确实被设计成了不变对象。
由于不变对象的状态之后就不再变化,因此不变对象满足亨元模式对亨元对象的要求。
2)使用备忘录模式实现亨元工厂角色
亨元工厂负责维护一个表,通过这个表把很多全同的实例与代表它们的一个对象联系起来。这就是备忘录模式的应用。
3)使用单例模式实现亨元工厂角色
系统往往只需要一个亨元工厂的实例,所以亨元工厂可以设计成为单例模式。
5、亨元模式的使用情况
当以下所有的条件都满足时,可以考虑使用亨元模式:
(1)一个系统有大量的对象。
(2)这些对象耗费大量的内存
(3)这些对象的状态中大部分都可以外部化
(4)这些对象可以按照内蕴状态分成很多的组,当把外蕴对象从对象中剔除时,每一个组都可以仅用一个对象代替。
(5)软件系统不依赖于这些对象的身份,换言之,这些对象可以是不可分辨的。
应当在有足够多的亨元实例可供共享时才值得使用亨元模式。
6、怎样做到共享
一个亨元对象之所以可以被很多的用户端共享,是因为它只含有可以共享的状态,而没有不可以共享的状态,
这就是使用亨元模式的前提。
要做到符合亨元模式这一点,需要分两步走:
(1)将可以共享的状态和不可以共享的状态从此常规类中区分开来,将不可共享的状态从类里剔除出去。
那些对所有客户端都去相同的值的状态是可以共享的状态;而那些对不同的客户端有不同值的状态是不可以共享的状态
(2)这个类的创建过程必须由一个工厂对象加以控制。
这个工厂对象应当使用一个内部列表保存所有的已经创建出来的对象。当客户端请求一个新的对象时,
工厂对象首先检查列表,看是否已经有一个对象。如果已经有了,就直接返还此对象,如果没有就创建一个新对象。
亨元模式要求将可以共享的状态设置为内蕴状态,而将不可以共享的状态设置成外蕴状态,将它们外部化。
7、亨元模式的优缺点
亨元模式的优点在于它大幅度降低内存中对象的数量。但是,它做到这一点所付出的代价也是很高的:
(1)亨元模式使得系统更加复杂。为了使对象可以共享,需要将一些状态外部化,这使得程序的逻辑复杂化
(2)亨元模式将亨元对象的状态外部化,而读取外部状态使得运行时间稍微变长。
1、亨元模式的用意
亨元模式是对象的结构模式。亨元模式以共享的方式高效地支持大量的细粒度对象。
亨元模式能做到共享的关键是区分内蕴状态和外蕴状态
一个内蕴状态是存储在亨元对象内部的,并且是不会随环境改变而有所不同的。因此,一个亨元可以具有内蕴状态并可以共享。
一个外蕴状态是随环境改变而改变的、不可以共享的状态。亨元对象的外蕴状态必须由客户端保存,并在亨元对象被创建之后,
在需要使用的时候再传入到亨元对象内部。
外蕴状态不可以影响亨元对象的内蕴状态的,它们是相互独立的。
2、亨元模式的种类
根据所涉及的亨元对象的北部表象,亨元模式可以分为单纯亨元模式和复合亨元模式两种形式。
3、亨元模式的实现:
1)单纯亨元模式涉及的角色
1-抽象亨元角色:此角色是所有的具体亨元类的超类,为这些规定出需要实现的公共接口,那些需要外蕴状态的操作
可以通过方法的参数传入。抽象亨元的接口使得亨元变得可能,但是并不强制子类实行共享,因此并非所有的亨元
对象都是可以共享的
2-具体亨元角色:实现抽象亨元角色所规定的接口。如果有内蕴状态的话,必须负责为内蕴状态提供存储空间。
亨元对象的内蕴状态必须与对象所处的周围环境无关,从而使得亨元对象可以在系统内共享。有时候具体亨元角色
又叫做单纯具体亨元角色,因为复合亨元角色是由单纯具体亨元角色通过复合而成的
3-复合亨元角色:复合亨元角色所代表的对象是不可以共享的,但是一个复合亨元对象可以分解成为多个本身是单纯亨元
对象的组合。复合亨元角色又称做不可共享的亨元对象。
4-亨元工厂角色:本角色负责创建和管理亨元角色。本角色必须保证亨元对象可以被系统适当地共享。
当一个客户端对象请求一个亨元对象的时候,亨元工厂角色需要检查系统中是否已经有一个符合要求的亨元对象,
如果已经有了,亨元工厂角色就应当提供这个已有的亨元对象;如果系统中没有一个适当的亨元对象的话,
亨元工厂角色就应当创建一个新的合适的亨元对象。
5-客户端角色:本角色还需要自行存储所有亨元对象的外蕴状态。
//抽象亨元角色 public abstract class Flyweight{ public abstract void operation(String state); } //具体亨元角色 具体亨元角色的主要责任: 1)实现了抽象亨元角色所声明的接口,也就是operation()方法。operation()方法 接收一个外蕴状态作为参量。 2)为内蕴状态提供存储空间,在本实现中就是intrinsicState属性。亨元模式本身对内蕴状态的存储类型并无要求 这里的内蕴状态是Character类型,是为了给符合亨元的内蕴状态选做String类型提供方便。 public class ConcreteFlyweight extends Flyweight{ private Character intrinsicState = null; public ConcreteFlyweight(Character state){ this.intrinsicState = state; } //外蕴状态作为参量传入到方法中 public void operation(String state){ System.out.print("\nInternal State = " + intrinsicState + "Extrinsic State = " + state); } } //具体复合亨元角色 具体复合亨元角色的责任: 1)复合亨元对象是由单纯的亨元对象通过复合而成,因此它提供了add()这样的聚集管理方法。 由于一个复合亨元对象具有不同的聚集元素,这些聚集元素在复合亨元对象被创建之后加入,这本身就意味着 亨元对象的状态是会改变的,因此复合亨元对象是不能共享的。 2) 复合亨元角色实现了抽象亨元角色所规定的接口, 也就是operation()方法。这个方法有一个参量, 代表复合亨元对象的外蕴状态,。一个复合亨元对象的所有单纯亨元对象元素的外蕴状态都是与复合亨元对象的 外蕴状态相等的,而一个复合亨元对象所含有的单纯亨元对象的内蕴状态一般是不相等的,不然就没有使用价值了。 import java.util.Map; import java.util.HashMap; import java.util.Iterator; public class ConcreteCompositeFlyweight extends Flyweight{ private HashMap flies = new HashMap(10); private Flyweight flyweight; public ConcreteCompositeFlyweight(){} //增加一个新的单纯亨元对象到聚集中 public void add(Character key, Flyweight fly){ flies.put(key,fly); } //外蕴状态作为参量传入到方法中 public void operation(String extrinsicState){ Flyweight fly = null; for(Iterator it = flies.entrySet().iterator()); it.hasNext();){ Map.Entry e = (Map.Entry)it.next(); fly = (Flyweight)e.getValue(); fly.operation(extrinsicState); } } } //亨元工厂角色 import java.util.Map; import java.util.HashMap; import java.util.Iterator; public class FlyweightFactory{ private HashMap flies = new HashMap(); public FlyweightFactory(){} //复合亨元工厂方法,所需状态以参量形式传入,这个参量恰好可以使用String类型 public Flyweight factory(String compositeState){ ConcreteCompositeFlyweight compositeFly = new ConcreteCompositeFlyweight(); int length = compositeState.length(); Character state = null; for(int i = 0; i < length; i ++){ state = new Character(compositeState.charAt(i)); System.out.println("factory(" + state +")"); compositeFly.add(state,this.factory(state)); } return compositeFly; } //单纯亨元工厂方法 public Flyweight factory(Character state){ //检查具有此状态的亨元是否已经存在 if(flies.containsKey(state)){ //具有此状态的亨元已经存在,因此直接将它返回 retun (Flyweight)flies.get(state); }else{ //具有此状态的亨元不存在,因此创建新实例 Flyweight fly = new ConcreteFlyweight(state); //将实例存储到聚集中 flies.put(state,fly); //将实例返回 return fly; } } public void checkFlyweight(){ Flyweight fly; int i = 0; System.out.println("\n==========CheckFlyweight()=============="); for(Iterator it = flies.entrySet().iterator(); it.hasNext();){ Map.Entry e = (Map.Entry) it.next(); System.out.println("Item" + (++i) + ";" + e.getKey()); } System.out.println("\n==========CheckFlyweight()=============="); } }
4、模式的实现
1)使用不变模式实现亨元角色
亨元模式里的亨元对象不一定非得是不变对象,但是很多的亨元对象确实被设计成了不变对象。
由于不变对象的状态之后就不再变化,因此不变对象满足亨元模式对亨元对象的要求。
2)使用备忘录模式实现亨元工厂角色
亨元工厂负责维护一个表,通过这个表把很多全同的实例与代表它们的一个对象联系起来。这就是备忘录模式的应用。
3)使用单例模式实现亨元工厂角色
系统往往只需要一个亨元工厂的实例,所以亨元工厂可以设计成为单例模式。
在单纯的共享模式中使用单例模式实现共享工厂角色 import java.util.Map; import java.util.HashMap; import java.util.Iterator; public class FlyweightFactorySingleton{ private HashMap flies = new HashMap(); private static FlyweightFactorySingleton myself = new FlyweightFactorySingleton(); private FlyweightFactorySingleton(){} public static FlyweightFactorySingleton getInstance(){ return myself; } //工厂方法,向外界提供含有指定内蕴状态的对象 public synchronized Flyweight factory(Character state){ //检查具有此状态的亨元是否已经存在 if(flies.containsKey(state)){ //具有此状态的亨元对象已经存在,因此直接返还此对象 return (Flyweight)flies.get(state); }else{ Flyweight fly = new ConcreteFlyweight(state); flies.put(state,fly); return fly } } //辅助方法,打印所有已经创建的亨元对象清单 public void checkFlyweight(){ Flyweight fly; int i = 0; System.out.println("\n===========checkFlyweight==============="); for(Iterator it = flies.entrySet().iterator(); it.hasNext();){ Map.Entry e = (Map.Entry)it.next(); System.out.println("Item" + (++i) + ":" + e.getKey()); } System.out.println("\n===========checkFlyweight==============="); } } //客户端代码 public class ClientSingleton{ private static FlyweightFactorySingleton factory; public static void main(String args[]){ factory = FlyweightFactorySingleton.getInstance(); Flyweight fly = factory.factory(new Character('a')); fly.operation("First Call"); fly = factory.factory(new Character('b')); fly.operation("Second call"); Flyweight fly = factory.factory(new Character('a')); fly.operation("Third Call"); factory.checkFlyweight(); } } //将一个共享工厂角色用单例模式实现 import java.util.Map; import java.util.HashMap; import java.util.Iterator; public class FlyweightFactorySingleton{ private static FlyweightFactorySingleton myself = new FlyweightFactorySingleton(); private HashMap flies = new HashMap(); private Flyweight inkFlyweight; private FlyweightFactorySingleton(){} public static FlyweightFactorySingleton getInstance(){ return new FlyweightFactorySingleton(); } public Flyweight factory(String complexState){ ConcreteCompositeFlyweight complexFly = new ConcreteCompositeFlyweight(); int length = complexState.length(); Character state = null; for(int i = 0; i < length; i ++){ state = new Character(complexState.charAt(i)); System.out.println("factory(" + state + ")"); complexFly.add(state,this.factory(state)); } return complexFly; } public synchronized Flyweight factory(Character state){ //检查具有此状态的亨元是否已经存在 if(flies.containsKey(state)){ return (Flyweight)flies.get(state); }else{ Flyweight fly = new ConcreteFlyweight(state); flies.put(state,fly); return fly; } } public void checkFlyweight(){ Flyweight fly; int i = 0; System.out.println("\n===========checkFlyweight==============="); for(Iterator it = flies.entrySet().iterator(); it.hasNext();){ Map.Entry e = (Map.Entry)it.next(); System.out.println("Item" + (++i) + ":" + e.getKey()); } System.out.println("\n===========checkFlyweight==============="); } } //一个应用亨元模式的咖啡摊例子 //抽象亨元角色,serve()它没有参量是因为没有外蕴状态 public abstract class Order{ //将咖啡卖客人 public abstract void serve(); //返还咖啡的名字 public abstract String getFlavor(); } //具体亨元角色 public class Flavor extends Order{ private String flavor; public Flavor(String flavor){ this.flavor = flavor; } public String getFlavor(){ return this.flavor; } //将咖啡卖给客人 public void serve(){ System.out.println(System.out.println("Serving flavor " + flavor); } } //工厂角色 public class FlavorFactory{ private Order[] flavors = new Flavor[10]; private int ordersMade = 0; private int totalFlavors = 0; //工厂方法,根据所需的风味提供咖啡 public Order getOrder(String flavorToGet){ if(ordersMade > 0){ for(int i = 0 ; i < ordersMade; i ++){ if(flavorToGet.equals(flavors[i].getFlavor())){ return flavors[i]; } } } flavors[ordersMade] = new Flavor(flavorToGet); totalFlavors++; return flavors[ordersMade++]; } //辅助方法,返还创建过的风味对象的个数 public int getTotalFlavorsMade(){ return totalFlavors; } } //客户端代码,代表咖啡摊侍者 public class ClientFlavor{ private static Order[] flavors = new Flavor[20]; private static int ordersMade = 0; private static FlavorFactory flavorFactory; //提供一杯咖啡 private static void takeOrders(String aFlavor){ flavors[ordersMade++] = flavorFactory.getOrder(aFlavor); } public static void main(String args[]){ flavorFactory = new FlavorFactory(); takeOrders("Black Coffee"); takeOrders("Capucino"); takeOrders("Espresso"); takeOrders("Espresso"); takeOrders("Capucino"); takeOrders("Capucino"); takeOrders("Black Coffee"); takeOrders("Espresso"); takeOrders("Capucino"); //将所创建的对象卖给客人 for(int i = 0; i < ordersMade; i ++){ flavors[i].serve(); } System.out.println("\nTotal teaFlavor objects made: " + flavorFactor.getTotalFlavorsMade() ); } } //如果这个例子再大点,可以增加一个外蕴状态,也就是说可以增加桌子号,建立一个桌子类,将桌子号作为 参数传给serve(Table table).
5、亨元模式的使用情况
当以下所有的条件都满足时,可以考虑使用亨元模式:
(1)一个系统有大量的对象。
(2)这些对象耗费大量的内存
(3)这些对象的状态中大部分都可以外部化
(4)这些对象可以按照内蕴状态分成很多的组,当把外蕴对象从对象中剔除时,每一个组都可以仅用一个对象代替。
(5)软件系统不依赖于这些对象的身份,换言之,这些对象可以是不可分辨的。
应当在有足够多的亨元实例可供共享时才值得使用亨元模式。
6、怎样做到共享
一个亨元对象之所以可以被很多的用户端共享,是因为它只含有可以共享的状态,而没有不可以共享的状态,
这就是使用亨元模式的前提。
要做到符合亨元模式这一点,需要分两步走:
(1)将可以共享的状态和不可以共享的状态从此常规类中区分开来,将不可共享的状态从类里剔除出去。
那些对所有客户端都去相同的值的状态是可以共享的状态;而那些对不同的客户端有不同值的状态是不可以共享的状态
(2)这个类的创建过程必须由一个工厂对象加以控制。
这个工厂对象应当使用一个内部列表保存所有的已经创建出来的对象。当客户端请求一个新的对象时,
工厂对象首先检查列表,看是否已经有一个对象。如果已经有了,就直接返还此对象,如果没有就创建一个新对象。
亨元模式要求将可以共享的状态设置为内蕴状态,而将不可以共享的状态设置成外蕴状态,将它们外部化。
7、亨元模式的优缺点
亨元模式的优点在于它大幅度降低内存中对象的数量。但是,它做到这一点所付出的代价也是很高的:
(1)亨元模式使得系统更加复杂。为了使对象可以共享,需要将一些状态外部化,这使得程序的逻辑复杂化
(2)亨元模式将亨元对象的状态外部化,而读取外部状态使得运行时间稍微变长。
发表评论
-
java设计模式笔记链接地址汇总
2009-10-24 14:46 2252各位,这些笔记已经生成了pdf,如果有兴趣的可以在本文末尾下载 ... -
MVC模式【行为模式第十三篇】
2009-10-23 23:36 1478MVC模式:就是模型-视 ... -
状态(State Pattern)模式【行为模式第十二篇】
2009-10-23 23:35 1323状态(State Pattern)模式:又称为状态对象模式,状 ... -
责任链(Chain of Responsibility)模式【行为模式第十一篇】
2009-10-23 23:33 1214责任链(Chain of Responsibility)模式 ... -
模板方法(Template Method)模式【行为模式第十篇】
2009-10-23 23:32 1188模板方法(Template Method)模式 模板方法模式 ... -
命令(Command)模式【行为模式第九篇】
2009-10-23 23:31 1372命令(Command)模式: ... -
解释器(Interpreter)模式【行为模式第八篇】
2009-10-23 23:29 1075解释器(Interpreter)模 ... -
观察者(Observer)模式【行为模式第七篇】
2009-10-23 23:28 1228观察者(Observer)模式 ... -
访问者(Visitor)模式【行为模式第六篇】
2009-10-23 23:26 1065访问者(Visitor)模式: 访问者模式是对象的行为模式。 ... -
迭代子(Iterator)模式【行为模式第五篇】
2009-10-23 23:25 1410迭代子(Iterator)模式: 迭代子模式又叫游标(Cur ... -
调停者(Mediator)模式 【行为模式第四篇】
2009-10-23 23:23 2631调停者(Mediator)模式 调停者模式是对象的行为模式。 ... -
策略(Strategy)模式 【行为模式第三篇】
2009-10-23 23:22 1504策略(Strategy)模式 策略模式属于对象的行为模式。其 ... -
不变(Immutable)模式【行为模式第二篇】
2009-10-23 23:21 1645不变(Immutable)模式 一个对象的状态在对象被创建之 ... -
备忘录(Memento Pattern)模式 【行为模式第一篇】
2009-10-23 23:19 1951备忘录(Memento Pattern)模式 备忘录模式又叫 ... -
适配器模式举例【结构模式第八篇】
2009-10-23 23:17 1027XMLProperties与适配器模式举例: //---- ... -
适配器模式【结构模式第六篇】
2009-10-23 23:12 1156适配器模式(Adapter Pattern)(另称-变压器模式 ... -
桥梁(Bridge)模式【结构模式第五篇】
2009-10-23 23:09 1310桥梁(Bridge)模式: 一、桥梁模式的用意 桥梁模式 ... -
门面(Facade)模式【结构模式第四篇】
2009-10-23 23:08 1203门面(Facade)模式: 是对象的结构模式。外部与一个子系 ... -
合成(Composite)模型模式【结构模式第二篇】
2009-10-23 23:04 1348合成(Composite)模型模式: 属于对象的结构模式,有 ... -
代理(Proxy)模式 【结构模式第一篇】
2009-10-23 23:02 1365代理(Proxy)模式 是对 ...
相关推荐
享元模式(Flyweight Pattern)主要用于减少创建对象的数量,以减少内存占用和提高性能。这种类型的设计模式属于结构型模式,它提供了减少对象数量从而改善应用所需的对象结构的方式。
设计模式(C#)之享元模式(Flyweight Pattern),运用共享技术有效地支持大量细粒度的对象。
6共享元模式(Flyweight) 用意:以共享的方式高效地支持大量的细粒度对象
C#面向对象设计模式纵横谈(12):Flyweight 享元模式(结构型模式) (Level 300)
设计模式 Flyweight
设计模式学习笔记--Flyweight享元模式.docx设计模式学习笔记--Flyweight享元模式.docx设计模式学习笔记--Flyweight享元模式.docx设计模式学习笔记--Flyweight享元模式.docx设计模式学习笔记--Flyweight享元模式.docx
C#面向对象设计模式纵横谈(12):Flyweight 享元模式(结构型模式)
享元模式(Flyweight Pattern) 代理模式(Proxy Pattern) 3. 行为型模式 责任链模式(Chain of Responsibility Pattern) 命令模式(Command Pattern) 解释器模式(Interpreter Pattern) 迭代器模式...
适配器模式(Adapter Pattern) 提供者模式(Provider Pattern) 外观模式(Facade Pattern) 享元模式(Flyweight Pattern) 原型模式(Prototype Pattern) 责任链模式(Chain of Responsibility Pattern) 中介者模式...
享元模式英文称为“Flyweight Pattern”,我非常感谢将Flyweight Pattern翻译成享元模式的那位强人,因为这个词将这个模式使用的方式明白得表示了出来;如果翻译成为羽量级模式或者蝇量级模式等等,虽然可以含蓄的...
享元模式(Flyweight Pattern) 12. 代理模式(Proxy Pattern) 行为型: 13. 模板方法(Template Method) 14. 命令模式(Command Pattern) 15. 迭代器模式(Iterator Pattern) 16. 观察者模式(Observer Pattern) 17. ...
享元模式(Flyweight Pattern) 12. 代理模式(Proxy Pattern) 13. 模板方法(Template Method) 14. 命令模式(Command Pattern) 15. 迭代器模式(Iterator Pattern) 行为型: 16. 观察者模式(Observer Pattern...
23种设计模式之十(结构型模式)Flyweight模式
享元模式(Flyweight Pattern) 代理模式(Proxy Pattern) 行为型模式用来对类或对象怎样交互和怎样分配职责进行描述,主要包含以下11种设计模式: 责任链模式(Chain of Responsibility Pattern) ...
软件模式之Flyweight模式.docx
享元模式(Flyweight Pattern) 12. 代理模式(Proxy Pattern) 13. 模板方法(Template Method) 14. 命令模式(Command Pattern) 15. 迭代器模式(Iterator Pattern) 行为型: 16. 观察者模式(Observer Pattern...
享元模式(Flyweight Pattern) 代理模式(Proxy Pattern) 3 行为型模式 这些设计模式特别关注对象之间的通信。 责任链模式(Chain of Responsibility Pattern) 命令模式(Command Pattern) 解释器模式...
主要介绍了C++设计模式编程的Flyweight享元模式结构,享元模式在实现过程中主要是要为共享对象提供一个存放的"仓库"(对象池),需要的朋友可以参考下
在这里与各位分享本人从网络上下载的C#面向对象设计模式纵横谈系列视频,共有25节,除了第一节需要各位贡献一点资源分以作为对本人上传资源的回馈,后面的其他资源均不需要... 这是第12节:结构型模式Flyweight享元模式
Design Pattern: Flyweight 模式 46 Design Pattern: Proxy 模式(一) 48 Design Pattern: Proxy 模式(二) 49 Design Pattern: Chain of Responsibility 模式 53 Design Pattern: Command 模式 59 Design Pattern...