设计模式学习笔记

1、工厂模式

1、 目的：为了实现平滑插入，闭——开原则。在不修改原代码的基础上添加新的功能！

2、 内容：抽象工厂、实体工厂、抽象产品、实体产品。在添加新功能的时候，只要创建新的实体产品就可以，然后用工程生成产品。

3、 如Connection是一个工厂，它可以产生Statement，PreparedStatement。

4、 我当时做的实例就是， 将菜单项配置在XML文件中，然后读取XML文件，用Class.forName()去生成菜单。因此添加新的菜单项只要在XML中配置就可以啦。

2、抽象工厂

1、和工厂模式差不多。可以认为一样。

3、原型模式

1、目的：当一个工具类构造十分复杂的时候，例如它的构造要设置相当多的参数的时候，用Clone方法克隆出一个类要比构造一个类快的多。因此原型模式就是给一个原型，然后克隆出新的对象。

2、用Object对象的Clone方法，因此返回新对象的时候用此方法返回getInstance()

3、注意浅克隆和深克隆，默认的克隆方法之克隆基本数据类型，引用类型不会被克隆，因此如果原型中包含引用类型，则必须复写Clone方法，进行深克隆。

4、单例模式

1、最简单的一种模式，也是最熟悉的模式之一。

2、目的：一个类我只希望它只实例化一个对象就足够，大多数为工具类，且消耗资源比较多，如数据库连接对象，网络连接对象，所引用的资源文件等。

3、private构造方法，保证是单例。

4、static的本身对象域。

5、饥汉单例：static域直接new出来。

6、饿汉单例：判断static域是否为空，空则new非空则直接返回。

7、多线程下的单例模式：

public class SingletonTest
{
private SingletonTest()
{
}


private static class Inner   //私有的静态内部类
{
static SingletonTest singletonTest = new SingletonTest();
}


public static SingletonTest getInstance()
{
return Inner.singletonTest;
}
}

5、建造者模式

1.        目的：用于生成某一个类的不同实例，即属性不同，一个构造器去构造一种实例。

2.        一般适用于，所构造的对象是经过多步构造成功的，可以值得去新建一个类去构造此对象。

3.        每一个建造者只负责构造一种实例，如套餐，套餐是一个类，但其属性有很多，而且不同，因此可以为每一个套餐建立一个构造器，分步骤去构造。

4.        构造器一定含有一个被构造对象的实例。Has a

5.        实例：StringBuilder类，它应该含有一个String实例，而且构造这个String对象一般都不是一步就完事的，要经过多次的append、insert、delete等操作，最终构造出String对象。

结构性模式：

6、适配器模式

1、   就像电源适配器一样，电压有110v的、220v的、380v的，但我有个适配器，就可以得到5v的，而且两段的电压都不用改变。

2、   适配器就是这样，在不改变原有的类的基础上，实现两个接口之间的转化。符合闭——开原则。当然这两个要转化的类是有联系的，不可能将两个完全没有联系的接口相互转化。

3、   实现方式：用对象组合的方式以目标接口包装被适配的类或接口。新建一个适配器类，次类实现目标接口，含有一个被适配的类的对象。可以认为要被转化的对象是输入，而目标接口是输出，这个新建的类就是适配器。

4、   它不会破坏已经存在的类，实现平滑的将两个类转化。

5、   实例：ActionListener是目标接口，ActionAdapter是适配器。

7、桥接模式

1、  目的：为容易改变的两端搭桥，只要此桥不变不论两端如何变化，他们都可以配合工作。

2、  实现方式：用接口搭桥，例如，一个操作类的抽象类中含有一个被操作类的接口，这样只要是实现了这个接口的所有被操作类对象，都可以传进来被我操作。因此被操作类不论怎么变都可以。同时，操作类也可以通过继承这个抽象类改变自己的内容，因此不论两端如何变化，只要实现了接口，就有了桥，就可以合作。

3、  聚合的关联程度小于继承的关联程度，即hasa < is a

4、  适配器是为了实现两个接口或类的转化

5、  桥接模式是为了适应桥两端的变化。

6、  实例：java中的流，只要用了流，不论两端是文件还是网络连接，都可以工作。

8、组合模式

1、  目的：适合整体与部分、超级组合对象——组合对象——简单对象类型的继承关系

2、  这些对象都继承于一个同一个父类接口，只不过是简单对象只实现其中的一小部分功能，组合对象次之，超级组合对象实现大部分功能。

3、  实例：Container（超级组合对象）、JComponent（组合对象）、JPanel（组合对象）、JButton、JLable（组合对象）。他们都有共同的父类JComponent，但JButton、JLable里不能再添加对象，而JPanel可以。

再如：父类staff类，子类有CEO、Manager、worker,都有公共父类Staff但Manager可以管理Manager和worker，但worker不可以添加他能管理的人员。

9、装饰者模式

1、  目的：为了实现不改变原有的类，同时扩展其功能，办法就是用装饰者将其包装起来，然后装饰者完成添加的功能。

2、  符合闭——开原则，面向抽象、接口隔离。

3、  初始的被装饰者一般为接口或抽象类，然后每一层装饰者都含有被装饰者的引用，装饰者对被装饰者内的抽象方法进行新的改造，在保留以前的功能上添加新的功能，就是先调用父类的此方法，然后添加自己的新功能。Super.do(),   doSomething….

4、  实例：Java IO里的包装类，InputStream是个接口，其功能较少，但经过

new FilerReader（new InputStreamReader（inputStream））这样层层包装之后，就可以获得很强大的新的功能。

10、外观模式

 

1、  目的：为了减少子系统之间的相互调用，相互访问，减小子系统之间的耦合度，可以使用外观模式。

2、  外观模式为子系统提供一个一般化的功能接口，当然实现这个接口的实现类中要含有要调用子系统的引用，在它所覆盖的接口方法中调用子系统的方法去处理。因此外界只看到外观类而看不到子系统，同时外观模式还可以将复杂的调用次序封装在一个接口方法中。用户只要调用此方法，并不用为子系统的方法调用次序烦恼。

3、  例子：做菜

a)    自己按着菜谱做，必须按菜谱的顺序调用每一个方法

b)    下馆子，下单之后所以的任务都交给厨师去做。我只要调用一下厨师就可以。

4、  外观模式为子系统创建一个高层接口，来统一调用子系统，使子系统更加容易使用，使用户无需和子系统直接交互。

11、享元模式

1.     目的：对于要创建大量的细颗粒度对象，而每个对象基本相同，或差别很小，就可以使用享元模式，各个对象共享元对象，因此开销比较小，如：棋子对象。

2.     享元模式中的元对象包含了对象中相同的部分以及不同的部分，相同的部分在构造元对象的工厂中设置，并且用单例只存储一份，而不同的部分要在外部设置并存储。

3.     组成：抽象元对象、元对象、工厂（只设置元对象的相同部分）、外部对象（设置元对象的不同部分）。

4.     有点：用于构造大量细颗粒度对象，同时区分存储相同的和不同的属性。

12、代理模式

1.     目的：为了减少类之间的直接访问，代理对象处理请求对象发出的请求，之后委托给真实对象去处理请求，代理对象隔离了客户端和真实处理对象，并为两者之间搭建了桥梁。

2.     代理对象用聚合代替了继承（代理对象中含有真实对象的引用），降低了耦合度。

3.     代理模式和Java中的代理Proxy不同，Java中的代理是指在运行时想调用某个接口中的某个方法，但不能实例化接口对象，此时，可以通过代理类来访问调用接口中的方法，将任务全部交给代理类：

Java.lang.reflect.InvocationHander中有：

Invoke(Object proxy , Method me, Object args[]) 方法

行为型模式

13、责任链模式

1.        目的：适用于多个对象处理一个请求，具体由哪个对象去处理还不确定，只有在运行时才能确定，同一个消息的处理对象可能动态的增加或减少。

2.        实现了开闭原则，所以责任链中的处理对象增加或减少不影响客户端的代码。

3.        组成：每个处理节点都含有下一个节点的引用，因此组成一条链，请求在这条链上传递，直到有人去处理他。有抽象处理接口或抽象类，和具体处理对象组成。

4.        JDK中的Exception，就是try 和cache

14、命令模式

1.        目的：将请求与实现解耦，在两者之间加入中间者，使请求与实现没有直接联系。

2.        符合开闭原则，两者之间不论增加请求或是处理对象，请求这还是调用命令对象，却可以将扩展打开。

3.        面向抽象、接口编程：就是最终传入的对象都是接口，即最终的引用都是接口类型的， 因为如果使用具体的类，当我增加新功能时必须修改这个类，但如果用接口的话，由于有接口回调，所以增加新的功能只需增加一个处理类实现传入的接口，新的功能，在这个类中体现，但由于用了回调，因此这个新添的类可以传入旧的类，作为引用。因此实现了开闭原则——对扩展打开，对修改关闭。

4.        命令模式适合做日志，事务处理等。

5.        它将请求封装成一个对象。

6.        组成：抽象命令角色，具体命令，请求者，接受者。请求者含有抽象命令角色的引用，而后者含有接受对象的引用。

7.        例如：我有自己熟悉的邮局，我将信交给邮局，而邮局又有收信人的引用，可以将信送送给收信人。　

15、解释器模式

1.        目的：比较单一，就是解释执行语言，实现开闭原则，扩展新的语法很容易，增加一个新的类就可以。但运用的地方少。功能比较单一。

2.        组成：抽象表达式（所有表达式实现这个接口，含有一个方法interpret()解释）、终结（元表达式、或具体表达式）——最简单的表达式，可以直接执行。非终结表达式（符合表达式，里面含有终结表达式）、上下文角色（提供全局信息）

3.        JDK中的java.text.Format类就是

16、迭代器模式

1.        目的：希望不用关心软件内部某个集合的内部实现细节（如：用数组、List、set），而可以按照统一的模式访问这个集合。同时如果我修改了具体实现，如用数组代替了List，如果使用了迭代器模式，则就不用修改任何代码，而且迭代器以上的各个组件甚至不知道这样的修改。

2.        实现了开闭原则。内部变化后，只要增加一个实现了特定接口的类就可以。

3.        适用于访问一个集合对象，但又不想暴露集合内部实现的情况。

4.        为了遍历不同集合而提供一个统一的接口。

5.        组成：迭代器接口、具体的迭代器、容器接口、具体容器。

6.        ＪＤＫ中：java.util.iterator

17、中介者模式(多人聊天室中的服务器)

1.        目的：用一个中介者对象来封装一系列对象之间的交互。使多个对象不用显示的含有对其他对象的引用，降低对象之间的耦合度。

2.        适用于：将一对多的对象连接关系转化为一对一的依赖关系。但也有缺陷。如对象非常多时不太好用。

3.        组成：对象、中介者、加上两者之间的接口。

4.        JDK中：ButtonGroup，Button

18、备忘录模式

5.        目的：将信息保存到备忘录中，然后可以用备忘录恢复到以前的状态。

6.        组成：发起人（需要保存备忘录）、备忘录、管理者。

7.        JDK：java.util.Date中的long型属性，就是一个备忘录，可以用这个long型来恢复时间状态。

19、观察者模式

1.        目的：一个对象改变时：可以通知其他的对象，然后可以做出回应。

2.        实现了开闭原则。

3.        组成：抽象主题角色接口Isubject，具体主题角色Subject，抽象观察者模式IObserver，具体观察者Observer。Subject中addObserver()，remove()，notifyAllObserver()方法。

同时含有一个List<Observer>,每一个Observer中有一个Update()方法。

在notifyAllObserver中遍历list然后调用list.get(i).update();