Java程序的设计模式程序的设计说明.docx

上传人:b****4 文档编号:665025 上传时间:2022-10-11 格式:DOCX 页数:79 大小:542.31KB
下载 相关 举报
Java程序的设计模式程序的设计说明.docx_第1页
第1页 / 共79页
Java程序的设计模式程序的设计说明.docx_第2页
第2页 / 共79页
Java程序的设计模式程序的设计说明.docx_第3页
第3页 / 共79页
Java程序的设计模式程序的设计说明.docx_第4页
第4页 / 共79页
Java程序的设计模式程序的设计说明.docx_第5页
第5页 / 共79页
点击查看更多>>
下载资源
资源描述

Java程序的设计模式程序的设计说明.docx

《Java程序的设计模式程序的设计说明.docx》由会员分享,可在线阅读,更多相关《Java程序的设计模式程序的设计说明.docx(79页珍藏版)》请在冰豆网上搜索。

Java程序的设计模式程序的设计说明.docx

Java程序的设计模式程序的设计说明

Java设计模式

1.1创建型模式

AbstractFactory(抽象工厂)

FactoryMethod(工厂方法)

Singleton(单态模式)

Builder(建造者模式)

Prototype(原型模式)

1.2结构型模式

Adapter(适配器模式)

Bridge(桥接模式)

Composite(组合模式)

Decorator(装配模式)

Facade(外观模式)

Flyweight(享元模式)

Proxy(代理模式)

1.3行为型模式

ChainofResponsibility(责任链模式)

Command(命令模式)

Interpreter(解释器模式)

Iterator(迭代器模式)

Mediator(中介者模式)

Memento(备忘录模式)

Observer(观察者模式)

State(状态模式)

Strategy(策略模式)

TemplateMethod(模板方法)

Visitor(访问者模式)

ToneyChen的总结

Singleton设计模式

Singleton单类模式是最简单的设计模式,它的主要作用是保证在程序运行生命周期中,使用了单类模式的类只能有一个实例对象存在。

单类模式实现了类似C语言中全局变量的功能,单类模式常用于注册/查找的服务。

单类模式有两种实现方式:

饱汉模式和饿汉模式,如下:

饱汉单类模式例子代码:

[java]viewplaincopy

1.public class Singleton1{  

2.        //饱汉模式,声明时就创建实例对象  

3.    public static final Singleton1 instance = new Singleton1();  

4.    //单类模式的构造方法必须为private,以避免通过构造方法创建对象实例,  

5.        //并且必须显示声明构造方法,以防止使用默认构造方法  

6.    private Singleton1(){}  

7.        //单类模式必须对外提供获取实例对象的方法  

8.        public static Singleton1 geInstance(){  

9.           return instance;  

10.        }  

11.}  

饿汉单类模式即延迟初始化单类方式,例子代码:

[java]viewplaincopy

1.public class Singleton2{  

2.        //饿汉模式,声明时不创建实例对象  

3.    public static Singleton2 instance;  

4.    //单类模式的构造方法必须为private,以避免通过构造方法创建对象实例,  

5.        //并且必须显示声明构造方法,以防止使用默认构造方法  

6.    private Singleton2(){}  

7.        //单类模式必须对外提供获取实例对象的方法,延迟初始化的单类模式必须使用synchronized同步关键字,否则多线程情况下很容易产生多个实例对象  

8.        public static synchronized Singleton2 geInstance(){  

9.           //延迟初始化,只有当第一次使用时才创建对象实例  

10.           if(instance == null){  

11.               return new Singleton2();  

12.                }  

13.               return instance;  

14.        }  

15.}  

一般认为饱汉模式要比饿汉模式更加安全。

上面两种Singleton单类设计模式的实现方式都隐藏有如下的问题:

(1).虽然构造方式的访问修饰符为private,即除了自身以外其他任何类都无法调用,但是通过反射机制的setAccessiable(true)方法可以访问私有方法和属性。

因此Singleton单类模式必须考虑这种例外情况。

(2).对象序列化之后再反序列化时会生成新的对象,因此当Singleton单类模式类实现序列化接口时,必须显式声明所有的字段为tranisent。

在JDK1.5之后引入了Enum枚举,因此在JDK1.5之后Singleton单类模式又有了第三种实现方式,也是最好的实现方式,例子如下:

[java]viewplaincopy

1.public enum Singleton3{  

2.    INSTANCE{  

3.        public void doSomething(){  

4.            ……  

5.        }  

6.    };  

7.    public Singleton3 getInstance(){  

8.        return INSTANCE;  

9.    }  

10.    public abstract void doSomething();    

11.}  

Singleton单类模式中只有一个INSTANCE枚举元素,枚举可以保证真个程序生命周期中只有一个实例对象存在,同时还避免了常规Singleton单类模式private构造方法被反射调用和序列化问题。

注意:

java中除了构造方法可以创建对象实例以外,还可以通过克隆方法(clone()是Object中的protected方法)来创建对象,若单类对象直接继承自Object对象,则如果没有提供具体clone方法实现,则当调用克隆方法创建对象时,会抛出运行时的异常CloneNotSupportedException。

若单类类继承了实现克隆方法的类,则在单类类中必须覆盖父类的克隆方法,显式抛出异常CloneNotSupportedException。

另外,实现了单类模式的类不能再有派生子类,因为构造方式是私有的,子类无法调用父类构造方法,因此达到了Final的效果。

Proxy设计模式

Proxy代理设计模式是一种控制对象访问的设计模式,类似于网络代理,网络代理机制如下图:

Proxy代理设计模式机制如下:

客户端程序通过代理程序来访问真正的目标程序,代理程序对外隐藏了目标程序。

普通代理设计模式例子代码如下:

[java]viewplaincopy

1.interface ProxyBase{  

2.    public void f();  

3.    public void g();  

4.    public void h();  

5.}  

6.//代理程序  

7.class Proxy implement ProxyBase{  

8.    private ProxyBase implementation;  

9.    public Proxy(){  

10.        //目标程序  

11.        implementation = new ProxyImplementation();  

12.    }  

13.    public void f(){  

14.        implementation.f();  

15.    }  

16.    public void g(){  

17.        implementation.g();  

18.    }  

19.    public void h(){  

20.        implementation.h();  

21.    }  

22.}  

23.//目标程序  

24.class ProxyImplementation implements ProxyBase{  

25.    public void f(){  

26.        System.out.println(“ProxyImplementation.f()”);  

27.    }  

28.    public void g(){  

29.        System.out.println(“ProxyImplementation.g()”);  

30.    }  

31.    public void h(){  

32.        System.out.println(“ProxyImplementation.h()”);  

33.    }  

34.}  

35.//客户端程序调用代理  

36.public class ProxyDemo{  

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

38.        //客户端调用代理程序  

39.        Proxy p = new Proxy();  

40.        p.f();  

41.        p.g();  

42.        p.h();  

43.    }  

44.}  

从JDK1.3以后,java引入动态代理机制,java的动态代理只能针对接口进行动态代理,即要实现动态代理的类必须实现接口,CGLIB提供了针对类的动态代理功能。

JDK动态代理的例子如下:

[java]viewplaincopy

1.//代理接口  

2.interface Foo{  

3.    public void f(String s);  

4.    public void g(int i);  

5.    public void h(int i, String s);  

6.}  

7.//接口实现类,即被代理类  

8.class FooImpl implements Foo{  

9.    public void f(String s){  

10.        System.out.println(“FooImpl.f(), s=” + s);  

11.    }  

12.    public void g(int i) {  

13.        System.out.println(“FooImpl.g(), i=” + i);  

14.    }  

15.    public void h(int i, String s) {  

16.        System.out.println(“FooImpl.h(), i=” + i + “, s=” + s);  

17.    }  

18.}   

19.//动态代理处理类  

20.class ProxyHandler implements InvocationHandler{  

21.    //代理实现类  

22.    private Object delegate;     

展开阅读全文
相关资源
猜你喜欢
相关搜索

当前位置:首页 > 人文社科 > 法律资料

copyright@ 2008-2022 冰豆网网站版权所有

经营许可证编号:鄂ICP备2022015515号-1