对23种模式的理解跟举例

设计模式:
程式设计是思维具体化的一种方式，是思考如何解决问题的过程，
设计模式是在解决问题的过程中，一些良好思路的经验集成
GOF提出来的23种模式 4个人创建出来的.他们总结的(其中一个是junit测试的作者)

讲模式的4个特点:
讲特点, 比如说:单例模式 就是只有一个单例.共用一个实例
生活的例子. 地球,中国..关键是看类的定义.
好处.
设计模式写出来.
公司那些地方用
-------------------------------------------------------------------------------------------------------
单例模式 Singleton(
确保一个类就只有一个单例.
特点: 私有构造器,拥有一个静态的获取实例的方法,静态的实例
解决的问题:共用一个实例
饿汉式单例(类加载的时候就加载好了),
懒汉式单例(调用的时候才去加载))
例子:国家中只有一个中国.同一个QQ不能双开. 企业商标.吉尼斯世界纪录.NBA,CBA,诺贝尔文学奖,奥运会,世界杯
jdk: * java.lang.Runtime#getRuntime()
* java.awt.Toolkit#getDefaultToolkit()
* java.awt.GraphicsEnvironment#getLocalGraphicsEnvironment()
* java.awt.Desktop#getDesktop()
项目:spring的beanFactory,数据库连接.
-------------------------------------------------------------------------------------------------------
工厂模式 Factory:
主要是为创建对象,提供过渡接口,以便将创建对象的具体过程隐藏起来.
结构: 对外提供一个方法,根据传入的对象得到不同的实例.
提高了灵活性.
安全,可扩展性强.修改起来也方便.
举例: 去饭店吃饭.只要点个菜就可以了.不需要知道怎么去做的.去肯德基吃东西.汽车厂造汽车.
jdk: * java.lang.Proxy#newProxyInstance()
* java.lang.Object#toString()
* java.lang.Class#newInstance()
* java.lang.reflect.Array#newInstance()
* java.lang.reflect.Constructor#newInstance()
* java.lang.Boolean#valueOf(String)
* java.lang.Class#forName()
项目:从DBUtil里面得到Connection对象.
-------------------------------------------------------------------------------------------------------
模版模式 template:
父类定义流程.子类去具体实现
结构:父类去定义抽象的方法,子类去实现这个方法,然后父类去调用.
好处:
减少重复的代码.
防止调用出错
举例: 就像是给你一个模具,你只需要照着做出来.不需要知道是干什么的.
父类像是老板.子类像是员工,项目经理把文档做出来,然后员工去实现
jdk: * java.util.Collections#sort()
* java.io.InputStream#skip()
* java.io.InputStream#read()
* java.util.AbstractList#indexOf()
项目:Dao层的实现.Service层的实现.
-------------------------------------------------------------------------------------------------------
外观模式 Facade:
(外观模式（Facade pattern）为子系统提供了一个更高层次、更简单的接口，
从而降低了子系统的复杂度和依赖。这使得子系统更易于使用和管理。)
结构:可以将一系列复杂的类包装成一个简单的封闭接口(类)
封装具体的实现类.外面调用的时候只能看到它们的调用类.
好处:
1.提供复杂系统的访问接口,简化了系统接口调用.
2.对外部程序来说,无论内部子系统如何变化都不需要更改,实现一定程度的解耦合.
举例: 去饭店吃饭.只需要和服务员说就可以了,不需要和厨师打交道. 或者通过客服买东西. 去杂货店买东西,老板会拿给你
jdk:java.lang.Class
项目: Connection,PreparedStatement,ResultSet 直接使用DButil封装起来
--------------------------------------------------------------------------------------------------------
适配器模式 adapter: (组合优于继承)
使原本不兼容,不能一起运行的类.现在可以一起运行.
对象适配器: 通过 被适配的类 创建的实例,调用 被适配类的方法
类适配器, (会造成 接口污染 继承了多余的方法)
举例: 电脑的usb接口,手机的充电接口,或者听歌的接口. 如果耳机不匹配,就需要买个一个转换的东西(适配器),
电脑和内存卡.必须要读卡器. 手机的充电器.
jdk中:# java.io.InputStreamReader(InputStream)
# java.io.OutputStreamWriter(OutputStream)
项目中: Query方法,update,add,delete等数据库操作方法.
------------------------------------------------------------------------------------------------------------
策略模式 strategy:
定义了一系列的解决方案(算法),并将每一个解决方案(算法)封装起来.
而且使它们还可以相互替换,
策略模式让解决方案(算法)的变化不会影响到使用解决方案(算法)的客户.
好处:
降低了类和类之间的耦合度,使系统更灵活,并易于扩展
举例: (一般是有多种解决方案的)
吃饭, 可以在家里吃,饭店吃,餐馆吃,朋友家吃,学校吃,公司吃. 只要能吃饭就可以了
去某个地方. 坐车去,走路,跑步,做的士,做小轿车, 只要能达到目的就可以了.
jdk:* java.util.Comparator#compare()
interceptor,
* javax.servlet.http.HttpServlet
* javax.servlet.Filter#doFilter()
项目中: 持久层的实现, 可以选择 jdbc,hibernate,ibatis
页面: 可以使用jsp,ext,html,struts1 tag,strust2 tag,等等.
数据库 : 可以选择多种数据库, mysql,oracle,sqlserver
-----------------------------------------------------------------------------------------------------------
命令模式 command:
命令模式的关键就是把请求封装成为命令对象，然后就可以对这个对象进行一系列的处理了
比如把对象的每一个行为封装成一个对象,实现了代码的单一职责.分工明细
好处:降低了类与类之间的耦合度.使系统更灵活,并易于扩展.
举例:电脑上的键盘.按一下就会执行一个命令. 电视机的遥控器.
客户去饭店点菜. 每一个厨师都会做不同的菜. 客户只管下菜单.
老板下命令.
jdk: * java.lang.Runnable
* javax.swing.Action
项目:事务,线程的start().
-------------------------------------------------------------------------------------------------------
代理模式 proxy:
Proxy代理模式是一种结构型设计模式，主要解决的问题是：在直接访问对象时带来的问题，
:给某一对象提供代理对象,并由代理对象控制具体对象的引用.
分为:
①静态代理
一个具体对象只能对应一个代理对象.
如果新增了一个具体对象,就要相应的添加代理对象.
需要对代码进行更改.增加了代码的复杂性,
②动态代理:

举例:明星的经纪人,老板的秘书,买电脑去找代理商,送信.和朋友打电话等
jdk:java.lang.reflect.Proxy
项目: spring的aop,
动态代理代码:
# 自己定义类,去实现代理接口
#
# import java.lang.reflect.InvocationHandler;
# import java.lang.reflect.Method;
# import java.lang.reflect.Proxy;
# //动态代理类只能代理接口，代理类都需要实现InvocationHandler类，实现invoke方法。
该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类
# public class DynamicProxy implements InvocationHandler{
# private Object object;
# //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。
# //Proxy.newProxyInstance的第三个参数是表明这些被拦截的方法执行时需要执行哪个InvocationHandler的invoke方法
# public Object bindRelation(Object object){
# this.object = object;
# return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(),this);
# }
# //拦截关联的这个实现类的方法被调用时将被执行
# public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
# System.out.println("Welcome");
# Object result = method.invoke(object, args);
# return result;
}
}


--------------------------------------------解释...........
Proxy.newProxyInstance(Service.class.getClassLoader(),Service.class.getInterfaces(),ih);
*ih,如果是在DynamicProxy里面就可以直接使用this代替.
*解析一下上面的代码:
*java.lang.reflet.proxy.newProxyInstance方法根据传入的
*(接口类型*)obj.getClass().getInterfaces()动态构造出一个(代理实例返回*).
* 这也说明为什么动态代理实现要求其所代理的对象一定
* (*要至少实现一个接口).因这个代理类实例是在运行时从内存中动态构造出它的实现传入的所有接口.
*
* public Object invoke(Object proxy,Method method,Object[] args)throws Throwable{
* //oObject是传入的Class的实例. 通过cla.newInstance()得到的,而不是这个proxy
* result = method.invoke(originalObject,args)
* }
*
* InvocationHandler.invoke方法将在代理类的方法被条用之前调用,
* 通过这个方法,我们可以在被代理类方法调用的前后进行一些处理,
* 在上述方法中,InvocationHandler.invoke方法的参数中传递了当前被调用的方法Method.
* 被调用的方法的参数args,通过method.invoke方法调用被代理类的原始方法实现,
* 这样就可以在被代理类的方法调用前后写入任何想要进行的操作.
*


测试类:
# public class TestDynamicProxy {
# public static void main(String[] args){
# HelloWorld helloWorld = new HelloWorldImpl();
# DynamicProxy dp = new DynamicProxy();
# //在这里绑定的是HelloWorld,也就是HelloWorld是被代理接口。所以绑定关系时，需要传递一个HelloWorld的实现类的实例化对象。
# HelloWorld helloWorld1 = (HelloWorld)dp.bindRelation(helloWorld);
# helloWorld1.print();
# helloWorld1.say();
#
# //helloWorld2将不被拦截
# HelloWorld helloWorld2 = new HelloWorldImpl();
# helloWorld2.print();
# helloWorld2.say();
#
# }
# }
动态代理与普通的代理相比较，最大的好处是接口中声明的所有方法都被转移到一个集中的方法中处理（invoke），
这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。

动态代理类只能代理接口，代理类都需要实现InvocationHandler类，实现invoke方法。
该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类
-------------------------------------------------------------------------------------------------------
责任链模式 strategy:
使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。
将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
优点:降低了耦合、提高了灵活性
抽象处理者角色（Handler）：它定义了一个处理请求的接口。当然对于链子的不同实现，也可以在这个角色中实现后继链。
具体处理者角色（Concrete Handler）：实现抽象角色中定义的接口，并处理它所负责的请求。如果不能处理则访问它的后继者。
举例:拨打10086的电话,普通话请按1....,取款,先输入密码.....生产食品,接力棒,去医院看病等等
做项目,首先是项目经理做文档.然后再是设计需求,然后分配给员工,再由员工去编写.测试,完成后交给客户.
jdk: * java.util.Comparator#compare()
* javax.servlet.http.HttpServlet
* javax.servlet.Filter#doFilter()
项目: 过滤器,servle,拦截器
---------------------------------------------------------------------------------------------------------
观察者模式 observer:
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。
这个主题对象在状态上发生变化时，会通知所有观察者对象，让他们能够自动更新自己
举例:
留校观察的学生.天气预报.日本地震了,全世界都报道了.
小时候把别人打伤了.告诉家长,然后家长去解决.
jdk:# java.util.EventListener
# javax.servlet.http.HttpSessionBindingListener
# javax.servlet.http.HttpSessionAttributeListener
项目: jsp页面的Onsubmit,onchange
--------------------------------------------------------------------------------------------------------
抽象工厂模式 AbstractFactory:
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
生活的例子:
汽车制造厂.更换皮肤.饭店的菜谱,上面有不同类型的菜.不同类型的菜里面又有许多菜.
康师傅工厂,卖矿泉水,饮料,方便面.
jdk:* java.util.Calendar#getInstance()
* java.util.Arrays#asList()
* java.util.ResourceBundle#getBundle()
* java.sql.DriverManager#getConnection()
* java.sql.Connection#createStatement()
* java.sql.Statement#executeQuery()
项目:dom,sax解析xml文件.
-----------------------------------------------------------------------------------------------------------
状态模式 state:
: 不同的状态,不同的行为;或者说,每个状态有着相应的行为.

举例:一个人的生老病死,已婚,未婚,离婚,热恋等..人的表情喜怒哀乐.
公司倒闭,关门,经营.发展. 银行卡的正常状态,挂失,锁定.废弃. QQ的在线,隐身,离线等.
jdk:java.util.Iterator,
项目中:一般用来if,esle if,else这些地方. 取代if,或者switch,Servlet
---------------------------------------------------------------------------------
组合模式(解决树形结构) composite:
定义:将对象以树形结构组织起来,以达成"部分--整体"的层次结构,使得客户端对当前对象和组
合对象的使用具有一致性.
优点:层次结构清晰.
举例:
学校里面有校长,主任,班主任,老师,学生.
公司里面有Boss,总经理,部门经理,组长,员工.
一棵树:树根,枝干,树叶.
jdk:# java.util.Map#putAll(Map)
# java.util.List#addAll(Collection)
# java.util.Set#addAll(Collection)
项目: 定义多个观察者,在被观察者里面定义了观察者的集合,当被观察者改变的时候,通知观察者.观察者自己进行更新
dom,sax解析xml文件.得到一个document对象

sturts2 ：代理、观察、责任、命令、模板

db：门面、工厂、适配器、策略、单例