zoukankan      html  css  js  c++  java

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

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

    分类： java 2014-07-03 10:13 364人阅读 评论(0) 收藏 举报

    一、Singleton单例模式

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

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

    [java] view plaincopy
    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. }  
    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    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 plaincopy
    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. }  
    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    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 plaincopy
    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方法并没有被同步，并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问成本。  
    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    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 plaincopy
    1. public enum Singleton4 {  
    2.     INSTANCE{  
    3.         @Override  
    4.         public String doSomeThing() {  
    5.             return "单例类中的方法";  
    6.         }  
    7.     };  
    8.     public abstract String doSomeThing();  
    9. }  
    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    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 plaincopy
    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. }  
    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    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 plaincopy
    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()");      }   }    
    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    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. <div class="dp-highlighter bg_java"><div class="bar"><div class="tools"><strong>[java]</strong> <a target=_blank title="view plain" class="ViewSource" href="http://blog.csdn.net/huangzebiao007/article/details/12880067#">view plain</a><a target=_blank title="copy" class="CopyToClipboard" href="http://blog.csdn.net/huangzebiao007/article/details/12880067#">copy</a><a target=_blank title="print" class="PrintSource" href="http://blog.csdn.net/huangzebiao007/article/details/12880067#">print</a><a target=_blank title="?" class="About" href="http://blog.csdn.net/huangzebiao007/article/details/12880067#">?</a></div></div><ol class="dp-j"><li class="alt"><span><span class="comment">//目标接口</span><span>  </span></span></li><li><span><span class="keyword">interface</span><span> ProxyBase{    </span></span></li><li class="alt"><span>    <span class="keyword">public</span><span> </span><span class="keyword">void</span><span> f();    </span></span></li><li><span>}    </span></li></ol></div><pre class="java" style="display: none;" name="code">//目标接口  
    24. interface ProxyBase{    
    25.     public void f();    
    26. }    
    //目标程序 class Target implements ProxyBase{ public void f(){ System.out.println("Target.f()"); } } 输出结果：

    代理程序在调用目标程序前的处理
    Target.f()
    代理程序在调用目标程序后的处理

    2、动态代理，java的动态代理只能针对接口进行动态代理，即要实现动态代理的类必须实现接口

    [java] view plaincopy
    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. }    
    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    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 plaincopy
    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. }  
    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    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 plaincopy
    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. }  
    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    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 plaincopy
    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. }  
    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    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 plaincopy
    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. }  
    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    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和从网上查找到的学习资料，转载请注明出处。
  • 相关阅读:
    求二叉树的层次遍历
    求二叉树的先序遍历
    数据结构实验之二叉树一：树的同构
    list列表操作
    汉罗塔问题
    expected an indented block
    42步进阶学习—让你成为优秀的Java大数据科学家！
    MVC 3.0错误 HTTP 404您正在查找的资源(或者它的一个依赖项)可能已被移除，或其名称已更改，或暂时不可用。请检查以下 URL 并确保其拼写正确。
    判断浏览器版本
    VisualStudio2012编辑器错误
  • 原文地址：https://www.cnblogs.com/firstdream/p/4733664.html
Copyright © 2011-2022 走看看