设计模式-工厂方法模式

概述

工厂方法模式的作用是负责实例化同一个接口的多个类。工厂方法模式的意义是定义一个创建产品对象的工厂类，由该工厂统一创建继承了同一个接口的多个产品对象。

根据工厂类和工厂方法的不同形式，可以用来表示不同的创建策略。根据决策策略的不同，工厂方法模式可以分为3个子类型。

• 工厂方法模式(FactoryMethod)：最基本的工厂模式
• 多个工厂方法模式：对工厂方法模式的扩展。
• 简单工厂模式(Simple Factory)：一种特殊的工厂模式，其工厂方法是静态的，因此又称为静态工厂方法模式(Static Factory Method)。

  一、工厂方法模式

  工厂方法模式提供了一个工厂方法类 Farm1，并提供了一个工厂方法函数produce()，该接口负责创建所有的Animal产品对象，其模型如下图所示。

  

  工厂类 Farm1.java 的函数 produce()提供了一个type 参数，根据该参数的值来创建不同的产品对象。

  • type ==“pig”：创建 Pig 对象。
  • type ==“chicke”：创建 Chicken 对象
  • type ==“cattle”：创建 Cattle 对象。
  • type ==“sheep”：创建 Sheep 对象。

    该工厂类的代码如程序：

    package creation.factorymethod;
    /**
    * @author Minggg
    * 工厂方法模式
    */
    public class Farm1 {
    	public Animal produce(String type){
    		if (type == "pig"){
    			return new Pig();
    		} else if (type == "chicken") {
    			return new Chicken();
    		} else if(type == "cattle") {
    			return new Cattle();
    		} else if(type == "sheep") {
    			return new Sheep();
    		} else {
    			return new Chicken();
    		}
    	}
    }
    

    要使用该工厂类创建不同的 Animal产品，可以按照下面的步骤来使用：

    (1)创建工厂类Farm1.java的一个实例 farm。

    (2)传递不同的type 参数创建不同的 Animal 产品对象。

    可以调用每个 Animal的 sale()函数来计算销售价格和总收入，测试程序如下所示：

    测试类FarmlTest.java

    package creation.factorymethod;
    public class FarmlTest {
    	public static void test(int countl, int count2, int count3, int count4){
    		//创建工厂实例
    		FarmI farm = new Farml();
    		//生产对象
    		Animal animal1 = farm.produce("pig");
    		Animal animal2 = farm.produce("chicken");
    		Animal animal3 = farm.produce("cattle");
    		Animal animal4 = farm.produce("sheep");
    		
    		/计算收入
    		int money1 = animal1.sale()* count1;
    		int money2 = animal2.sale()* count2;
    		int money3 = animal3.sale( * count3;
    		int money4 = animal4.sale()* count4;
    		
    		System.out.println("Framl养猪收入:"+money1);
    		System.out.println("Framl养鸡收入:"+money2);
    		System.out.println("Framl养牛收入:"+ money3);
    		System.out.println("Framl养羊收入:"+money4);
    		
    		// 计算总收入
    		int sum = moneyl + money2 + money3 + money4;
    		System.out.println("Framl总收入:"+sum);
    	}
    	public static void main(String[] args) {
    		Farm1Test.test(20,1000,10,50);
    	}
    

    运行该程序的结果输出是：

    Fram1养猪收入:40000
    Framl养鸡收入:45000
    Framl养牛收入:76000
    Framl养羊收入:52500
    Fram1总收入:213500
    

    二、多个工厂方法模式

    对于第一种工厂类 Farm1.java 的函数 produce(，在每次调用该函数时必须传递一个类型参数。这种工厂类还显得比较稚嫩，因为当传递参数错误时，就不能够正确地创建产品。

    为了避免这一点不足，可以对该工厂进行改进，为该工厂类提供多个工厂方法，分别创建不同的产品对象，这就是多个工厂方法模式，其结构如下图所示。

    

    在工厂类 Farm2.java中，它提供了多个工厂方法用来创建不同的 Animial 产品对象。

    • producePig()：创建 Pig 对象。
    • produceChicke()：创建 Chicken 对象
    • produceCattle()：创建 Cattle 对象。
    • produceSheep()：创建 Sheep 对象。

      该工厂类的代码如下程序：

      package creation.factorymethod;
      /**
      * @author Minggg
      * 多个工厂方法模式
      */
      public class Farm2{
      	public Animal producePig(){
      		return new Pig();
      	}
      	
      	publie Animal produceChicken(){
      		return new Chicken();
      	}
      	
      	public Animal produceCattle(){
      		return new Cattle();
      	}
      	
      	publie Animal produceSheep(){
      		return new Sheep();
      	}
      }
      

      此时我们再改造测试类，使用工厂类Farm2来分别创建4个不同的产品，不同之处如下程序所示：

      测试类Farm2Test.java

      package creation.factorymethod;
      public class Farm2Test {
      	public static void test(int countl, int count2, int count3, int count4) {
      		//创建工厂实例
      		Farm2 farm = new Farm2();
      		/ 生产对象
      		Animal animal1 = farm.producePig();
      		Animal animal2 = farm.produceChicken();
      		Animal animal3 = farm.produceCattle();
      		Animal animal4 = farm.produceSheep();
      		
      		/ 计算收入
      		int money1 = animal1.sale() * count1;
      		int money2 = animal2.sale() * count2;
      		int money3 = animal3.sale() * count3;
      		int money4 = animal4.sale() * count4;
      		
      		System.out.printIn("Fram2养猪收入:"+moneyl);
      		System.out.printin("Fram2 养鸡收入:"+money2);
      		System.out,println("Fram2 养牛收入:" + money3);
      		System.out.println("Fram2 养羊收入:"+money4);
      		
      		//计算总收入
      		int sum = moneyl + money2 + money3 + money4;
      		System.out.println("Fram2 总收入:" + sum);
      	}
      	public static void main(String[] args) {
      		Farm2Test.test(20,1000,10,50);
      	}
      }
      

      与普通的工厂方法模式不同的是，这里在使用Farm2创建产品时不需要输入参数，直接调用不同的工厂方法即可创建出各自的产品，显然使得代码更加优美了。

      三、静态工厂方法模式（简单工厂模式）

      经过以上的改进，使得工厂类更优美了，但是还有些美中不足。因为，我们在每一次创建 Animal实例需要使用工厂类时，都需要创建一个工厂对象。此时可以使用静态工厂方法模式，将工厂方法置为静态的，可以直接引用工厂类的方法来创建产品，结构如下图所示。

      

      静态工厂方法模式又称为简单工厂模式，此时的工厂类如下程序所示：

      package creation.factorymethod;
      /**
      * @author Minggg
      * 简单工厂模式(静态工厂方法模式)
      */
      public class Farm3{
      	
      	public static Animal producePig() {
      		return new Pig();
      	}
      	
      	public static Animal produceChicken() {
      		retum new Chicken();
      	}
      	
      	public static Animal produceCattle() {
      		return new Cattle();
      	}
      	
      	public static Animal produceSheep() {
      		return new Sheep():
      	}
      }
      

      此时不需要创建工厂类的实例，可以直接引用静态方法来创建Animal产品，如下程序所示：

      package creation.factorymethod;
      public class Farm3Test {
      	public static void test(int countl, int count2, int count3, int count4){
      		// 生产对象
      		Animal animal1 = Farm3.producePig();
      		Animal animal2 = Farm3.produceChicken();
      		Animal animal3 =Farm3.produceCattle();
      		Animal animal4 = Farm3.produceSheep();
      		
      		//计算收入
      		int moneyl = animal1.sale() * count1;
      		int money2 = animal2.sale() * count2;
      		int money3 = animal3.sale() * count3;
      		int money4 = animal4.sale() * count4;
      		
      		System.out.printIn("Fram3 养猪收入:"+ money1);
      		System.out.println("Fram3 养鸡收入:"+ money2);
      		System,out.println("Fram3 养牛收入:"+ money3);
      		System.out.println("Fram3 养羊收入:"+ money4);
      		
      		// 计算总收入
      		int sum = money1 + money2 + money3 + money4;
      		System.out,printIn("Fram3 总收入:"+ sum);
      	}
      	public static void main(String[] args) {
      		Farm3Testtest(20,1000,10,50);
      	}
      }
      

      四、何时使用工厂方法模式

      工厂方法模式的核心是工厂类，这个类包含了创建产品的决策策略，它可以决定如何和何时创建什么产品对象。

      工厂方法模式应用的应用场景:凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。如下图所示为产品结构：

      

      以上我们讲解了3种工厂方法模式，经过逐步的改造，我们会发现第三种方式是比较优美的，因为它不需要创建工厂实例，而且可以创建多个产品，因此通常我们都会选用静态工厂方法模式来进行产品的创建。

      五、Java中的应用–Swing中的静态工厂类BorderFactory

      在 Java 的 Swing 包 javax.swing 中,需要创建多个不同的边界对象，这些边界类拥有一个共同的接口 Border，符合工厂方法模式应用的场景，如下图所示。

      

      于是 Swing 中提供了一个工厂类 BorderFactory来创建不同的边界对象,它采用的是第三种静态工厂方法模式，在该工厂类中包含多个静态方法，分别用于创建不同类习惯的边界对象，例如下程序所示：

      Swing中的静态工厂类BorderFactory.java

      package javax.swing;
      import java.awt.Color;
      import java.awt.Font;
      import javax.swing.JComponent;
      import javax.swing.border.* ;
      public class BorderFactory {
      	public statie Border createLineBorder(Color color) {
      		return new LineBorder(color, 1);
      	}
      	public statie Border createLineBorder(Color color, int thickness){
      		return new LineBorder(color, thickness);
      	}
      	static final Border sharedRaisedBevel = new BevelBorder(BevelBorder.RAISED);
      	static final Border sharedLoweredBevel = new BevelBorder(BevelBorder.LOWERED);
      	publie static Border createRaisedBevelBorder()(
      		return createSharedBevel(BevelBorder RAISED);
      	}
      	
      	public statie Border createLoweredBevelBorder(){
      		return createSharedBevel(BevelBorder.LOWERED);
      	}
      	
      	publie static Border createBevelBorder(int type) {
      		return createSharedBevel(type);
      	}
      	
      	public statie Border createBevelBorder(int type, Color highlight, Color shadow){
      		return new BevelBorder(type, highlight, shadow);
      	}
      	public static Border createBevelBorder(int type, Color highlightOuter, Color highlightlnner, Color shadowOuter, Color
      shadowInner){
      		return new BevelBorder(type, highlightOuter, highlightlnner, shadowOuter, shadowlnner);
      	}
      	
      	static Border createSharedBevel(int type) {
      		if(type == BevelBorder.RAISED){
      			return sharedRaisedBevel;
      		} else if(type == BevelBorder.LOWERED){
      			return sharedLoweredBevel;
      		}
      		return null;
      	}
      	
      	static final Border sharedEtchedBorder = new EtchedBorder();
      	private static Border sharedRaisedEtchedBorder;
      	
      	public static Border createEtehedBorder() {
      		return sharedEtchedBorder;
      	}
      	
      	public static Border createEtchedBorder(Color highlight, Color shadow)
      		return new EtchedBorder(highlight, shadow);
      	}
      	public statie Border createEtchedBorder(int type) {
      		switch (type){
      			case EtchedBorder.RAISED:
      				if (sharedRaisedEtchedBorder == null){
      					sharedRaisedEtchedBorder = new EtchedBorder(EtchedBorder.RAISED):
      				}
      				return sharedRaisedEtchedBorder;
      			case EtchedBorder.LOWERED:
      				return sharedEtchedBorder;
      			default:
      				throw new IllegalArgumentException("type must be one of EthedBorder.RAISED or EtchedBorder.LOWERED"):
      		}
      	}
      	publie static Border createEtchedBorder(int type, Color highlight, Color shadow) {
      		return new EtchedBorder(type, highlight, shadow);
      	}
      	public statie TitledBorder createTitledBorder(String title) {
      		return new TitledBorder(title);
      	}
      	
      	public static TitledBorder createTitledBorder(Border border) {
      		return new TitledBorder(border);
      	}
      	public statie TitledBorder ereateTitledBorder(Border border, String title){
      		return new TitledBorder(border, title);
      	}
      	
      	public statie TitledBorder createTitledBorder(Border border, String title, int titleJustification, int titlePosition) {
      		return new TitledBorder(border, title, titleJustifieation, titlePosition);
      	}
      	public static TitledBorder createTitledBorder(Border border, String title, int titleJustification int titlePosition, Font titleFont){
      		return new TitledBorder(border, title, titleJustification, titlePosition, titleFont);
      	}
      	
      	public static TitledBorder createTitledBorder(Border border, String title, int titleJustifcation, int titlePosition, Font titleFont, Color titieColor){
      		return new TitledBorder(border, title, titleJustification, titlePosition, titleFont, titleColor);
      	}
      	
      	final static Border emptyBorder = new EmptyBorder(0, 0, 0, 0);
      	public static Border createEmptyBorder(){
      		return emptyBorder;
      	}
      	public statie Border createEmptyBorder(int top, int left, int bottom, int right) {
      		return new EmptyBorder(top, left, bottom, right);
      	}
      	
      	public static CompoundBorder createCompoundBorder()(
      		return new CompoundBorder;
      	}
      	
      	publie statie CompoundBorder createCompoundBorder(Border outsideBorder, Border insideBorder) {
      		return new CompoundBorder(outsideBorder, insideBorder);
      	}
      	
      	public static MatteBorder createMatteBorder(int top, int left, int bottom, int right, Color color) {
      		return new MatteBorder(top, left, bottom, right, color);
      	}
      	
      	public static MatteBorder createMatteBorder(int top, int left, int bottom, int right, lcon tilelcon) {
      		return new MatteBorder(top, left, bottom, right, tilelcon);
      	}
      }
      

      以上的代码的静态函数才属于本文所讲解的工厂方法模式，还有一些使用了单例模式创建的唯一性实例变量。