《java设计模式.wps》由会员分享，可在线阅读，更多相关《java设计模式.wps（19页珍藏版）》请在taowenge.com淘文阁网|工程机械CAD图纸|机械工程制图|CAD装配图下载|SolidWorks_CaTia_CAD_UG_PROE_设计图分享下载上搜索。
1、编程一些设计模式（java 为主）小叙几种简单的设计模式 自从学习编程这一段时间以来（以 java 为主），懂得了一些设计模式，也是 java中最常用的一些模式。最经典的设计模式总的有24种，我用一些通俗的话语夹杂专业术语叙述一些我所学过的设计模式，也算是对自己的一个鞭策，此文仅供参考交流，包括单例模式、策略模式、工厂模式、代理模式、装饰模式、观察者模式。1.单例（单态）模式(singleton)单例模式是我学习程序以来第一个触碰到的设计模式，首先这个模式的初衷是在程序的运行时（runtime）当且仅当只存在一个这样的实例（对象），以减少空间利用率，程序的运行效率。单例模式的经典结构是：/一个
2、对本类的静态引用Private staticSingleton singleton;/一个私有的构造方法PrivateSingleton()/一个创建类的静态方法Public staticSingleton newInstance();单例模式有两种比较经典的写法：package com.shangguanrs.singleton;public class Singleton1 /一个对本类的引用 private static Singleton1 singleton=null;/一个私有的构造方法 private Singleton1()/调用对象的静态方法 public static sy
3、nchronized Singleton1 newInstance()if(singleton=null)return new Singleton1();return singleton;另一种方式：package com.shangguanrs.singleton;public class Singleton2 /一个对本类的引用 private static Singleton2 singleton=new Singleton2();/一个私有的构造方法 private Singleton2()/调用对象的静态方法 public static Singleton2 newInstance(
4、)return singleton;可以比较这两个方法，第一种写法明显要逊色于第二种，首先第一种写法的newInstance 方法每次调用的时候需要判断这个类的这个实例是否存在，并且如果有多线程调用的情况下就有可能出现两个实例，原因是这样的，如果第一个线程 thread1执行这个方法到 if 条件里面的时候，还没有执行条件体里面的任何代码，第二个线程 thread2的优先级或者其他种种原因导致 thread1的对象锁被剥夺，直到 thread2执行完成。有这种情况存在，当这个类刚刚初始化，thread2执行的时候因为引用指向一个 null，所以会导致 thread2也执行 if 里面的代码，所
5、以有一个新的对象出来，而当 thread2释放时，thread1重新获得对象锁，继续往下执行，这样以后，两个对象出来了，这就不符合单例模式的初衷了，所以我们需要加上关键字:synchronized 关键字，但是 synchronized 是粗力度的同步，会降低程序的执行效率。而第二种写法简单明了，执行起来也是符合单例模式的。2.策略模式(strategy)策略模式是一个比较简单的模式，在 java 的集合里面体现的比较明显，策略模式的初衷是对一组算法的封装，并且动态选择使用。策略模式经典结构：1.抽象的角色封装一些方法2.具体的角色去实现这些方法3.环境角色调用这些方法package com.
6、shangguanrs.strategy;/*抽象角色*author Administrator*/public interface Strategy public float calculate(float a,float b)throws Exception;/*具体角色*author Administrator*/class AddCalculate implements Strategy Override public float calculate(float a,float b)return a+b;class SubstractCalculate implements Strat
7、egy Override public float calculate(float a,float b)return a-b;class MultiplyCalculate implements Strategy Override public float calculate(float a,float b)return a*b;class DevideCalculate implements Strategy Override public float calculate(float a,float b)throws Exception if(b=0)throw new Exception(
8、除数不能为0);return a/b;/*环境角色*author Administrator*/public class Environment private Strategy strategy;public Environment(Strategy strategy)this.strategy=strategy;public float calculate(float a,float b)throws Exception return this.strategy.calculate(a,b);public Strategy getStrategy()return strategy;publ
9、ic void setStrategy(Strategy strategy)this.strategy=strategy;/*客户端调用*author Administrator*/public class Client public static void main(String args)throws Exception AddCalculate ac=new AddCalculate();Environment e=new Environment(ac);float result=e.calculate(1,2);DevideCalculate dc=new DevideCalculat
10、e();e.setStrategy(dc);result=e.calculate(1,2);System.out.println(result);总结一下，策略模式的优点是可以动态调用所有的算法，缺点是暴露无遗，首先，有多少个算法就要多少个子类需要被建立出来，增加了子类的数量，第二就是客户端必须要知道有多少个子类。这种缺点工厂模式是可以在一定程度上减轻的，所以看下面的工厂模式。3.工厂模式(factory)工厂模式是一个比较复杂的模式，工厂模式的初衷是能动态的调用指定的类，因为这个模式与很多现行流行的框架结合使用，比如说 Hibernate、Spring 等框架的重要组成部分，其中在 Spri
11、ng 的核心思想 IOC（inverse ofcontrol）反转控制中扮演着核心角色，工厂模式使用到了一个 java 里面很重要的概念，那就是反射（Reflect），要是没有反射，在 java 中，会让很多框架就此覆灭，至少三大框架 SSH 是不会存在了。所以说反射是一个很重要的概念，奇怪的是开发人员可以不必掌握，也是很多开发人员必须掌握的概念，甚至精通：问题就在于你想处于哪个层次。工厂模式有三种模式：1）.简单工厂2）.工厂方法3）.抽象工厂我对第一种简单工厂比较感知，对后面那两种不感冒，所以对于后面的那两种模式我就以反射一并盖之。简单工厂：factory 是一个与需要类无关的类，负责生产
12、需要的类。简单工厂就简单的阐述一下：首先需要接口第二，需要接口的实现类，实现具体的方法然后需要一个工厂类，有一个工厂方法，里面用 ifelse ifelse 或者 switchcase 分别调用综上所述，知道这个工厂模式能得到我们想要的类，不过在于灵活性和可扩展性方面是大打折扣。例如：还需要再添加一个继承接口的类，那就需要改动 factory里面的方法，给一个程序或者是框架带来无限的麻烦。如果有反射，那一切就 OK了。步骤和简单工厂没有什么区别，只是动作却是重点在于 factory 这个类。工厂模式：/*汽车总接口*author Administrator*/public interface
13、Car public void run();/*实现Car接口的类*author Administrator*/public class BMW implements Car private String name;private int price;public BMW()public BMW(String name,int price)this.name=name;this.price=price;Override public void run()System.out.println(this.name+:宝马汽车跑跑跑);private void engine()System.out.
14、println(宝马凤凰牌发动机);public String getName()return name;public void setName(String name)this.name=name;public int getPrice()return price;public void setPrice(int price)this.price=price;/*实现Car接口的类*author Administrator*/public class DasAuto implements Car private String name;private int price;public Das
15、Auto()public DasAuto(String name,int price)this.name=name;this.price=price;Override public void run()System.out.println(this.name+:大众汽车跑跑跑);public String getName()return name;public void setName(String name)this.name=name;public int getPrice()return price;public void setPrice(int price)this.price=pr
16、ice;/*工厂类*author Administrator*/public class ObjectFactory /*param objectName类的全称（包括包名）*param cTypes该类的构造方法的class类型 *param objs该类构造方法的实际参数 *return 返回一个类的对象 *throws Exception没有找到该类异常 */public static Object objectFactory(String objectName,ClasscTypes,Object objs)throws Exception /需要返回的实际实例 Object obje
17、ct=null;/找出该类的Class对象 Class classType=Class.forName(objectName);/判断通过哪一种构造方法新建实例 if(null=cTypes|cTypes.length=0)object=classType.newInstance();else Constructorcons=classType.getConstructor(cTypes);object=cons.newInstance(objs);return object;/*param object需要调用方法的实体类 *param methodName方法名称 *param cType
18、s方法参数类型 *param objs方法具体参数 *return 方法返回值 *throws Exception没有这个类异常，或者安全异常 */public static Object executeMethod(Object object,StringmethodName,Class cTypes,Object objs)throws Exception /返回值 Object obj=null;/方法对象 Method method=object.getClass().getDeclaredMethod(methodName,cTypes);/压制访问修饰符 method.setAcc
19、essible(true);/调用该方法 obj=method.invoke(object,objs);return obj;/*客户端调用*author Administrator*/public class Client public static void main(String args)throws Exception Car car=(Car)ObjectFactory.objectFactory(com.shangguanrs.myfactory.BMW,new ClassString.class,int.class,new Object宝马X1,540000);car.run(
20、);BMW bmw=(BMW)car;/调用私有方法 ObjectFactory.executeMethod(bmw,engine,new Class,new Object);总结：工厂模式是一个灵活性非常强悍的模式，被广泛的应用于各个框架以及程序中，我个人觉得如果您是一位 java 开发人员的话，必须要掌握反射和工厂模式。4.代理模式(proxy)代理模式是一个巧妙的模式，代理模式的初衷是为了在实现某个功能的前后穿插着做一些其他的事情，它类似于现实的一种情形，就像现在套房出租一样，把房间拿给代理商，通过代理商把房间出租，从而代理商可以在租房前后做手脚，获取相应的利润。在我们实际开发中，如果你
21、遇到过 spring 框架，你也就慢慢懂得了代理模式的强大之处，代理模式也就是 spring 框架两大基本思想的其中一个思想的核心概念,那就是 AOP（Aspect-oriented Programming）面向切面编程！所以要了解这个模式让我感觉势在必行。代理模式分为静态代理和动态代理，不过都离不开这三大基本步骤：1）.需要一个抽象类或者接口来统一真实角色和代理角色的行为动作2）.实现具体的真实角色，这个角色拥有真实的权利执行本方法，实现代理角色，调用真实角色的方法，实现真实角色的功能。3）.客户端与代理角色相互交互，完成真是角色的功能，以及客户所需。1）.package com.shang
22、guanrs.proxy;/*房主*author Administrator*/public interface HouseHolder public String doSomething(String name);真实角色package com.shangguanrs.proxy;/*真实角色*author Administrator*/public class RealHouseHolder implements HouseHolder Override public void doSomething(String name)System.out.println(房主租房给:+name);
23、2).1静态代理：/*静态代理类*author Administrator*/public class HouseHolderProxy implements HouseHolder /真实角色 private HouseHolder hh;/对真实角色赋值 public HouseHolderProxy(HouseHolder hh)this.hh=hh;/代理角色调用真实角色的方法，同时做自己的功能 Override public void doSomething(String name)System.out.println(房主我最多能帮你以500元租出去);hh.doSomething
24、(name);System.out.println(尊敬客户：+name+,我们决定以1000元每月的底价租给您);2).2动态代理类/*动态代理类*author Administrator*/public class ProxyHouseHolder implements InvocationHandler /真实角色 private Object object;/给真实角色赋值 public ProxyHouseHolder(Object object)this.object=object;/*invoke方法为自动调用方法,proxy为代理类，method为所调用方法对应的Method对
25、象 *args为所调用方法的参数 */Override public Object invoke(Object proxy,Method method,Objectargs)throws Throwable System.out.println(房主我最多能帮你以500元租出去);Object obj=method.invoke(this.object,args);System.out.println(尊敬客户：我们决定以1000元每月的底价租给您);return obj;3）.客户端调用/*客户端调用*author Administrator*/public class Client pub
26、lic static void main(String args)HouseHolder rh=new RealHouseHolder();/静态代理 HouseHolderProxy hhp=new HouseHolderProxy(rh);hhp.doSomething(小鸭子);/动态代理 ProxyHouseHolder phh=new ProxyHouseHolder(rh);HouseHolder hh=(HouseHolder)Proxy.newProxyInstance(rh.getClass().getClassLoader(),rh.getClass().getInterf
27、aces(),phh);hh.doSomething(小欣子);综上所述，动态代理类的灵活性确实要比静态代理类强多了，因为这个代理类不止可以代理这个类，任何只要你想要的都可以代理。但是关于动态代理的实现，确实会让刚刚学习的人摸不着头脑,因为看起来太离谱了,它看起来和公共接口没什么关联,实现的接口是一个比较陌生的 InvocationHandler，关于这些您如果不是很了解，只能自己去查 API。我尽量阐述清楚其中的步骤，然后与 API 相结合应该是能很好的理解其中的概念，不过要是不太了解反射，还是先去学习什么是反射吧。步骤如下：首先真实角色（RealHouseHolder）以及动态角色(Pro
28、xyHouseHolder)都生成出来，然后通过 java 给我们提供的 Proxy 类的一个静态方法newProxyInstance接受三个参数,第一个参数是提供一个类装载器，第二个参数是提供真实对象所实现的接口，这样以后，代理类使用这些接口，也就相当于自己实现了上述接口，拥有了相应的功能，第三个参数为实现了 InvocationHandler 接口的类，自然是动态角色的一个实例传入，然后会自动调用 ProxyHouseHolder 类里面的 invoke 方法，通过 method 对象实现对相应的方法进行调用，完成代理功能。5.装饰模式（decorator）装饰模式是一个了不起的模式，装饰
29、模式的初衷是为了功能的相互封装，如 A 有 A 的功能，B 分装了 A 就有了 AB 的功能，C 分装了 A 之后就有 AC 的功能，如果 B 分装了 A，C 封装了 B，那么 C 就有 ABC 的功能，至少在 java 里面是这么说，因为它帮助 Java 在 I/O 模块中灵活使用少数的类，做了同样或者更多的事情。可以说不了解装饰模式的话，你永远都无法灵活应用 I/O 这一模块，一个稍微复杂一点的嵌套就会让你头大，比如说：BufferedWriter bw=new BufferedWriter(newOutputStreamWriter(new FileOutputStream(“C:/bs
30、.txt”);这 是一个典型的装饰模式，你不懂装饰模式你就不知道为什么要这么嵌套，为什么能这么嵌套。装饰模式的灵活性远不止这些，我们可以设想一下，要是没有这个模式，那么 Java 写 I/O 就需要至少不下100个类，大大增加了其中的难度，所以装饰模式也是必须要学会的一个经典模式。装饰模式的组成部分：1）.公共接口2）.多个实现组件 具体代码：package com.shangguanrs.decorator;/*组件接口*author Administrator*/public interface Conponent public void doSomething();package com
31、.shangguanrs.decorator;/*具体实现类*author Administrator*/public class ConcreateConponent implements Conponent Override public void doSomething()System.out.println(do A);package com.shangguanrs.decorator;/*包装类*author Administrator*/public class ConponentConcreate1 implements Conponent private Conponent c
32、;public ConponentConcreate1(Conponent c)this.c=c;Override public void doSomething()/TODO Auto-generatedmethod stub c.doSomething();this.doOtherThing();public void doOtherThing()System.out.println(do B);package com.shangguanrs.decorator;/*包装类*author Administrator*/public class ConponentConcreate2 imp
33、lements Conponent private Conponent c;public ConponentConcreate2(Conponent c)this.c=c;Override public void doSomething()/TODO Auto-generatedmethod stub c.doSomething();this.doOtherThing();public void doOtherThing()System.out.println(do C);package com.shangguanrs.decorator;/*调用类*author Administrator*
34、/public class Test public static void main(String args)Conponent c1=new ConcreateConponent();Conponent c2=new ConponentConcreate1(c1);Conponent c3=new ConponentConcreate2(c2);c3.doSomething();看 完 这 个 调 用 类 再 去 看 这 个：BufferedWriter bw=new BufferedWriter(newOutputStreamWriter(new FileOutputStream(“C:/
35、bs.txt”);应 该会有些启示，要是没有那就没得办法了。只要理解装饰模式，可以说，你的 I/O就是没问题了，就是能不能熟悉 API 的问题。6.观察者模式（observer）观察者模式在 Java 的 GUI 中起着承上启下的作用，观察者模式的初衷就是被观察者发生了任何事情，观察者都能马上知道，就像现实生活中的女孩子，此时，她正在路上走，因为夏天，她穿的有点露，所以她受到了很多男孩子的关注，然后有几个男孩子认识了她，知道了她的联系方式，女孩说：今天我好开心呀，所有男的都会在空间里面或者短信里面看到她开心的心情。突然之间，那个女孩觉得有一个男的太丑了，所以把联系方式都删了，然后发了一条说说或
36、者短信说：我很不开心，然后除了被删除的那个男生，其他男生都能收到相应的信息。这就是一个观察者，一个被观察者。经典的观察者模式。组成部分：1）.观察者2）.被观察者 具体实现：package com.shangguanrs.observer;/*观察者*author Administrator*/public interface Watcher public void notifyWatcher(String str);/*被观察者*author Administrator*/public interface Watched public void addWatcher(Watcher watc
37、her);public void removeWatcher(Watcher watcher);public void notifyWatcher(String str);/*观察者的具体实现*author Administrator*/public class ConcreateWatcher implements Watcher Override public void notifyWatcher(String str)System.out.println(str);/*被观察者的具体实现*author Administrator*/public class ConcreateWatche
38、red implements Watched /用集合存放观察者 private List watchers=new ArrayList();/*添加观察者 */Override public void addWatcher(Watcher watcher)watchers.add(watcher);/*移除观察者 */Override public void removeWatcher(Watcher watcher)/TODO Auto-generatedmethod stub watchers.remove(watcher);/*通知观察者 */Override public void
39、notifyWatcher(String str)/TODO Auto-generatedmethod stub for(Watcher w:watchers)w.notifyWatcher(str);/*调用类*author Administrator*/public class Test public static void main(String args)Watched girl=new ConcreateWatchered();Watcher boy1=new ConcreateWatcher();Watcher boy2=new ConcreateWatcher();Watcher boy3=new ConcreateWatcher();girl.addWatcher(boy1);girl.addWatcher(boy2);girl.addWatcher(boy3);girl.notifyWatcher(我很开心哦!);girl.removeWatcher(boy3);girl.notifyWatcher(不开心);通过上面的代码，看到了熟悉的步骤，就像 GUI 里面添加一个按钮或者其他组件的时候，然后需要给按钮添加监听器，这是如此的吻合，不过 GUI 里面的实现要比这个复杂得多。