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

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

分类： 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

  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

  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

  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

  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. class Subject extends Observable{
  12. public void change(){
  13. setChanged();
  14. String message = "我是主题，我发生了变化";
  15. System.out.println(message);
  16. notifyObservers(message);
  17. }
  18. }
  19. class Observer1 implements Observer {
  20. public void update(Observable arg0, Object arg1) {
  21. System.out.println(arg0+":观察者一收到了");
  22. }
  23. }
  24. class Observer2 implements Observer {
  25. public void update(Observable arg0, Object arg1) {
  26. System.out.println(arg0+":观察者二收到了");
  27. }
  28. }

[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. class Subject extends Observable{
  12. public void change(){
  13. setChanged();
  14. String message = "我是主题，我发生了变化";
  15. System.out.println(message);
  16. notifyObservers(message);
  17. }
  18. }
  19. class Observer1 implements Observer {
  20. public void update(Observable arg0, Object arg1) {
  21. System.out.println(arg0+":观察者一收到了");
  22. }
  23. }
  24. class Observer2 implements Observer {
  25. public void update(Observable arg0, Object arg1) {
  26. System.out.println(arg0+":观察者二收到了");
  27. }
  28. }

输出结果：

我是主题，我发生了变化
com.hzb.observer.Subject[email protected]:观察者二收到了
[email protected]:观察者一收到了

三、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. class ProxyProgram implements ProxyBase{
  10. private ProxyBase target;
  11. public ProxyProgram(){
  12. //目标程序
  13. target = new Target();
  14. }
  15. public void f(){
  16. System.out.println("代理程序在调用目标程序前的处理");
  17. target.f();
  18. System.out.println("代理程序在调用目标程序后的处理");
  19. }
  20. }
  21. <pre class="java" name="code">//目标接口
  22. interface ProxyBase{
  23. public void f();
  24. }  </pre>//目标程序  class Target implements ProxyBase{      public void f(){          System.out.println("Target.f()");      }   }

[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. class ProxyProgram implements ProxyBase{
  10. private ProxyBase target;
  11. public ProxyProgram(){
  12. //目标程序
  13. target = new Target();
  14. }
  15. public void f(){
  16. System.out.println("代理程序在调用目标程序前的处理");
  17. target.f();
  18. System.out.println("代理程序在调用目标程序后的处理");
  19. }
  20. }
  21. <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">//目标接口
  22. interface ProxyBase{
  23. public void f();
  24. }

//目标程序 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. interface ITarget{
  13. public void f(String s);
  14. public void g();
  15. }
  16. //接口实现类，即被代理类（目标类）
  17. class TargetImpl implements ITarget{
  18. public void f(String s){
  19. System.out.println("TargetImpl.f(), s=" + s);
  20. }
  21. public void g() {
  22. System.out.println("TargetImpl.g()");
  23. }
  24. }
  25. //动态代理处理类
  26. class ProxyHandler implements InvocationHandler{
  27. private Object object;
  28. public ProxyHandler (Object obj) {
  29. this.object = obj;
  30. }
  31. public Object invoke(Object proxy, Method method, Object[] args){
  32. System.out.println("Before mothod:" + method);
  33. try {
  34. method.invoke(this.object, args);
  35. } catch (Exception e) {
  36. e.printStackTrace();
  37. }
  38. System.out.println("After mothod:" + method);
  39. return null;
  40. }
  41. }

[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. interface ITarget{
  13. public void f(String s);
  14. public void g();
  15. }
  16. //接口实现类，即被代理类（目标类）
  17. class TargetImpl implements ITarget{
  18. public void f(String s){
  19. System.out.println("TargetImpl.f(), s=" + s);
  20. }
  21. public void g() {
  22. System.out.println("TargetImpl.g()");
  23. }
  24. }
  25. //动态代理处理类
  26. class ProxyHandler implements InvocationHandler{
  27. private Object object;
  28. public ProxyHandler (Object obj) {
  29. this.object = obj;
  30. }
  31. public Object invoke(Object proxy, Method method, Object[] args){
  32. System.out.println("Before mothod:" + method);
  33. try {
  34. method.invoke(this.object, args);
  35. } catch (Exception e) {
  36. e.printStackTrace();
  37. }
  38. System.out.println("After mothod:" + method);
  39. return null;
  40. }
  41. }

输出结果：

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. public static void main(String[] args) {
  3. Originator originator = new Originator("State1");
  4. Caretaker caretaker = new Caretaker();
  5. caretaker.addMemento(originator.createMemento(originator.getState()));
  6. originator.setState("State2");
  7. String restore = caretaker.getMemento().getState();
  8. System.out.println("Current originator state=" + originator.getState()
  9. + ",restore state=" + restore);
  10. }
  11. }
  12. // Memento
  13. class Memento {
  14. private String state;
  15. public Memento(String state) {
  16. this.state = state;
  17. }
  18. public String getState() {
  19. return state;
  20. }
  21. }
  22. // Caretaker
  23. class Caretaker {
  24. private Stack<Memento> mementos = new Stack<Memento>();
  25. public void addMemento(Memento m) {
  26. mementos.push(m);
  27. }
  28. public Memento getMemento() {
  29. if (!mementos.empty()) {
  30. return mementos.pop();
  31. }
  32. return null;
  33. }
  34. }
  35. // Originator
  36. class Originator {
  37. private String state;
  38. public Originator(String state) {
  39. this.state = state;
  40. }
  41. public void setState(String state) {
  42. this.state = state;
  43. }
  44. public String getState() {
  45. return state;
  46. }
  47. public Memento createMemento(String state) {
  48. return new Memento(state);
  49. }
  50. }

[java] view plaincopy

  1. public class MementoPattern {
  2. public static void main(String[] args) {
  3. Originator originator = new Originator("State1");
  4. Caretaker caretaker = new Caretaker();
  5. caretaker.addMemento(originator.createMemento(originator.getState()));
  6. originator.setState("State2");
  7. String restore = caretaker.getMemento().getState();
  8. System.out.println("Current originator state=" + originator.getState()
  9. + ",restore state=" + restore);
  10. }
  11. }
  12. // Memento
  13. class Memento {
  14. private String state;
  15. public Memento(String state) {
  16. this.state = state;
  17. }
  18. public String getState() {
  19. return state;
  20. }
  21. }
  22. // Caretaker
  23. class Caretaker {
  24. private Stack<Memento> mementos = new Stack<Memento>();
  25. public void addMemento(Memento m) {
  26. mementos.push(m);
  27. }
  28. public Memento getMemento() {
  29. if (!mementos.empty()) {
  30. return mementos.pop();
  31. }
  32. return null;
  33. }
  34. }
  35. // Originator
  36. class Originator {
  37. private String state;
  38. public Originator(String state) {
  39. this.state = state;
  40. }
  41. public void setState(String state) {
  42. this.state = state;
  43. }
  44. public String getState() {
  45. return state;
  46. }
  47. public Memento createMemento(String state) {
  48. return new Memento(state);
  49. }
  50. }

输出结果：

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. public static void main(String[] args) {
  6. try {
  7. draw(ShapeFactory.createShape("com.hzb.factory.Circle"));
  8. draw(ShapeFactory.createShape("com.hzb.factory.Rectangle"));
  9. } catch (Exception e) {
  10. // TODO Auto-generated catch block
  11. e.printStackTrace();
  12. }
  13. }
  14. }
  15. // 图形接口
  16. interface Shape {
  17. public void draw();
  18. }
  19. // 圆形
  20. class Circle implements Shape {
  21. public void draw() {
  22. System.out.println("Circle is drawing");
  23. }
  24. }
  25. // 矩形
  26. class Rectangle implements Shape {
  27. public void draw() {
  28. System.out.println("Rectangle is drawing");
  29. }
  30. }
  31. // 图形工厂
  32. class ShapeFactory {
  33. public static Shape createShape(String name) throws InstantiationException,
  34. IllegalAccessException, ClassNotFoundException {
  35. // 使用java的反射机制来产生对象实例
  36. return (Shape) Class.forName(name).newInstance();
  37. }
  38. }

[java] view plaincopy

  1. public class FactorySimple {
  2. public static void draw(Shape shape) {
  3. shape.draw();
  4. }
  5. public static void main(String[] args) {
  6. try {
  7. draw(ShapeFactory.createShape("com.hzb.factory.Circle"));
  8. draw(ShapeFactory.createShape("com.hzb.factory.Rectangle"));
  9. } catch (Exception e) {
  10. // TODO Auto-generated catch block
  11. e.printStackTrace();
  12. }
  13. }
  14. }
  15. // 图形接口
  16. interface Shape {
  17. public void draw();
  18. }
  19. // 圆形
  20. class Circle implements Shape {
  21. public void draw() {
  22. System.out.println("Circle is drawing");
  23. }
  24. }
  25. // 矩形
  26. class Rectangle implements Shape {
  27. public void draw() {
  28. System.out.println("Rectangle is drawing");
  29. }
  30. }
  31. // 图形工厂
  32. class ShapeFactory {
  33. public static Shape createShape(String name) throws InstantiationException,
  34. IllegalAccessException, ClassNotFoundException {
  35. // 使用java的反射机制来产生对象实例
  36. return (Shape) Class.forName(name).newInstance();
  37. }
  38. }

输出结果：

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. class Skin {
  13. private SkinFactory skinFactory;
  14. public Skin(SkinFactory factory) {
  15. setSkinFactory(factory);
  16. }
  17. public void setSkinFactory(SkinFactory factory) {
  18. this.skinFactory = factory;
  19. }
  20. public void showSkin() {
  21. System.out.println("Style=" + skinFactory.getStyle().showStyle()
  22. + ", color=" + skinFactory.getColor().showColor());
  23. }
  24. }
  25. //抽象皮肤工厂
  26. interface SkinFactory {
  27. public Style getStyle();
  28. public Color getColor();
  29. }
  30. // IOS皮肤工厂
  31. class IOSSkinFactory implements SkinFactory {
  32. public Style getStyle() {
  33. return new IOSStyle();
  34. }
  35. public Color getColor() {
  36. return new IOSColor();
  37. }
  38. }
  39. // Android皮肤工厂
  40. class AndroidSkinFactory implements SkinFactory {
  41. public Style getStyle() {
  42. return new AndroidStyle();
  43. }
  44. public Color getColor() {
  45. return new AndroidColor();
  46. }
  47. }
  48. // 软件Style
  49. interface Style {
  50. public String showStyle();
  51. }
  52. // IOS style
  53. class IOSStyle implements Style {
  54. public String showStyle() {
  55. return "This is IOS style";
  56. }
  57. }
  58. // Android style
  59. class AndroidStyle implements Style {
  60. public String showStyle() {
  61. return "This is Android style";
  62. }
  63. }
  64. // 软件Color
  65. interface Color {
  66. public String showColor();
  67. }
  68. // IOS color
  69. class IOSColor implements Color {
  70. public String showColor() {
  71. return "This is IOS color";
  72. }
  73. }
  74. // Android color
  75. class AndroidColor implements Color {
  76. public String showColor() {
  77. return "This is Android color";
  78. }
  79. }

[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. class Skin {
  13. private SkinFactory skinFactory;
  14. public Skin(SkinFactory factory) {
  15. setSkinFactory(factory);
  16. }
  17. public void setSkinFactory(SkinFactory factory) {
  18. this.skinFactory = factory;
  19. }
  20. public void showSkin() {
  21. System.out.println("Style=" + skinFactory.getStyle().showStyle()
  22. + ", color=" + skinFactory.getColor().showColor());
  23. }
  24. }
  25. //抽象皮肤工厂
  26. interface SkinFactory {
  27. public Style getStyle();
  28. public Color getColor();
  29. }
  30. // IOS皮肤工厂
  31. class IOSSkinFactory implements SkinFactory {
  32. public Style getStyle() {
  33. return new IOSStyle();
  34. }
  35. public Color getColor() {
  36. return new IOSColor();
  37. }
  38. }
  39. // Android皮肤工厂
  40. class AndroidSkinFactory implements SkinFactory {
  41. public Style getStyle() {
  42. return new AndroidStyle();
  43. }
  44. public Color getColor() {
  45. return new AndroidColor();
  46. }
  47. }
  48. // 软件Style
  49. interface Style {
  50. public String showStyle();
  51. }
  52. // IOS style
  53. class IOSStyle implements Style {
  54. public String showStyle() {
  55. return "This is IOS style";
  56. }
  57. }
  58. // Android style
  59. class AndroidStyle implements Style {
  60. public String showStyle() {
  61. return "This is Android style";
  62. }
  63. }
  64. // 软件Color
  65. interface Color {
  66. public String showColor();
  67. }
  68. // IOS color
  69. class IOSColor implements Color {
  70. public String showColor() {
  71. return "This is IOS color";
  72. }
  73. }
  74. // Android color
  75. class AndroidColor implements Color {
  76. public String showColor() {
  77. return "This is Android color";
  78. }
  79. }

输出结果：

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. abstract class CarFactory {
  13. public abstract ICar createCar();
  14. }
  15. //奔驰车工厂
  16. class BenzCarFactory extends CarFactory {
  17. public ICar createCar() {
  18. return new BenzCar();
  19. }
  20. }
  21. //宝马车工厂
  22. class BMWCarFactory extends CarFactory {
  23. public ICar createCar() {
  24. return new BMWCar();
  25. }
  26. }
  27. // 汽车接口
  28. interface ICar {
  29. public void run();
  30. }
  31. // 奔驰车
  32. class BenzCar implements ICar {
  33. public void run() {
  34. System.out.println("Benz car run");
  35. }
  36. }
  37. // 宝马车
  38. class BMWCar implements ICar {
  39. public void run() {
  40. System.out.println("BMW car run");
  41. }
  42. }

[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. abstract class CarFactory {
  13. public abstract ICar createCar();
  14. }
  15. //奔驰车工厂
  16. class BenzCarFactory extends CarFactory {
  17. public ICar createCar() {
  18. return new BenzCar();
  19. }
  20. }
  21. //宝马车工厂
  22. class BMWCarFactory extends CarFactory {
  23. public ICar createCar() {
  24. return new BMWCar();
  25. }
  26. }
  27. // 汽车接口
  28. interface ICar {
  29. public void run();
  30. }
  31. // 奔驰车
  32. class BenzCar implements ICar {
  33. public void run() {
  34. System.out.println("Benz car run");
  35. }
  36. }
  37. // 宝马车
  38. class BMWCar implements ICar {
  39. public void run() {
  40. System.out.println("BMW car run");
  41. }
  42. }

输出结果：

Benz car run
BMW car run

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

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

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

时间： 2024-10-25 10:25:04

单例、观察者、代理、备忘录、工厂的相关文章

常用设计模式（单例，代理，工厂，观察者）

单例:线程池.任务管理器. 1.饿汉模式:类加载时就创建好单例对象,调用静态方法返回单例对象,不需要考虑多线程问题. class Singleton{ private static singleInstance = new Singleton(); private Singleton(){} public static Singleton getInstance(){ return singleInstance; } } 2.懒汉模式:在调用方法时再创建单例对象 class Singleton{

单例、代理 &amp; 通知

PS:手写单例.代理方法实现 & 通知的简单使用! [ 单例模式,代理设计模式,观察者模式! ] 设计模式(Design pattern)是一套被反复使用.多数人知晓的.经过分类编目的.代码设计经验的总结.使用设计模式是为了可重用代码.让代码更容易被他人理解.保证代码可靠性. -- GoF “四人帮”<Design Patterns: Elements of Reusable Object-Oriented Software>将设计模式提升到理论高度,并将之规范化.该书提出了23种基本

iOS常用设计模式：MVC、单例、代理、观察者。

MVC 模型-视图-控制器(MVC)设计模式 MVC根据角色划分类,涉及到三个角色: Model:模型保存应用程序的数据. View:视图是模型的可视化表示以及用户交互的控件. Controller:控制器是一个协调所有工作的中介者.它访问模型中的数据并在视图中展示它们,同时它们还监听事件和操作数据. 单例设计模式 单例设计模式可以确保对于一个类只有一个实例(对象)存在,这个对象有一个全局的访问点.通常采用懒加载的方式在第一次用到对象的时候才去创建它. 如何创建一个单例: 如:在SortDeta

浅谈应用工厂模式和单例在Android中实现业务隔离

Android中写应用,一样需要考虑到降低耦合性的问题,还有一些其他问题,比如App的增量式更新,业务变更的便捷实现等等,都会有工厂模式和单例的身影. 工厂模式是我们最常用的实例化对象模式了,是用工厂方法代替new操作的一种模式.因为工厂模式就相当于创建实例对象的new,我们经常要根据类Class生成实例对象,如A a=new A() 工厂模式也是用来创建实例对象的,所以以后new时就要多个心眼,是否可以考虑使用工厂模式,虽然这样做,可能多做一些工作,但会给你系统带来更大的可扩展性和尽量少的修改

OC中的单例设计模式及单例的宏抽取

1 // 在一个对象需要重复使用,并且很频繁时,可以对对象使用单例设计模式 2 // 单例的设计其实就是多alloc内部的allocWithZone下手,重写该方法 3 4 #pragma Person.h文件 5 6 #import <Foundation/Foundation.h> 7 @interface Person : NSObject <NSCopying,NSMutableCopying> 8 + (instancetype)sharePerson; // 给类提供一

Java设计模式之单例模式之登记式单例

package 创建型_单例模式_登记式; import java.util.HashMap; import java.util.Map; /** * 登记式单例实际上维护的是一组单例类的实例,将这些实例存储到一个Map(登记簿) * 中,对于已经登记过的单例,则从工厂直接返回,对于没有登记的,则先登记,而后 * 返回 * @author pp * */ public class RegSingleton { /** * 登记簿,用来存放所有登记的实例 */ private static Map

编程常用设计模式详解--（上篇）（工厂、单例、建造者、原型）

参考来自:http://zz563143188.iteye.com/blog/1847029 一.设计模式的分类 总体来说设计模式分为三大类: 创建型模式,共五种:工厂方法模式.抽象工厂模式.单例模式.建造者模式.原型模式. 结构型模式,共七种:适配器模式.装饰器模式.代理模式.外观模式.桥接模式.组合模式.享元模式. 行为型模式,共十一种:策略模式.模板方法模式.观察者模式.迭代子模式.责任链模式.命令模式.备忘录模式.状态模式.访问者模式.中介者模式.解释器模式. 二.设计模式的六大原则 1

编程经常使用设计模式具体解释--（上篇）（工厂、单例、建造者、原型）

參考来自:http://zz563143188.iteye.com/blog/1847029 一.设计模式的分类 整体来说设计模式分为三大类: 创建型模式.共五种:工厂方法模式.抽象工厂模式.单例模式.建造者模式.原型模式. 结构型模式,共七种:适配器模式.装饰器模式.代理模式.外观模式.桥接模式.组合模式.享元模式. 行为型模式,共十一种:策略模式.模板方法模式.观察者模式.迭代子模式.责任链模式.命令模式.备忘录模式.状态模式.訪问者模式.中介者模式.解释器模式. 二.设计模式的六大原则 1

iOS 页面间几种传值方式（属性，代理，block，单例，通知）

第二个视图控制器如何获取第一个视图控制器的部分信息 例如 :第二个界面中的lable显示第一个界面textField中的文本 这就需要用到属性传值.block传值 那么第一个视图控制器如何获的第二个视图控制器的部分信息 例如:第一个界面中的lable显示第二个界面textField中的文本 这就需要使用代理传值 页面间传值有八大传值方式,下面我们就简单介绍下页面间常用的五种传值方式: (一)属性传值 第二个界面中的lable显示第一个界面textField中的文本 首先我们建立一个RootVie