前言
在前面的章节中，我们先后介绍了简单工厂模式和工厂方法模式。他们都是工厂模式大家族的一员，那么，本章将会接着上一章，来说一说工厂模式的最后一员，那就是抽象工厂模式。
思考题
首先，来思考下下面的问题怎么实现：
在工厂方法模式中，博主在四川和上海开了一家饭店，目前生意相当的火爆，但是还是不赚钱。分析原因发现，目前各家分店都是自己采购原料，并且很贵。那博主就不愿意了，博主决定，自己开一家生产原料的工厂。那么我们应该去实现这个工厂呢？
要是学习了 抽象工厂模式 ，你就会很惊喜的发现，那家伙可以很好的满足我们的需求。
抽象工厂模式
定义：抽象工厂模式就是在抽象工厂中提供一系列的接口，用这一系列的接口创建相关或者依赖对象的家族，而不需要指定具体的类。
类图：
上面的类图，涉及以下几个角色：
- 抽象产品A，B：为产品A，B定义了一些接口。
- 具体产品A，B：抽象产品A，B的具体实现。
- 抽象工厂：定义了一些列的接口，用于创建具体的产品A，B。
- 具体工厂：实现了抽象工厂的一系列接口，可以生产一些相关的产品。
思考题实现
首先，定义抽象产品：
Salt.java:
public interface Salt {
String put();
}
然后，定义抽象产品的实现：
ShangHaiSalt.java:
public class ShangHaiSalt implements Salt {
public String put() {
return "上海的盐";
}
}
SiChuanSalt.java:
public class SiChuanSalt implements Salt {
public String put(){
return "四川的盐";
}
}
然后，定义抽象原料工厂：
IngredientFactory.java:
public interface IngredientFactory {
Salt createSalt();
}
然后，实现抽象原料工厂：
ShangHaiIngredientFactory.java:
public class ShangHaiIngredientFactory implements IngredientFactory {
public Salt createSalt() {
return new ShangHaiSalt();
}
}
SiChuanIngredientFactory.java:
public class SiChuanIngredientFactory implements IngredientFactory {
public Salt createSalt() {
return new SiChuanSalt();
}
}
然后，定义抽象产品：
Food.java:
public abstract class Food {
protected IngredientFactory ingredientFactory;
public Food(IngredientFactory ingredientFactory) {
this.ingredientFactory = ingredientFactory;
}
public void fry() {
System.out.println("翻炒");
}
public void eat() {
System.out.println("吃");
}
public abstract void putSeasoning();
}
然后，实现抽象产品：
KungPaoChicken.java:
public class KungPaoChicken extends Food {
public KungPaoChicken(IngredientFactory ingredient) {
super(ingredient);
}
@Override
public void putSeasoning() {
Salt salt = ingredientFactory.createSalt();
System.out.println("放入" + salt.put());
}
}
TomatoEgg.java:
public class TomatoEgg extends Food {
public TomatoEgg(IngredientFactory ingredientFactory) {
super(ingredientFactory);
}
@Override
public void putSeasoning() {
Salt salt = ingredientFactory.createSalt();
System.out.println("放入" + salt.put());
}
}
然后，定义抽象工厂：
AbstractHotal.java:
public abstract class AbstractHotal {
public Food saleFood(String foodName) {
Food food = createFood(foodName);
food.putSeasoning();
food.fry();
return food;
}
public abstract Food createFood(String foodName);
}
然后，实现抽象工厂：
ShangHaiHotal.java:
public class ShangHaiHotal extends AbstractHotal {
@Override
public Food createFood(String foodName) {
IngredientFactory ingredient = new ShangHaiIngredientFactory();
switch(foodName) {
case "KungPaoChicken":
return new KungPaoChicken(ingredient);
case "TomatoEgg":
return new TomatoEgg(ingredient);
default:
return null;
}
}
}
SiChuanHotal.java:
public class SiChuanHotal extends AbstractHotal {
@Override
public Food createFood(String foodName) {
IngredientFactory ingredient = new SiChuanIngredientFactory();
switch(foodName) {
case "KungPaoChicken":
return new KungPaoChicken(ingredient);
case "TomatoEgg":
return new TomatoEgg(ingredient);
default:
return null;
}
}
}
最后附上测试代码：
Custom.java:
public class Custom {
public static void main(String ...args) {
AbstractHotal shangHaiHotal = new ShangHaiHotal();
AbstractHotal siChuanHotal = new SiChuanHotal();
Food shangHaiKungPaoChicken = shangHaiHotal.saleFood("KungPaoChicken");
Food shangHaiTomatoEgg = shangHaiHotal.saleFood("TomatoEgg");
Food siChuanKungPaoChicken = siChuanHotal.saleFood("KungPaoChicken");
Food siChuanTomatoEgg = siChuanHotal.saleFood("TomatoEgg");
shangHaiKungPaoChicken.eat();
shangHaiTomatoEgg.eat();
siChuanKungPaoChicken.eat();
siChuanTomatoEgg.eat();
}
}