簡單工廠模式、工廠方法模式以及抽象工廠模式

摘要

  本文主要講解工廠模式所包含的三種模式，並通過源碼展示其實現。工廠模式主要用來創建對象，以去除與被創建類之間的耦合。工廠模式通常分爲三種：簡單工廠模式、工廠方法模式以及抽象工廠模式。

一、簡單工廠模式

  簡單工廠模式主要用來創建單一的類，只是簡單封裝了new對象這個動作。

  案例：想得到KFC烹飪的食物，想得到MCD(麥當勞)烹飪的食物。
  代碼結構：
    1.1、FoodFactory.java
    1.2、Food.java
    1.3、KFC.java
    1.4、MCD.java
    1.5、Main.java

1.1 FoodFactory.java

// 食物工廠類
public class FoodFactory {
	static Food createFood(String food) {
		// 生產KFC的食物
		if(food.equals("KFC")) {
			return new KFC();
		}
		// 生產MCD的食物
		else if(food.equals("MCD")) {
			return new MCD();
		} 
		// 生產其他食物
		else {
			return null;
		}
	}
}

1.2 Food.java

  Food類爲一個接口，提供一個必要的方法給子類去實現。

// Food接口
public interface Food {
	void cooking();
}

1.3 KFC.java

  KFC類實現Food接口，重寫屬於KFC的特有cooking()方法。

public class KFC implements Food{
	@Override
	public void cooking() {
		System.out.println("KFC is cooking");
	}
}

1.4 MCD.java

  MCD類實現Food接口，重寫屬於MCD的特有cooking()方法。

public class MCD implements Food{
	@Override
	public void cooking() {
		System.out.println("MCD is cooking");
	}
}

1.5 Main.java

  Main類表現出簡單工廠模式的使用方法。

public class Main {
	public static void main(String[] args) {
		Food food_1 = FoodFactory.createFood("KFC");
		Food food_2 = FoodFactory.createFood("MCD");
		
		food_1.cooking();
		food_2.cooking();
	}
}

執行結果如下：

KFC is cooking
MCD is cooking

  從Main.java可知，代碼已經脫離了與new KFC()、new MCD()之間的耦合。

二、工廠方法模式

  簡單工廠模式只是簡單地封裝了new動作，還不能做到開閉原則，需要進一步升級，由此產生了工廠方法類。讓每一個實例類都擁有一個工廠類，這些工廠類統一實現於工廠接口類。

  案例：想得到KFC烹飪的食物，想得到MCD(麥當勞)烹飪的食物。
  代碼結構：
    2.1、FoodFactory.java
    2.2、KFCFactory.java
    2.3、MCDFactory.java
    2.4、Food.java
    2.5、KFC.java
    2.6、MCD.java
    2.7、Main.java

2.1 FoodFactory.java

  FoodFactory類爲接口類，其他生產Food的工廠類都實現它的相關方法。

public interface FoodFactory{
	public Food createFood();
}

2.2 KFCFactory.java

public class KFCFactory implements FoodFactory{
	@Override
	public Food createFood() {
		return new KFC();
	}
}

2.3 MCDFactory .java

public class MCDFactory implements FoodFactory{
	@Override
	public Food createFood() {
		return new MCD();
	}
}

2.4 Food.java

public interface Food {
	void cooking();
}

2.5 KFC.java

public class KFC implements Food{
	@Override
	public void cooking() {
		System.out.println("KFC is cooking");
	}
}

2.6 MCD.java

public class MCD implements Food{
	@Override
	public void cooking() {
		System.out.println("MCD is cooking");
	}
}

2.7 Main.java

public class Main {
	public static void main(String[] args) {
		Food food_1 = new KFCFactory().createFood();
		food_1.cooking();
		Food food_2 = new MCDFactory().createFood();
		food_2.cooking();
	}
}

執行結果如下：

KFC is cooking
MCD is cooking

  從代碼可以看出，若想增加新food類，添加新的FoodFactory類即可，不需要修改其他代碼。

三、抽象工廠模式

   抽象工廠模式用於同一類下的不同品質，如生產汽車，其中同一品牌汽車有高端車和低端車。再如，KFC生產的食物，其中同一KFC生產的食物，有美國KFC生產的食物和中國KFC生產的食物。

  案例：想得到中國KFC烹飪的漢堡、雞柳，想得到美國KFC烹飪的漢堡、雞柳。
  代碼結構：
    3.1、KFCFactory.java
    3.2、KFCFactoryChina.java
    3.3、KFCFactoryUSA.java
    3.4、Food.java
    3.5、HamburgerChina.java 和 HamburgerUSA.java
    3.6、ChopChina.java 和 ChopUSA.java
    3.7、Main.java

3.1 KFCFactory.java

  KFCFactory類爲KFC的接口類，其他生產Food的KFC工廠類都實現它的相關方法。

public interface KFCFactory{
	public Food createChop();
	public Food createHamburger();
}

3.2 KFCFactoryChina.java

public class KFCFactoryChina implements KFCFactory{
	@Override
	public ChopChina createChop() {
		System.out.println("Chicken Chop from China ");
		return new ChopChina();
	}
	@Override
	public HamburgerChina createHamburger() {
		System.out.println("Chicken Hamburger from China ");
		return new HamburgerChina();
	}
}

3.3 KFCFactoryUSA.java

public class KFCFactoryUSA implements KFCFactory{
	@Override
	public ChopUSA createChop() {
		System.out.println("Chicken Chop from USA ");
		return new ChopUSA();
	}
	@Override
	public HamburgerUSA createHamburger() {
		System.out.println("Chicken Hamburger from USA ");
		return new HamburgerUSA();
	}
}

3.4 Food.java

public interface Food {
	void cooking();
}

3.5 HamburgerChina.java 和 HamburgerUSA.java

public class HamburgerChina implements Food{
	@Override
	public void cooking() {
		System.out.println("Hello, I am Chinese Hamburger");
	}
}

public class HamburgerUSA implements Food{
	@Override
	public void cooking() {
		System.out.println("Hello, I am American Hamburger");
	}
}

3.6 ChopChina.java 和 ChopUSA.java

public class ChopChina implements Food{
	@Override
	public void cooking() {
		System.out.println("Hello, I am Chinese Chop");
	}
}

public class ChopUSA implements Food{
	@Override
	public void cooking() {
		System.out.println("Hello, I am American Chop");
	}
}

3.7 Main.java

public class Main {
	public static void main(String[] args) {
		Food food_11 = new KFCFactoryChina().createChop();
		Food food_13 = new KFCFactoryChina().createHamburger();
		food_11.cooking();
		food_13.cooking();
		System.out.println("##############################");
		Food food_21 = new KFCFactoryUSA().createChop();
		Food food_23 = new KFCFactoryUSA().createHamburger();
		food_21.cooking();
		food_23.cooking();
	}
}

執行結果如下：

Chicken Chop from China 
Chicken Hamburger from China 
Hello, I am Chinese Chop
Hello, I am Chinese Hamburger
##############################
Chicken Chop from USA 
Chicken Hamburger from USA 
Hello, I am American Chop
Hello, I am American Hamburger

四、總結

  1、簡單工廠是根據不同對象類型創建對象；
  2、工廠方法是把工廠提取出來，先創建不同工廠，在創建不同對象；
  3、抽象工廠是把工廠的方法提取出來，先創建不同工廠方法，在創建不同對象。