现在的位置: 首页 > 综合 > 正文

设计模式之工厂模式

2018年03月30日 ⁄ 综合 ⁄ 共 8332字 ⁄ 字号 小 中 大 ⁄ 评论关闭

  1. 一、工厂模式的介绍  
  2. 工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪一个类。  
  3. 工厂模式的几种形态：  
  4. （1）简单工厂（Simple Factory）模式，又称静态工厂方法模式（Static Factory Method  
  5. Pattern）。  
  6. （2）工厂方法（Factory Method）模式，又称多态性工厂（Polymorphic Factory）模式  
  7. 或虚拟构造子（Virtual Constructor）模式；  
  8. （3）抽象工厂（Abstract Factory）模式，又称工具箱（Kit 或Toolkit）模式。   

  1. 二、简单工厂模式  
  2. 2.1简单工厂模式介绍  
  3. 简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据自变量的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。   
  4.   
  5.   
  6. 2.2简单工厂模式角色  
  7. （1）工厂类（Creator）角色：担任这个角色的是工厂方法模式的核心，含有与应用紧密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象，它往往由一个具体Java 类实现。  
  8. （2）抽象产品（Product）角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。抽象产品角色可以用一个Java 接口或者Java 抽象类实现。  
  9. （3）具体产品（Concrete Product）角色：工厂方法模式所创建的任何对象都是这个角色的实例，具体产品角色由一个具体Java 类实现。

  1. 三、工厂方法模式  
  2. 3.1工厂方法模式的介绍  
  3.     工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method是一个类的实例化延迟到其子类。  
  4. 在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。这个核心类则摇身一变，成为了一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。  
  5.   
  6. 3.2工厂方法模式角色  
  7. （1）抽象工厂（Creator）角色：担任这个角色的是工厂方法模式的核心，它是与应用程序无关的。任何在模式中创建对象的工厂类必须实现这个接口。在上面的系统中这个角色由Java 接口Creator 扮演；在实际的系统中，这个角色也常常使用抽象Java 类实现。  
  8. （2）具体工厂（Concrete Creator）角色：担任这个角色的是实现了抽象工厂接口的具体Java 类。具体工厂角色含有与应用密切相关的逻辑，并且受到应用程序的调用以创建产品对象。在本系统中给出了两个这样的角色，也就是具体Java 类ConcreteCreator1 和ConcreteCreator2。  
  9. （3）抽象产品（Product）角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。在本系统中，这个角色由Java 接口Product 扮演；在实际的系统中，这个角色也常常使用抽象Java 类实现。  
  10. （4）具体产品（Concrete Product）角色：这个角色实现了抽象产品角色所声明的接口。工厂方法模式所创建的每一个对象都是某个具体产品角色的实例。 

  1.  
  2. 3.5工厂方法模式的举例  
  3. 例：  
  4. //抽象产品   
  5. PenCore.java  
  6. public abstract class PenCore{  
  7. String color;  
  8. public abstract void writeWord(String s);  
  9. }  
  10. //具体产品  
  11. RedPenCore.java  
  12. public class RedPenCore extends PenCore {  
  13.     RedPenCore() {  
  14.         color = "红色";  
  15.     }  
  16.     public void writeWord(String s) {  
  17.         System.out.println("写出" + color + "的字" + s);  
  18.     }  
  19. }  
  20. BluePenCore.java  
  21. public class BluePenCore extends PenCore {  
  22.     BluePenCore() {  
  23.         color = "蓝色";  
  24.     }  
  25.     public void writeWord(String s) {  
  26.         System.out.println("写出" + color + "的字" + s);  
  27.     }  
  28. }  
  29. BlackPenCore.java  
  30. public class BlackPenCore extends PenCore {  
  31.     BlackPenCore() {  
  32.         color = "黑色";  
  33.     }  
  34.     public void writeWord(String s) {  
  35.         System.out.println("写出" + color + "的字" + s);  
  36.     }  
  37. }  
  38. //构造者  
  39. BallPen.java  
  40. public abstract class BallPen {  
  41.     BallPen(){  
  42.         System.out.println("生产一只装有"+getPenCore().color+"笔芯的圆珠笔");  
  43.     }  
  44.     public abstract PenCore getPenCore();  
  45. }  
  46. //具体构造者  
  47. RedBallPen.java  
  48. public class RedBallPen extends BallPen {  
  49.     public PenCore getPenCore() {  
  50.         return new RedPenCore();  
  51.     }  
  52. }  
  53. BlueBallPen.java  
  54. public class BlueBallPen extends BallPen {  
  55.     public PenCore getPenCore() {  
  56.         return new BluePenCore();  
  57.     }  
  58. }  
  59. BlackBallPen.java  
  60. public class BlackBallPen extends BallPen {  
  61.     public PenCore getPenCore() {  
  62.         return new BlackPenCore();  
  63.     }  
  64. }  

  1.   
  2. 四、抽象工厂模式  
  3. 4.1抽象工厂模式的介绍  
  4.     抽象工厂模式提供一个创建一系列或相互依赖的对象的接口，而无需指定它们具体的类。  
  5.   
  6. 4.2抽象工厂模式角色  
  7. 抽象工厂模式涉及到的系统角色  
  8. （1）抽象工厂（AbstractFactory）角色：担任这个角色的是工厂方法模式的核心，它是与应用系统的商业逻辑无关的。通常使用Java 接口或者抽象Java 类实现，而所有的具体工厂类必须实现这个Java 接口或继承这个抽象Java 类。  
  9. （2）具体工厂类（Conrete Factory）角色：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。通常使用具体Java 类实现这个角色。  
  10. （3）抽象产品（Abstract Product）角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。通常使用Java 接口或者抽象Java 类实现这一角色。  
  11. （4）具体产品（Concrete Product）角色：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西，其内部一定充满了应用系统的商业逻辑。通常使用具体Java 类实现这个角色。
  1. 4.5抽象工厂模式的举例  
  2. 例：  
  3. //抽象产品  
  4. UpperClothes.java  
  5. public abstract class UpperClothes {  
  6.     public abstract int getChestSize();  
  7.     public abstract int getHeight();  
  8.     public abstract String getName();  
  9. }  
  10. Trousers.java  
  11. public abstract class Trousers {  
  12.     public abstract int getWaistSize();  
  13.     public abstract int getHeight();  
  14.     public abstract String getName();  
  15. }  
  16. //具体产品  
  17. WesternUpperClothes.java  
  18. public class WesternUpperClothes extends UpperClothes {  
  19.     private int chestSize;  
  20.     private int height;  
  21.     private String name;  
  22.     WesternUpperClothes(String name,int chestSize,int height){  
  23.         this.name=name;  
  24.         this.chestSize=chestSize;  
  25.         this.height=height;  
  26.     }  
  27.     public int getChestSize() {  
  28.         return chestSize;  
  29.     }  
  30.     public int getHeight() {  
  31.         return height;  
  32.     }  
  33.     public String getName() {  
  34.         return name;  
  35.     }  
  36. }  
  37. CowboyUpperClothes.java  
  38. public class CowboyUpperClothes extends UpperClothes {  
  39.     private int chestSize;  
  40.     private int height;  
  41.     private String name;  
  42.     CowboyUpperClothes(String name,int chestSize,int height){  
  43.         this.name=name;  
  44.         this.chestSize=chestSize;  
  45.         this.height=height;  
  46.     }  
  47.     public int getChestSize() {  
  48.         return chestSize;  
  49.     }  
  50.     public int getHeight() {  
  51.         return height;  
  52.     }  
  53.     public String getName () {  
  54.         return name;  
  55.     }  
  56. }  
  57. WesternTrousers.java  
  58. public class WesternTrousers extends Trousers {  
  59.     private int waistSize;  
  60.     private int height;  
  61.     private String name;  
  62.     WesternTrousers(String name,int waistSize,int height){  
  63.         this.name=name;  
  64.         this.waistSize=waistSize;  
  65.         this.height=height;  
  66.     }  
  67.     public int getHeight() {  
  68.         return height;  
  69.     }  
  70.     public String getName() {  
  71.         return name;  
  72.     }  
  73.     public int getWaistSize() {  
  74.         return waistSize;  
  75.     }  
  76. }  
  77. CowboyTrousers.java  
  78. public class CowboyTrousers extends Trousers {  
  79.     private int waistSize;  
  80.     private int height;  
  81.     private String name;  
  82.     CowboyTrousers(String name,int waistSize,int height){  
  83.         this.name=name;  
  84.         this.waistSize=waistSize;  
  85.         this.height=height;  
  86.     }  
  87.     public int getHeight() {  
  88.         return height;  
  89.     }  
  90.     public String getName() {  
  91.         return name;  
  92.     }  
  93.     public int getWaistSize() {  
  94.         return waistSize;  
  95.     }  
  96. }  
  97. //抽象工厂  
  98. ClothesFactory.java  
  99. public abstract class ClothesFactory {  
  100.     public abstract UpperClothes createUpperClothes(int chestSize,int height);  
  101.     public abstract Trousers createTrousers(int waistSize,int height);  
  102. }  
  103. //具体工厂  
  104. BeijingClothesFactory.java  
  105. public class BeijingClothesFactory extends ClothesFactory {  
  106.     public Trousers createTrousers(int waistSize, int height) {  
  107.         return new WesternTrousers("北京牌裤子",waistSize,height);  
  108.     }  
  109.     public UpperClothes createUpperClothes(int chestSize, int height) {  
  110.         return new WesternUpperClothes("北京牌上衣",chestSize,height);  
  111.     }  
  112. }  
  113. ShanghaiClothesFactory.java  
  114. public class ShanghaiClothesFactory extends ClothesFactory {  
  115.     public Trousers createTrousers(int waistSize, int height) {  
  116.         return new WesternTrousers("上海牌裤子",waistSize,height);  
  117.     }  
  118.     public UpperClothes createUpperClothes(int chestSize, int height) {  
  119.         return new WesternUpperClothes("上海牌上衣",chestSize,height);  
  120.     }  
  121. }  

下面是一个简单的工厂模式 

[java] view
plaincopy

  1. package org;  
  2.   
  3. interface Fruit{  
  4.     public void eat();  
  5. }  
  6. class Apple implements Fruit{  
  7.     public void eat(){  
  8.         System.out.println("吃苹果。");  
  9.     }  
  10. }  
  11. class Orange implements Fruit{  
  12.     public void eat(){  
  13.         System.out.println("吃橘子");  
  14.     }  
  15. }  
  16. class Factory{     //工厂类  
  17.     public static Fruit getInstance(String className){  
  18.         Fruit f=null;  
  19.         if(className.equals("apple")){  
  20.             f=new Apple();  
  21.         }  
  22.         if(className.endsWith("orange")){  
  23.             f=new Orange();  
  24.         }  
  25.         return f;  
  26.     }  
  27. }  
  28. public class FactoryDemo02 {  
  29.     public static void main(String args[]){  
  30.     Fruit f=Factory.getInstance("apple");  
  31.     f.eat();  
  32.     }  
  33. }  



但是工厂类如果这样写的话，就有一个问题，如果增加了水果，比如香蕉，那么在工厂类里面也要进行相关的修改了，这样不合理，而java的反射机制可以解决这个问题

  1. package org1;  
  2.   
  3. interface Fruit {  
  4.     public void eat();  
  5. }  
  6.   
  7. class Apple implements Fruit {  
  8.     public void eat() {  
  9.         System.out.println("吃苹果。");  
  10.     }  
  11. }  
  12.   
  13. class Orange implements Fruit {  
  14.     public void eat() {  
  15.         System.out.println("吃橘子");  
  16.     }  
  17. }  
  18.   
  19. class Factory {  
  20.     public static Fruit getInstance(String className) {  
  21.         Fruit f = null;  
  22.         try {  
  23.             f = (Fruit) Class.forName(className).newInstance();  
  24.         } catch (Exception e) {  
  25.             e.printStackTrace();  
  26.         }  
  27.         return f;  
  28.     }  
  29. }  
  30.   
  31. public class CopyOfFactoryDemo03 {  
  32.     public static void main(String args[]) {  
  33.         Fruit f = Factory.getInstance("org1.Apple");  
  34.         f.eat();  
  35.     }  
  36. }  

利用java的反射机制，就能动态的实例化各种类了。

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞