程序博客网 > mac右键手势

单例、观察者、代理、备忘录、工厂

来源：互联网 发布：mac右键手势 编辑：程序博客网 时间：2024/05/17 07:30

一、Singleton单例模式

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

1、饱汉模式，声明时就创建实例对象

[java] view plaincopyprint?
  1. public class Singleton1 {  
  2.     public static final Singleton1 instance = new Singleton1();  
  3.     private Singleton1(){  
  4.     }  
  5.     public static Singleton1 getInstance(){  
  6.         return instance;  
  7.     }  
  8. }  
2、饿汉单类模式即延迟初始化单类方式,一般认为饱汉模式要比饿汉模式更加安全。

[java] view plaincopyprint?
  1. public class Singleton2 {  
  2.     public static Singleton2 instance;  
  3.     private Singleton2(){  
  4.     }  
  5.     //延迟初始化的单类模式必须使用synchronized同步关键字，否则多线程情况下很容易产生多个实例对象  
  6.     public static synchronized Singleton2 getInstance(){  
  7.         if(null==instance){  
  8.             instance = new Singleton2();  
  9.         }  
  10.         return instance;  
  11.     }  
  12. }  
3、类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载

[java] view plaincopyprint?
  1. public class Singleton3 {  
  2.     private static class SingletonHolder {  
  3.         //静态初始化器，由JVM来保证线程安全  
  4.         private static Singleton3 instance = new Singleton3();  
  5.     }  
  6.     private Singleton3() {  
  7.     }  
  8.     public static Singleton3 getInstance() {  
  9.         return SingletonHolder.instance;  
  10.     }  
  11. }  
  12. //当getInstance方法第一次被调用的时候，它第一次读取SingletonHolder.instance，导致SingletonHolder类得到初始化；  
  13. //而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建Singleton的实例，由于是静态的域，  
  14. //因此只会被虚拟机在装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。  
  15. //这个模式的优势在于，getInstance方法并没有被同步，并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问成本。  
4、用枚举，最好的实现方式

[java] view plaincopyprint?
  1. public enum Singleton4 {  
  2.     INSTANCE{  
  3.         @Override  
  4.         public String doSomeThing() {  
  5.             return "单例类中的方法";  
  6.         }  
  7.     };  
  8.     public abstract String doSomeThing();  
  9. }  
二、Observer观察者设计模式

Observer观察者设计模式用于将对象的变化通知给感兴趣的用户。在Observer模式中的角色为主题（subject）与观察者（observer），
观察者订阅它感兴趣的主题，一个主题可以被多个观 察者订阅，当主题的状态发生变化时，
它必须通知（notify）所有订阅它的观察者，观察者检视主题的状态变化，并作出对应的动作

[java] view plaincopyprint?
  1. public class ObserverPattern {  
  2.     public static void main(String[] args) {  
  3.         Subject subject = new Subject();  
  4.         Observer1 obj1 = new Observer1();  
  5.         subject.addObserver(obj1);  
  6.         Observer2 obj2 = new Observer2();  
  7.         subject.addObserver(obj2);  
  8.         subject.change();  
  9.     }  
  10. }  
  11.   
  12. class Subject extends Observable{  
  13.     public void change(){  
  14.         setChanged();  
  15.         String message = "我是主题，我发生了变化";  
  16.         System.out.println(message);  
  17.         notifyObservers(message);  
  18.     }  
  19. }  
  20.   
  21. class Observer1 implements Observer {  
  22.     public void update(Observable arg0, Object arg1) {  
  23.         System.out.println(arg0+":观察者一收到了");  
  24.     }  
  25. }  
  26. class Observer2 implements Observer {  
  27.     public void update(Observable arg0, Object arg1) {  
  28.         System.out.println(arg0+":观察者二收到了");  
  29.     }  
  30. }  
输出结果：

我是主题，我发生了变化
com.hzb.observer.Subject@ca0b6:观察者二收到了
com.hzb.observer.Subject@ca0b6:观察者一收到了

三、Proxy代理设计模式

1、普通的代理

客户端程序->代理程序->目标程序

[java] view plaincopyprint?
  1. public class ProxyGeneral {  
  2.     public static void main(String[] args){    
  3.         //客户端调用代理程序    
  4.         ProxyBase p = new ProxyProgram();    
  5.         p.f();   
  6.     }   
  7. }  
  8.   
  9. //代理程序    
  10. class ProxyProgram implements ProxyBase{    
  11.     private ProxyBase target;    
  12.     public ProxyProgram(){    
  13.         //目标程序    
  14.         target = new Target();    
  15.     }    
  16.     public void f(){  
  17.         System.out.println("代理程序在调用目标程序前的处理");  
  18.         target.f();    
  19.         System.out.println("代理程序在调用目标程序后的处理");  
  20.     }     
  21. }    
  22.   
  23. <pre class="java" name="code">//目标接口  
  24. interface ProxyBase{    
  25.     public void f();    
  26. }  </pre>//目标程序  class Target implements ProxyBase{      public void f(){          System.out.println("Target.f()");      }   }    
//目标程序 class Target implements ProxyBase{ public void f(){ System.out.println("Target.f()"); } }
输出结果：
代理程序在调用目标程序前的处理
Target.f()
代理程序在调用目标程序后的处理
2、动态代理，java的动态代理只能针对接口进行动态代理，即要实现动态代理的类必须实现接口
[java] view plaincopyprint?
  1. public class ProxyDynamic {  
  2.     public static void main(String[] args){    
  3.         ITarget target = new TargetImpl();    
  4.         ProxyHandler handler = new ProxyHandler(target);    
  5.         //产生动态代理    
  6.         ITarget proxy = (ITarget)Proxy.newProxyInstance(ITarget.class.getClassLoader(), new Class[]{ITarget.class}, handler);    
  7.         proxy.f("arg参数");    
  8.         proxy.g();  
  9.     }    
  10. }  
  11.   
  12. //目标接口    
  13. interface ITarget{    
  14.     public void f(String s);   
  15.     public void g();  
  16. }    
  17.   
  18. //接口实现类，即被代理类（目标类）    
  19. class TargetImpl implements ITarget{    
  20.     public void f(String s){    
  21.         System.out.println("TargetImpl.f(), s=" + s);    
  22.     }  
  23.     public void g() {  
  24.         System.out.println("TargetImpl.g()");  
  25.           
  26.     }    
  27. }     
  28.   
  29. //动态代理处理类    
  30. class ProxyHandler implements InvocationHandler{    
  31.     private Object object;                
  32.     public ProxyHandler (Object obj) {        
  33.         this.object = obj;        
  34.     }        
  35.     public Object invoke(Object proxy, Method method, Object[] args){    
  36.         System.out.println("Before mothod:" + method);    
  37.         try {  
  38.             method.invoke(this.object, args);  
  39.         } catch (Exception e) {  
  40.             e.printStackTrace();  
  41.         }  
  42.         System.out.println("After mothod:" + method);    
  43.         return null;     
  44.     }    
  45. }    
输出结果：
Before mothod:public abstract void com.hzb.proxy.ITarget.f(java.lang.String)
TargetImpl.f(), s=arg参数
After mothod:public abstract void com.hzb.proxy.ITarget.f(java.lang.String)
Before mothod:public abstract void com.hzb.proxy.ITarget.g()
TargetImpl.g()
After mothod:public abstract void com.hzb.proxy.ITarget.g()
四、Memento备忘录设计模式
Memento备忘录设计模式是一个保存另外一个对象内部状态拷贝的对象，这样以后就可以将该对象恢复到以前保存的状态
Memento备忘录设计模式有以下3个重要角色：
Originator：需要保存内部状态的对象。
Caretaker：为Originator保存并恢复状态的对象。
Memento：存放Originator内部状态的对象。
[java] view plaincopyprint?
  1. public class MementoPattern {  
  2.   
  3.     public static void main(String[] args) {  
  4.         Originator originator = new Originator("State1");  
  5.         Caretaker caretaker = new Caretaker();  
  6.         caretaker.addMemento(originator.createMemento(originator.getState()));  
  7.         originator.setState("State2");  
  8.         String restore = caretaker.getMemento().getState();  
  9.         System.out.println("Current originator state=" + originator.getState()  
  10.                 + ",restore state=" + restore);  
  11.     }  
  12. }  
  13.   
  14. // Memento  
  15. class Memento {  
  16.     private String state;  
  17.   
  18.     public Memento(String state) {  
  19.         this.state = state;  
  20.     }  
  21.   
  22.     public String getState() {  
  23.         return state;  
  24.     }  
  25. }  
  26.   
  27. // Caretaker  
  28. class Caretaker {  
  29.     private Stack<Memento> mementos = new Stack<Memento>();  
  30.   
  31.     public void addMemento(Memento m) {  
  32.         mementos.push(m);  
  33.     }  
  34.   
  35.     public Memento getMemento() {  
  36.         if (!mementos.empty()) {  
  37.             return mementos.pop();  
  38.         }  
  39.         return null;  
  40.     }  
  41. }  
  42.   
  43. // Originator  
  44. class Originator {  
  45.     private String state;  
  46.   
  47.     public Originator(String state) {  
  48.         this.state = state;  
  49.     }  
  50.   
  51.     public void setState(String state) {  
  52.         this.state = state;  
  53.     }  
  54.   
  55.     public String getState() {  
  56.         return state;  
  57.     }  
  58.   
  59.     public Memento createMemento(String state) {  
  60.         return new Memento(state);  
  61.     }  
  62.   
  63. }  
输出结果：
Current originator state=State2,restore state=State1
五、工厂模式
1、简单工厂模式：又叫静态工厂模式，简单工厂只包括一个抽象产品类（该类可以是接口，也可以是具体的类），所有需要的产品类都是该抽象产品类的子类。简单工厂模式中工厂为具体产品工厂，产品为抽象产品，由工厂实例创建产品实例：
[java] view plaincopyprint?
  1. public class FactorySimple {  
  2.     public static void draw(Shape shape) {  
  3.         shape.draw();  
  4.     }  
  5.   
  6.     public static void main(String[] args) {  
  7.         try {  
  8.             draw(ShapeFactory.createShape("com.hzb.factory.Circle"));  
  9.             draw(ShapeFactory.createShape("com.hzb.factory.Rectangle"));  
  10.         } catch (Exception e) {  
  11.             // TODO Auto-generated catch block  
  12.             e.printStackTrace();  
  13.         }  
  14.   
  15.     }  
  16. }  
  17.   
  18. // 图形接口  
  19. interface Shape {  
  20.     public void draw();  
  21. }  
  22.   
  23. // 圆形  
  24. class Circle implements Shape {  
  25.     public void draw() {  
  26.         System.out.println("Circle is drawing");  
  27.     }  
  28. }  
  29.   
  30. // 矩形  
  31. class Rectangle implements Shape {  
  32.     public void draw() {  
  33.         System.out.println("Rectangle is drawing");  
  34.     }  
  35. }  
  36.   
  37. // 图形工厂  
  38. class ShapeFactory {  
  39.     public static Shape createShape(String name) throws InstantiationException,  
  40.             IllegalAccessException, ClassNotFoundException {  
  41.         // 使用java的反射机制来产生对象实例  
  42.         return (Shape) Class.forName(name).newInstance();  
  43.     }  
  44. }  
输出结果：
Circle is drawing
Rectangle is drawing
2、抽象工厂模式：抽象工厂模式中可以包括多个抽象产品类，每个抽象产品类可以产生出多个具体产品类，一个抽象工厂用于定义所需产品的组合形式，抽象工厂派生具体工厂类，这些具体工厂类就是简单工厂模式中的工厂类，具体工厂类负责具体产品实例的创建：
[java] view plaincopyprint?
  1. public class FactoryAbstract {  
  2.     public static void main(String[] args) {  
  3.         // 显示一套IOS皮肤  
  4.         Skin skin = new Skin(new IOSSkinFactory());  
  5.         skin.showSkin();  
  6.         // 换一套Android的皮肤  
  7.         skin.setSkinFactory(new AndroidSkinFactory());  
  8.         skin.showSkin();  
  9.     }  
  10. }  
  11.   
  12.   
  13. //软件皮肤类  
  14. class Skin {  
  15.     private SkinFactory skinFactory;  
  16.   
  17.     public Skin(SkinFactory factory) {  
  18.         setSkinFactory(factory);  
  19.     }  
  20.   
  21.     public void setSkinFactory(SkinFactory factory) {  
  22.         this.skinFactory = factory;  
  23.     }  
  24.   
  25.     public void showSkin() {  
  26.         System.out.println("Style=" + skinFactory.getStyle().showStyle()  
  27.                 + ", color=" + skinFactory.getColor().showColor());  
  28.     }  
  29. }  
  30.   
  31. //抽象皮肤工厂  
  32. interface SkinFactory {  
  33.     public Style getStyle();  
  34.   
  35.     public Color getColor();  
  36. }  
  37.   
  38. // IOS皮肤工厂  
  39. class IOSSkinFactory implements SkinFactory {  
  40.     public Style getStyle() {  
  41.         return new IOSStyle();  
  42.     }  
  43.   
  44.     public Color getColor() {  
  45.         return new IOSColor();  
  46.     }  
  47. }  
  48.   
  49. // Android皮肤工厂  
  50. class AndroidSkinFactory implements SkinFactory {  
  51.     public Style getStyle() {  
  52.         return new AndroidStyle();  
  53.     }  
  54.   
  55.     public Color getColor() {  
  56.         return new AndroidColor();  
  57.     }  
  58. }  
  59.   
  60.   
  61. // 软件Style  
  62. interface Style {  
  63.     public String showStyle();  
  64. }  
  65.   
  66. // IOS style  
  67. class IOSStyle implements Style {  
  68.     public String showStyle() {  
  69.         return "This is IOS style";  
  70.     }  
  71. }  
  72.   
  73. // Android style  
  74. class AndroidStyle implements Style {  
  75.     public String showStyle() {  
  76.         return "This is Android style";  
  77.     }  
  78. }  
  79.   
  80. // 软件Color  
  81. interface Color {  
  82.     public String showColor();  
  83. }  
  84.   
  85. // IOS color  
  86. class IOSColor implements Color {  
  87.     public String showColor() {  
  88.         return "This is IOS color";  
  89.     }  
  90. }  
  91.   
  92. // Android color  
  93. class AndroidColor implements Color {  
  94.     public String showColor() {  
  95.         return "This is Android color";  
  96.     }  
  97. }  
输出结果：
Style=This is IOS style, color=This is IOS color
Style=This is Android style, color=This is Android color
3、工厂方法模式：工厂方法中也只包含一个抽象产品类，抽象产品类可以派生出多个具体产品类。工厂方法定义一个用于创建产品的接口，让子类决定实例化哪一个类，使得类的实例化延迟到子类。
[java] view plaincopyprint?
  1. public class FactoryMethod {  
  2.     public static void main(String[] args) {  
  3.         CarFactory factory = new BenzCarFactory();  
  4.         ICar car = factory.createCar();  
  5.         car.run();  
  6.         factory = new BMWCarFactory();  
  7.         car = factory.createCar();  
  8.         car.run();  
  9.     }  
  10. }  
  11.   
  12.   
  13. //抽象汽车工厂  
  14. abstract class CarFactory {  
  15.     public abstract ICar createCar();  
  16. }  
  17.   
  18. //奔驰车工厂  
  19. class BenzCarFactory extends CarFactory {  
  20.     public ICar createCar() {  
  21.         return new BenzCar();  
  22.     }  
  23. }  
  24.   
  25. //宝马车工厂  
  26. class BMWCarFactory extends CarFactory {  
  27.     public ICar createCar() {  
  28.         return new BMWCar();  
  29.     }  
  30. }  
  31.   
  32. // 汽车接口  
  33. interface ICar {  
  34.     public void run();  
  35. }  
  36.   
  37. // 奔驰车  
  38. class BenzCar implements ICar {  
  39.     public void run() {  
  40.         System.out.println("Benz car run");  
  41.     }  
  42. }  
  43.   
  44. // 宝马车  
  45. class BMWCar implements ICar {  
  46.     public void run() {  
  47.         System.out.println("BMW car run");  
  48.     }  
  49. }  
输出结果：
Benz car run
BMW car run

工厂模式中，重要的是工厂类，而不是产品类。产品类可以是多种形式，多层继承或者是单个类都是可以的。
但要明确的，工厂模式的接口只会返回一种类型的实例，这是在设计产品类的时候需要注意的，最好是有父类或者共同实现的接口。
使用工厂模式，返回的实例一定是工厂创建的，而不是从其他对象中获取的。工厂模式返回的实例可以不是新创建的，
返回由工厂创建好的实例也是可以的。

三种工厂模式的区别：
简单工厂 ： 用来生产同一等级结构中的任意产品，对于增加新的产品，无能为力。
抽象工厂 ：用来生产不同产品族(由不同产品组合成的一套产品)的全部产品，对于增加新的产品，无能为力；支持增加产品族。
工厂方法 ：用来生产同一等级结构中的固定产品，支持增加任意产品。

备注：java设计模式的学习主要是参考一位牛人http://blog.csdn.net/chjttony和从网上查找到的学习资料，转载请注明出处。
                                             
        0        0           
	
				
		









 mac右键手势
    		mac右键手势



原创粉丝点击



		

热门IT博客


linux启动进入grublinux启动进入grub




搜狗输入法云计算360搜狗输入法云计算360




w7怎么切换网络连接




单身狗公仔淘宝




知道软件下载




知史以明鉴 查古以至今




直播源码下载




5g云网络wlxiu




手机啤酒软件




crazybaby安卓软件




手机打卡软件




ps4版辐射4捏脸数据




python ldap




钢结构设计软件下载




网络诈骗破案率




js空格用什么表示




csol mac




三维家软件




淘宝拍摄衣服怎么布光




淘宝王成勇培训靠谱吗



		

热门问题
    老师的惩罚
    人脸识别
    我在镇武司摸鱼那些年
    重生之率土为王
    我在大康的咸鱼生活
    盘龙之生命进化
    天生仙种
    凡人之先天五行
    春回大明朝
    姑娘不必设防，我是瞎子
    强哥9527
    实力主播强哥
    呆哥强推兰兰在线播放
    呆哥强推178
    呆哥强上新婚兰兰
    男主播强哥
    呆哥强上兰兰
    强啊霸哥什么梗
    强哥抓娃娃
    强哥小静餐厅
    实力男主播强哥
    学习强哥
    呆哥强推新品
    准夫妻小静强哥续出差
    主播强哥
    从强哥开始的万界称雄路
    强哥 雅思
    小静圣诞节强哥王导
    王牌战士强哥怎么连砍
    英雄无敌3强哥虐圣龙原理
    强哥烧烤
    呆哥新婚兰兰
    小静番外篇为强哥生孩子
    女朋友在工地给人玩强哥下
    我爷爷是迪拜首富 强哥9527
    强壮英文
    强壮的英文
    强壮英语
    强壮
    强壮的英语
    强壮拼音
    强壮反义词
    强壮的三叔
    强壮的拼音
    强壮近义词
    强壮造句
    强壮功
    身体强壮
    强壮的
    强壮的狗老公
    男主很强壮肉很多种田


	










程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里