每天一种设计模式之抽象工厂模式（Java实现）

每天一种设计模式之抽象工厂模式（Java实现）

概述

在了解抽象工厂模式之前我们应当先了解下工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象

工厂模式和抽象工厂模式的区别

两者没有太大的区别，唯一的区别就是抽象工厂在工厂模式的基础上又抽象出一个超级工厂(用于生产工厂)，生产出来的工厂的工作模式和工厂模式一模一样

示例

还是以麦当劳为例，我们准备给麦当劳开两座工厂：

• 养鸡厂
• 餐具厂

养鸡场能生产：

• 白羽鸡
• 黑羽鸡
• 黄羽鸡

餐具厂能生产：

• 杯子
• 餐盒

我们通过一个超级工厂来生产我们的工厂,然后通过工厂来生产我们对应的原材料

源码实现

首先我们定义一个食物接口Food

public interface Food{
   void printName();
}

三种鸡分别实现该接口

实现白羽鸡WhiteChicken

public class WhiteChicken implements Food{
	@override
	printName(){
		System.out.println("白羽鸡");
	}
}

实现黑羽鸡BlackChicken

public class BlackChicken implements Food{
	@override
	printName(){
		System.out.println("黑羽鸡");
	}
}

实现黄羽鸡YellowChicken

public class YellowChicken implements Food{
	@override
	printName(){
		System.out.println("黄羽鸡");
	}
}

定义一个食物工厂FoodFactory用于生产各种鸡

public class FoodFactory {
   public Food getFood(String foodType){       
      if(foodType.equalsIgnoreCase("白羽鸡")){
         return new WhiteChicken();
      } else if(foodType.equalsIgnoreCase("黑羽鸡")){
         return new BlackChicken();
      } else if(foodType.equalsIgnoreCase("黄羽鸡")){
         return new YellowChicken();
      }
      // 没有匹配值返回空
      return null;
   }
}

然后定义一个包装接口Wrapper

public interface Wrapper{
   void printName();
}

实现杯子Cup

public class Cup implements Wrapper{
	@override
	printName(){
		System.out.println("杯子");
	}
}

实现餐盒Box

public class Box implements Wrapper{
	@override
	printName(){
		System.out.println("餐盒");
	}
}

定义一个包装工厂WrapperFactory用于生产各种包装

// 生产包装的工厂
public class WrapperFactory {
    public Wrapper getWrapper(String wrapperType){
        if(wrapperType.equalsIgnoreCase("杯子")){
            return new Cup();
        } else if(wrapperType.equalsIgnoreCase("餐盒")){
            return new Box();
        }
        // 没有匹配值返回空
        return null;
    }
}

直到这里工厂模式和抽象工厂模式都没有任何区别

接下来定义一个抽象工厂类,包含了两种工厂的生产方法

// 抽象工厂,包含了工厂里的两个类的方法
public abstract class AbstractFactory {
    public abstract Food getFood(String food);
    public abstract Wrapper getWrapper(String wrapper) ;
}

改造两个工厂分别继承这个抽象类,实现自己对应的方法

// 生产各种鸡的工厂
public class FoodFactory extends AbstractFactory{
    @Override
    public Food getFood(String foodType){
        if(foodType.equalsIgnoreCase("白羽鸡")){
            return new WhiteChicken();
        } else if(foodType.equalsIgnoreCase("黑羽鸡")){
            return new BlackChicken();
        } else if(foodType.equalsIgnoreCase("黄羽鸡")){
            return new YellowChicken();
        }
        // 没有匹配值返回空
        return null;
    }

    @Override
    public Wrapper getWrapper(String wrapper) {
        return null;
    }
}

// 生产包装的工厂
public class WrapperFactory extends AbstractFactory{
    @Override
    public Food getFood(String food) {
        return null;
    }
    @Override
    public Wrapper getWrapper(String wrapperType){
        if(wrapperType.equalsIgnoreCase("杯子")){
            return new Cup();
        } else if(wrapperType.equalsIgnoreCase("餐盒")){
            return new Box();
        }
        // 没有匹配值返回空
        return null;
    }
}

创建专门用于生产产品的工厂FactoryProducer

// 生产工厂类,根据参数创建工厂,即创建工厂的工厂
public class FactoryProducer {
    public static AbstractFactory getFactory(String factoryType){
        if(factoryType.equalsIgnoreCase("Food")){
            return new FoodFactory();
        } else if(factoryType.equalsIgnoreCase("Wrapper")){
            return new WrapperFactory();
        }
        return null;
    }
}

创建Demo类验证我们的实验

// 测试抽象工厂模式
public class Demo {
    public static void main(String[] args) {
        // 获取食物工厂
        AbstractFactory foodFactory = FactoryProducer.getFactory("food");
        // 获取包装工厂
        AbstractFactory wrapperFactory = FactoryProducer.getFactory("wrapper");

        //用工厂生产餐盒+白羽鸡
        Wrapper box = wrapperFactory.getWrapper("餐盒");
        Food whiteChicken = foodFactory.getFood("白羽鸡");

        //打印测试
        System.out.println("生产了一个包装:");
        box.printName();
        System.out.println("生产了一个食物:");
        whiteChicken.printName();
    }
}

得到如下输出:

生产了一个包装:
餐盒
生产了一个食物:
白羽鸡

以上就是抽象工厂模式的所有内容!

我创建了一个开源项目涵盖了33种设计模式的源码,GitHub地址如下
项目地址