flyweight模式 flyflight

extjs函数调用方法

其实都了解一下比较好。

一、获取元素（Getting

flyweight模式 flyflight

flyweight模式 flyflight

单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑，而不关心它是否是单例的，是不是要单例取决于环境，单例模式把“要单例”和业务逻辑融合在一个类中。

Elements）

1.Ext.get

var

el

=Ext.get('myElementId');//获取元素，等同于document.getElementById('myElementId');//会缓存

2.

Ext.fly

var

el

=Ext.fly('myElementId')//不需要缓存。

Design

Pattern）是一种节省内存的模式，该模式的大概原理是建立单个全体对象然后不断反复使用它。

3.Ext.getDom

var

elDom

=Ext.getDom('elId');

//

依据id来查dom

var

elDom1

//

依据dom来查dom

二、CSS元素

4.addClass

//

加入元素的'myCls'的样式

5.radioClass

Ext.fly('elId').radioClass('myCls');//添加一个或多个className到这个元素，并移除其所有侧边（siblings）上的同名样式。

6.removeClass

Ext.fly('elId').removeClass('myCls');

//

移除元素的样式

7.toggleClass

//

加入样式

//

移除样式

//

再加入样式

8.hasClass

if

(Ext.fly('elId').hasClass('myCls'))

{//判断是否已加上这个样式

//

是有样式的

Ext.fly('elId').replaceClass('myClsA',

'myClsB');//替换样式

11.getStyle

var

color

=Ext.fly('elId').getStyle('color');//返回该元素的统一化当前样式和计算样式。

var

zIndx

=Ext.fly('elId').getStyle('z-index');//返回该元素的统一化当前样式和计算样式。

12.setStyle

Ext.fly('elId').setStyle({

display

:'block',

overflow

:'hidden',

cursor

:'pointer'

});//设置元素的样式，也可以用一个对象参数包含多个样式。

13.getColor

Ext.fly('elId').getColor('color');//为指定的CSS属性返回CSS颜色

14.setOpacity

Ext.fly('elId').setOpacity(.45,

true);//设置元素的透明度。

15.clearOpacity

Ext.fly('elId').clearOpacity();//清除这个元素的透明度设置

.NET的24个设计模式有哪些？

通用代码：

创建型模式...

十八、Facade，外观模式：为子系统中的一组接口提供一致的界面，facade提供了一高层接口，这个接口使得子系统更容易使用。

1. Abstract Factory.. 2提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

2. Builder 2 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

3. Factory Mod.. 3定义一个用于创建对象的接口，让子类决定实例化哪一个类。使一个类的实例化延迟到其子类。

4. Prototype.. 3用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

5. Singleton. 3 保证一个类一个实例，并提供一个访问它的全局访问点

结构型模式...

1. Adapter. 4将一个类的接口转换成客户希望的另外一个接口。

2. Bridge.. 4将抽象部分与它的实现部分分离，使它们都可以的变化。

3. Comite.. 5将对象组合成树形结构以表示“部分-整体”的层次结构。

4. Decorator. 5动态地给一个对象添加一些额外的职责。

5. Fa?ade.. 6为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

6. Flyweight. 6运用共享技术有效地支持大量细粒度的对象。

7. Proxy.. 7为其它对象提供一种以控制对这个对象的访问。

行为模式...

1. Chain of Responsibility. 7 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。

2. Command. 7 将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的作。

3. Interpreter. 8给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语句中的句子。

4. Iterator 8 提供一种方法顺序访问一个聚合对象中的各个元素，而不需要暴露该对象的内部表示。

5. Mediator 8 用一个中介对象来封装一系列的对象交互。

7. Observer 9 定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。

8. State.. 9允许一个对象在其内部状态改变时改变它的行为。

9. Strategy. 10 定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。

10. Template Mod.. 10定义一个作中的算法的骨架，而将一些步骤延迟到子类中。

11. Visitor. 10表示一个作用于某对象结构中的各元素的作。

继承是否真的会破坏类的封装性？

问题一：什么是单例设计模式 问题八：你熟悉的设计模式有哪些？写出单例模式的实现代码 一共23种设计模式！ ja模式之单例模式：

当时以为这是正确，也没怎么想就带过去了。但是今天，我又碰到了同样的问题（真是冤家路窄:P），而我已经真正接触过了面向对象设计与编程，设计模式等东西。那么我现在不禁产生了这个疑问，类的继承真的会破坏类的封装性吗？

要解答这个问题，首先要明确的两个概念就是类的继承和封装。按照Ja中对于封装（Encapsulation）的概念，其是指：隐藏属性,方法或实现细节的过程，仅对外公开接口。继承（Inheritance）的概念是指：在父类和子类之间存在着继承和扩展关系；子类继承父类的属性和方法的同时，子类还可以扩展出新的属性和方法，并且还可以覆盖父类中方法的实现方式。其实无论是Ja还是其他的面向对象的编程语言，这两个概念以及由此衍生出的其他的诸如方法的重载、重写等概念几乎大同小异。不过由这两个概念我们可以看出，子类只不过是在父类的基础上进行的扩充。用数学的语言来说，是对关系的非最小化闭包运算（扯远了）。如此说来，父类中封装好的对外界隐藏的东西，子类继承过来后当然也应该是对外界隐藏。而子类中扩充的东西是否对外界隐藏，完全由子类说了算。就算是C++中的public继承方式，其子类继承了父类后，父类中的私有方法还是不能被外界直接调用。这样看的话，继承怎么就破坏了类的封装性了呢？难不成子类继承了父类的东西后，父类中的私有属性和方法在子类中就全成了公开的了，可以被所有的人随便调用了？我想这既不是我们这些开发人员想看到的，同样也不是那些编程语言的设计者们所希望的。

其实说到底，继承在适当的时候使用，会极大地加快开发速度和提高开发的效率。其他任何的东西也是如此（比如设计模式中的flyweight模式）。但是，继承破坏类的封装性的说法，我不敢认同。

有哪些JAVA设计模式呢？

Factory

Singleton(单态)

Builder

Prototype(原型)

Flyweight

Bridge6. Memento.. 9在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。

Decorator(油漆工)

Comite(组合)

Adapter(适配器)

Proxy()

Facade(外观 总管 Mar)

=Ext.getDom(elDom);Visitor

Observer

ja常用的的设计模式和开发模式都有哪些

设计模式是不分语言的;前辈们总结出来的设计模式分:3种类型及23种模式:

设计模式主要分三个类型:创建型、结构型和行为型。

其中创建型有Ext.fly('elId').toggleClass('myCls');：

一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点

二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。

四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。

五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。

行为型有：

六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。

七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。

八、Template Mod，模板方法：定义一个作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。

九、Command，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的作。

十、State，状态模式：允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。

十一、Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以于使用它们的客户。

十二、China of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系

十三}}、Mediator，中介者模式：用一个中介对象封装一些列的对象交互。

十四、Visitor，访问者模式：表示一个作用于某对象结构中的各元素的作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新作。

十五、Interpreter，解释器模式：给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

十六、Memento，备忘录模式：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。

结构型有：

十七、Comite，组合模式：将对象组合成树形结构以表示部分整体的关系，Comite使得用户对单个对象和组合对象的使用具有一致性。

十八、Facade，外观模式：为子系统中的一组接口提供一致的界面，fa?ade提供了一高层接口，这个接口使得子系统更容易使用。

二十、Adapter,适配器模式：将一类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作那些类可以一起工作。

二十一、Decrator，装饰模式：动态地给一个对象增加一些额外的职责，就增加的功能来说，Decorator模式相比生成子类更加灵活。

二十二、Bridge，桥模式：将抽象部分与它的实现部分相分离，使他们可以的变化。

二十三、Flyweight，享元模式

开发模式:

JAVA中的开发模式:

MVC是一个很常用的程序开发设计模式，M-Model（模型）：封装应用程序的状态；V-View（视图）：表示用户界面；C-Controller（）：对用户的输入作出反应，创建并设置模型。

ja什么是结构型模式

public static synchronized Singleton getInstance() {

结构型模式是描述如何将类对象结合在一起，形成一个更大的结构，结1.单例模式（有的书上说叫单态模式其实都一样）构模式描述两种不同的东西：类与类的实例。故可以分为类结构模式和对象结构模式。

在GoF设计模式中，结构型模式有：

1.适配器模式 Adapter

2.桥接模式 Bridge

3.组合模式 Comite

4.装饰模式 Decorator

5.外观模式 Facade

6.享元模式 Flyweight

7.模式 Proxy

什么是单例设计模式

注：享元模式（Flyweight

单例模式确保一个类只有一个实例，自行提供这个实例并向整个系统提供这个实例。

特点：

1，一个类只能有一个实例

2，自己创建这个实例

3，整个系统都要使用这个实例

例: 在下面的对象图中，有一个单例对象，而客户甲、客户乙 和客户丙是单例对象的三个客户对象。可以看到，所有的客户对象共享一个单例对象。而且从单例对象到自身的连接线可以看出，单例对象持有对自己的引用。

Singleton模式主要作用是保证在Ja应用程序中，一个类Class只有一个实例存在。在很多作中，比如建立目录 数据库连接都需要这样的单线程作。一些资源管理器常常设计成单例模式。

外部资源：譬如每台计算机可以有若干个打印机，但只能有一个Printer Spooler,以避免两个打印作业同时输出到打印机中。每台计算机可以有若干个通信端口，系统应当集中管理这些通信端口，以避免一个通信端口被两个请求同时调用。内部资源，譬如，大多数的软件都有一个（甚至多个）属性文件存放系统配置。这样的系统应当由一个对象来管理这些属性文件。

一个例子：Windows 回收站。

在整个视窗系统中，回收站只能有一个实例，整个系统都使用这个惟一的实例，而且回收站自行提供自己的实例。因此，回收站是单例模式的应用。

两种形式：

1，饿汉式单例类

public class Singleton {

private Singleton(){}

在自己内部定义自己一个实例，是不是很奇怪？

注意这是private 只供内部调用

private static Singleton instance = new Singleton();

这里提供了一个供外部访问本class的静态方法，可以直接访问

public static Singleton getInstance() {

return instance;

2，懒汉式单例类

public class Singleton {

private static Singleton instance = null;

这个方法比上面有所改进，不用每次都进行生成对象，只是次

使用时生成实例，提高了效率！

if (instance==null)

return instance; }

}第二中形式是lazy initialization，也就是说次调用时初始Singleton，以后就不用再生成了。...>>

问题二：将一个类设计成单例设计模式，需要哪些步骤 单例模式（Singleton Pattern）是一个比较简单的模式。

定义：

确保某一个类只有一个实例，而且自动实例化并向整个系统提供这个实例。

通用类图：

Singleton类称为单例类，通过使用private的构造函数确保了在一个应用中只产生一个实例，并且是自行实例化的。

/

线程安全的单例模式

饿汉式单例

@author Administrator

/

public class Singleton {

private static final Singleton singleton = new Singleton();

限制产生多个对象

private Singleton() {

}通过该方法获得实例对象

public static Singleton getSingleton() {

return singleton;

}类中其他方法尽量是static

public static void doSoming() {

单例模式的优点：

由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显了。

由于单例模式只生成一个实例，所以减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用驻留内存的方式来解决。

单例模式可以避免对资源的多重占用，例如一个写文件动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写作。

单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

单例模式的缺点：

单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。

单例模式对测试是不利的。在并行开发环境中，如果单例模式没有完成，是不能进行测试的，没有接口也不能用mock的方式虚拟一个对象。

单例模式的使用场景：

要求生成序列号的环境；

在整个项目中需要一个共享访问点或共享数据，例如一个Web页面上的计数器，可以不用把每次刷新都记录到数据库中，使用单例模式保持计数器的值，并确保是线程安全的；

创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源；

需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式（当然，也可以直接声明为static的方式）。

单例模式的注意事项：

1. 在高并 况下，请注意单例模式的线程同步问题。

/

懒汉式单例

@author Administrator

/

public class Singleton2 {

private static Singleton2 singleton = null;

限制产生多个对象

private Singleton2() {

}......>>

问题三：什么是单例模式 ja模式之单例模式：

单例模式确保一个类只有一个实例，自行提供这个实例并向整个系统提供这个实例。

特点：

1，一个类只能有一个实例

2，自己创建这个实例

3，整个系统都要使用这个实例

例: 在下面的对象图中，有一个单例对象，而客户甲、客户乙 和客户丙是单例对象的三个客户对象。可以看到，所有的客户对象共享一个单例对象。而且从单例对象到自身的连接线可以看出，单例对象持有对自己的引用。

Singleton模式主要作用是保证在Ja应用程序中，一个类Class只有一个实例存在。在很多作中，比如建立目录 数据库连接都需要这样的单线程作。一些资源管理器常常设计成单例模式。

外部资源：譬如每台计算机可以有若干个打印机，但只能有一个Printer Spooler,以避免两个打印作业同时输出到打印机中。每台计算机可以有若干个通信端口，系统应当集中管理这些通信端口，以避免一个通信端口被两个请求同时调用。内部资源，譬如，大多数的软件都有一个（甚至多个）属性文件存放系统配置。这样的系统应当由一个对象来管理这些属性文件。

一个例子：Windows 回收站。

在整个视窗系统中，回哗站只能有一个实例，整个系统都使用这个惟一的实例，而且回收站自行提供自己的实例。因此，回收站是单例模式的应用。

两种形式：

1，饿汉式单例类

public class Singleton {

private Singleton(){}

在自己内部定义自己一个实例，是不是很奇怪？

注意这是private 只供内部调用

private static Singleton instance = new Singleton();

这里提供了一个供外部访问本class的静态方法，可以直接访问

public static Singleton getInstance() {

return instance;

2，懒汉式单例类

public class Singleton {

private static Singleton instance = null;

这个方法比上面有所改进，不用每次都进行生成对象，只是次

使用时生成实例，提高了效率！

if (instance==null)

return instance; }

}第二中形式是lazy initialization，也就是说次调用时初始Singleton，以后就不用再生成了。...>>

问题四：请问，Ja中，单例设计模式是个什么意思，优势何在。 单例模式：保证一个类在使用过程中，只有一个实例。优势就是他的作用，这个类永远只有一个实例。

步骤： 1. 将该类的构造方式私有；

2. 在内部实例化一个该类的实例；

3. 提供接口给外部访问。

public clasintece ClassesDao{s SingletonDemo {

private SingletonDemo (){}; 1.

private static SingletonDemo mInstance = new SingletonDemo(); 2.

public static SingletonDemo getInstance(){ 3.

return mInstance;

问题五：将一个类做成单例是什么意思 单例模式（Singleton Pattern）是一个比较简单的模式。 定义： 确保某一个类只有一个实例，而且自动实例化并向整个系统提供这个实例。

问题六：单例模式的好处和缺点？为什么要用单例模式？详细才给分 1 单例模式 只允许创建一个对象，因此节省内存，加快对象访问速度，因此对象需要被公用的场合适合使用，如多个模块使用同一个数据源连接对象等等

2 单例的缺点 就是不适用于变化的对象，如果同一弗型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。

用单例模式，就是在适用其优点的状态下使用。

问题七：什么是Ja单例模式啊？ Singleton模式主要作用是保证在Ja应用程序中，一个类Class只有一个实例存在。

一般Singleton模式通常有几种种形式:

种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。

public class Singleton {

private Singleton(){}

在自己内部定义自己一个实例，是不是很奇怪？

注意这是private 只供内部调用

private static Singleton instance = new Singleton();

这里提供了一个供外部访问本class的静态方法，可以直接访问

public static Singleton getInstance() {

return instance;

第二种形式:

public class Singleton {

private static Singleton instance = null;

这个方法比上面有所改进，不用每次都进行生成对象，只是次

使用时生成实例，提高了效率！

if (instance==null)

return instance; }

}其他形式:

定义一个类，它的构造函数为private的，所有方法为static的。

一般认为种形式要更加安全些

这些都是Ja中的基础知识，如果你想更加详细的了解相关知识，你可以到秒秒学的网站上找到相应的课程。

引用《软件秘笈-设计模式那点事》书籍：

按照目的来分，设计模式可以分为创建型模式、结构型模式和行为型模式。

创建型模式用来处理对象的创建过程；结构型模式用来处理类或者对象的组合；行为型模式用来对类或对象怎样交互和怎样分配职责进行描述。

创建型模式用来处理对象的创建过程，主要包含以下5种设计模式：

? 工厂方法模式（Factory Mod Pattern）

? 抽象工厂模式（Abstract Factory Pattern）

? 原型模式（Prototype Pattern）

? 单例模式（Singleton Pattern）

结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式：

? 适配器模式（Adapter Pattern）

? 桥接模式（Bridge Pattern）

? 组合模式（ite Pattern）

? 装饰者模式（Decorator Pattern）

? 外观模式（Facade Pattern）

? 享元模式（Flyweight Pattern）

? 模式（Proxy Pattern）

行为型模式用来对类或对象怎样交互和怎样分配职责进行描述，主要包含以下11种设计模式：

? 链模式（Chain of Responsibility Pattern）

? 命令模式（mand Pattern）

? 解释器模式（Interpreter Pattern）

? 迭代器模式（Iterator Pattern）

? 中介者模式（Mediator Pattern）

? 备忘录模式（Memento Pattern）

? 观察者模式（Observer Pattern）

? 状态模式（State Pattern）

? 策略模式（Strategy Pattern）

? 访问者模式（Visitor Pattern）

单例模式实现1：

public class Singleton {

类共享实例对象

private static Singleton singleton = null;

私有构造方法

private Singleton() {

System.out.println(-- this is Singleton!!!);

}获得单例方法

public synchronized static Singleton getInstance() {

判断 共享对象是否为null ，如何为null则new一个新对象

if (singleton == null) {

singleton = new Singleton();

}return singleton;

单例模式实现2：

public class Singleton {

类共享实例对象 实例化

private s......>>

问题九：23种设计模式中哪些最重要 总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

其实还有两类：并发型模式和线程池模式。

最常用的是：工厂模式，单例模式，建造者模式，模式。

问题十：设计模式中，属于结构型模式的有哪些 设计模式主要分三个类型:创建型、结构型和行为型。

其中创建型有：

一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点

二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。

四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。

五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。

行为型有：

六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。

七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。

八、Template Mod，模板方法：定义一个作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。

九、mand，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的作。

十、State，状态模式：允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。

十一、Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以于使用它们的客户。

十二、China of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系

十三、Mediator，中介者模式：用一个中介对象封装一些列的对象交互。

十四、Visitor，访问者模式：表示一个作用于某对象结构中的各元素的作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新作。

十五、Interpreter，解释器模式：给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

十六、Memento，备忘录模式：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。

结构型有：

十七、ite，组合模式：将对象组合成树形结构以表示部分整体的关系，ite使得用户对单个对象和组合对象的使用具有一致性。

十八、Facade，外观模式：为子系统中的一组接口提供一致的界面，fa?ade提供了一高层接口，这个接口使得子系统更容易使用。

二十、Adapter,适配器模式：将一类的接口转换成客户希望的另外一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作那些类可以一起工作。

二十一、Decrator，装饰模式：动态地给一个对象增加一些额外的职责，就增加的功能来说，Decorator模式相比生成子类更加灵活。

二十二、Bridge，桥模式：将抽象部分与它的实现部分......>>

python面试一般问什么常用设计模式

十九、Proxy，模式：为其他对象提供一种以控制对这个对象的访问

1.设计模式介绍

instance＝new Singleton();

设计模式（Design Patterns）

——可复用面向对象软件的基础

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。

2. 设计模式分类

经典的《设计模式》一书归纳出23种设计模式，这23种模式又可归为，创建型、结构型和行为型3大类

2.1．创建型模式

前面讲过，化的分工越来越细，自然在软件设计方面也是如此，因此对象的创建和对象的使用分开也就成为了必然趋势。因为对象的创建会消耗掉系统的很多资源，所以单独对对象的创建进行研究，从而能够高效地创建对象就是创建型模式要探讨的问题。这里有6个具体的创建型模式可供研究，它们分别是：

简单工厂模式（Simple Factory）；

工厂方法模式（Factory Mod）；

抽象工厂模式（Abstract Factory）；

原型模式（Prototype）；

单例模式（Singleton）。

说明：严格来说，简单工厂模式不是GoF总结出来的23种设计模式之一。

2.2 结构型模式

在解决了对象的创建问题之后，对象的组成以及对象之间的依赖关系就成了开发人员关注的焦点，因为如何设计对象的结构、继承和依赖关系会影响到后续程序的维护性、代码的健壮性、耦合性等。对象结构的设计很容易体现出设计人员水平的高低，这里有7个具体的结构型模式可供研究，它们分别是：

外观模式（Facade）；

模式（Proxy）；

装饰模式（Decorator）；

桥模式（Bridge）；

组合模式（Comite）；

享元模式（Flyweight）

2.3 行为型模式

在对象的结构和对象的创建问题都解决了之后，就剩下对象的行为问题了，如果对象的行为设计的好，那么对象的行为就会更清晰，它们之间的协作效率就会提高，这里有11个具体的行为型模式可供研究，它们分别是：

模板方法模式（Template Mod）；

观察者模式（Observer）；

状态模式（State）；

策略模式（Strategy）；

职责链模式（Chain of Responsibility）；

命令模式（Command）；

访问者模式（Visitor）；

调停者模式（Mediator）；

备忘录模式（Memento）；

迭代器模式（Iterator）；

解释器模式（Interpreter）。

3. 设计模式的六大原则

1、开闭原则（Open Close Principle）

开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科

3、依赖倒转原则（Dependence Inversion Principle）

这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Intece Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

5、迪米特法则（最少知道原则）（Demeter Principle）

为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对。

原则是尽量使用合成/聚合的方式，而不是使用继承。

C# ，线程和DLL，相关书籍

}10.replaceClass

visual C#2005 文件IO与数据存储秘诀，一本关于C#设计中十分实用的参考书，其中有涉及到线程的，而且都是很实用的技巧，还有文件，数据库等等其他十分有用的东西，可当作参考书用。置于dll，其实组件非常好用，C#调用com组件或组件非常简单，直接添加引用，再加个using就行了。所以dll的编写与调用其实没那么复杂

看乐思公司出的书比6、合成复用原则（Comite Reuse Principle）较好

c# 都是用 提供的类库，先熟悉类库就OK了 在是一些特性方面，其实就是比MFC更生层次的封装，最终还是靠调用win32 API实现的

看看田轰川的视屏讲座吧

挺好的

Ja中常用的设计模式有哪些?请详细说明一下工厂模式。

代码模式(CodingPattern)

该模式主要目的是使内存中保持1个对象

2.工厂模式

该模式主要功能是统一提供实例对象的引用。看下面的例子：

public class Factory{

public ClassesDao getClassesDao(){

ClassesDao cd = new ClassesDaoImpl();

return cd;

public String getClassesName();

}class ClassesDaoImpl implements ClassesDao {

public String getClassesName(){

System.out.println("A班");

class test

{public static void main(String[] args){

Factory f = new Factory();

f.getClassesDao().getClassesName();

这个是最简单的例子了，就是通过工厂方法通过接口获取对象的引用

该模式其实就是说，一个对象的组成可能有很多其他的对象一起组成的，比如说，一个对象的实现非常复杂，有很多的属性，而这些属性又是其他对象的引用，可能这些对象的引用又包括很多的对象引用。封装这些复杂性，就可以使用建造模式。

4.门面模式

这个模式个人感觉像是Serv层的一个翻版。比如Dao我们定义了很多持久化方法，我们通过Serv层将Dao的原子方法组成业务逻辑，再通过方法向上层提供服务。门面模式道理其实是一样的。

这个模式是将行为的抽象，百度去搜搜吧，很多的，而且有很多完整的文档，不过有的资源需要积分。。即当有几个类有相似的方法，将其中通用的部分都提取出来，从而使扩展更容易。

软件架构模式基本概念及三者区别

5.策略模式

在做软件架构设计时,根据不同的抽象层次可分为三种不同层次的模式：架构模式(Pattern)、设计模式(DesignPattern)、代码模式(CodingPattern)。

架构模式是一个系统的高层次策略，涉及到大尺度的组件以及整体性质和力学。架构模式的好坏可以影响到总体布局和框架性结构。设计模式是中等尺度的结构策略。这些中等尺度的结构实现了一些大尺度组件的行为和它们之间的关系。模式的好坏不会影响到系统的总体布局和总体框架。设计模式定义出子系统或组件的微观结构。代码模式（或成例）是特定的范例和与特定语言有关的编程技巧。代码模式的好坏会影响到一个中等尺度组件的内部、外部的结构或行为的底层细节，但不会影响到一个部件或子系统的中等尺度的结构，更不会影响到系统的总体布局和大尺度框架。

架构模式(Pattern)

一个架构模式描述软件系统里的基本的结构组织或纲要。架构模式提供一些事先定义好的子系统，指定它们的，并给出把它们组织在一起的法则和指南。称之为系统模式。

6?1MVC模式,一个架构模式常常可以分解成很多个设计模式的联合使用。MVC模式常常包括调停者（Mediator）模式、策略（Strategy）模式、合成（Comite）模式、观察者（Observer）模式等。

6?1Layers（分层）模式，有时也称Tiers模式

6?1Blackboard（黑板）模式

6?1Broker（中介）模式

6?Process（分散过程）模式

6?（微核）模式

架构模式常常划分成如下的几种：

一、模块结构(FromMudtoStructure)型。帮助架构师将系统合理划分，避免形成一个对象的海洋。包括Layers（分层）模式、Blackboard（黑板）模式、Pipes/Filters（管道/过滤器）模式等。

二、分散系统（DistributedSystems）型。为分散式系统提供完整的架构设计，包括像Broker（中介）模式等。

三、人机互动（InteractiveSystems）型，支持包含有人机互动介面的系统的架构设计，例子包括MVC（Model-View-Controller）模式、PAC（-Abstraction-Control）模式等。

四、AdaptableSystems型，支持应用系统适应技术的变化、软件功能需求的变化。如Reflection（反射）模式、Microkernel（微核）模式等。

设计模式(DesignPattern)

一个设计模式提供一种提炼子系统或软件系统中的组件的，或者它们之间的关系的纲要设计。设计模式描述普遍存在的在相互通讯的组件中重复出现的结构，这种结构解决在一定的背景中的具有一般性的设计问题。

设计模式常常划分成不同的种类，常见的种类有：

创建型设计模式，如工厂方法（FactoryMod）模式、抽象工厂（AbstractFactory）模式、原型（Prototype）模式、单例（Singleton）模式，建造（Builder）模式等

结构型设计模式，如合成（Comite）模式、装饰（Decorator）模式、（Proxy）模式、享元（Flyweight）模式、门面（Facade）模式、桥梁（Bridge）模式等

行为型模式，如模版方法（TemplateMod）模式、观察者（Observer）模式、迭代子（Iterator）模式、链（Chainof）模式、备忘录（Memento）模式、命令（Command）模式、状态（State）模式、访问者（Visitor）模式等等。

以上是三种经典类型，实际上还有很多其他的类型，比如Fundamental型、Partition型，Relation型等等。设计模式在特定的编程语言中实现的时候，常常会用到代码模式。比如单例（Singleton）模式的实现常常涉及到双检锁（Double-CheckLocking）模式等。

代码模? 建造者模式（Builder Pattern）式（或成例）是较低层次的模式，并与编程语言密切相关。代码模式描述怎样利用一个特定的编程语言的特点来实现一个组件的某些特定的方面或关系。

较为的代码模式的例子包括双检锁（Double-CheckLocking）模式等