简单工厂模式、工厂方法模式以及抽象工厂模式

摘要

  本文主要讲解工厂模式所包含的三种模式，并通过源码展示其实现。工厂模式主要用来创建对象，以去除与被创建类之间的耦合。工厂模式通常分为三种：简单工厂模式、工厂方法模式以及抽象工厂模式。

一、简单工厂模式

  简单工厂模式主要用来创建单一的类，只是简单封装了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、抽象工厂是把工厂的方法提取出来，先创建不同工厂方法，在创建不同对象。