Java 设计模式 — 抽象工厂模式(2)

一、谈谈抽象工厂模式

抽象工厂模式是关于一个超级工厂创建其他工厂，这个超级工厂又被称为其它工厂的工厂。显然，这种设计模式属于创建型模式，它同时也提供了创建对象的最佳方式。

说到这里，可能就会有人有疑惑，那么这与工厂模式有什么区别呢？我们先来看看抽象工厂模式到底是什么再去进行比对~

二、测试代码

抽象工厂模式的逻辑图

 创建测试代码的 Package 图

 1. 创建一个 Interface Package，里面创建两个接口，一个是 Car，一个是 Phone

public interface Car {
    void bookCar();
}

public interface Phone {
    void bookPhone();
}

2. 创建两个 Package，一个是 Car Package，一个是 Phone Package

<1> Phone Package中创建三个类，继承 Phone 接口，并实现接口中定义的方法

public class HuaWei implements Phone {
    @Override
    public void bookPhone() {
        System.out.println("Book a Huawei Phone.");
    }
}

public class XiaoMi implements Phone {
    @Override
    public void bookPhone() {
        System.out.println("Book a XiaoMi Phone.");
    }
}

public class Apple implements Phone {
    @Override
    public void bookPhone() {
        System.out.println("Book a Apple Phone.");
    }
}

<2> Car Package中创建三个类，继承 Car 接口，并实现接口中定义的方法

public class RedFlag implements Car {
    @Override
    public void bookCar() {
        System.out.println("Book a RedFlag Car.");
    }
}

public class BiYa implements Car {
    @Override
    public void bookCar() {
        System.out.println("Book a BiYa Car.");
    }
}

public class Gwm implements Car {
    @Override
    public void bookCar() {
        System.out.println("Book a Gwm Car.");
    }
}

<3> 创建抽象类来获取 Car 和 Phone 工厂

public abstract class AbstractFactory {
    public abstract Car getCar(String car);
    public abstract Phone getPhone(String phone);
}

<4> 创建一个 Factory Package，其中 CarFactory 和 PhoneFactory 分别继承抽象类，并实现其中的方法，对于 CarFactory 来说就是创建自己的 Car 的实例对象，对于 PhoneFactory 来说就是创建自己的 Phone 的实例对象。对于 ProductFactory 说，那么就是用来生产 CarFactory 和 PhoneFactory ，也就是实例化这两个工厂的工厂。

public class CarFactory extends AbstractFactory {
    @Override
    public Car getCar(String car) {
        switch (car) {
            case "BiYa":
                return new BiYa();
            case "Gwm":
                return new Gwm();
            case "RedFlag":
                return new RedFlag();
            default:
                return null;
        }
    }
 
    @Override
    public Phone getPhone(String phone) {
        return null;
    }
}

public class PhoneFactory extends AbstractFactory {
    @Override
    public Car getCar(String car) {
        return null;
    }
 
    @Override
    public Phone getPhone(String phone) {
        switch (phone) {
            case "HuaWei":
                return new HuaWei();
            case "XiaoMi":
                return new XiaoMi();
            case "Apple":
                return new Apple();
            default:
                return null;
        }
    }
}

public class ProductFactory {
    public static AbstractFactory getFactory(String product) {
        switch (product) {
            case "CarFactory":
                return new CarFactory();
            case "PhoneFactory":
                return new PhoneFactory();
            default:
                return null;
        }
    }
}

<5> 编写测试类

public class Test {
    public static void main(String[] args) {
        // 生产工厂的工厂实例化手机工厂
        AbstractFactory phoneFactory = ProductFactory.getFactory("PhoneFactory");
 
        // HuaWei
        Phone huaWei = Objects.requireNonNull(phoneFactory).getPhone("HuaWei");
        huaWei.bookPhone();
 
        // XiaoMi
        Phone xiaoMi = phoneFactory.getPhone("XiaoMi");
        xiaoMi.bookPhone();
 
        // Apple
        Phone apple = phoneFactory.getPhone("Apple");
        apple.bookPhone();
 
        System.out.println("<====================>");
        
        // 生产工厂的工厂加工汽车工厂
        AbstractFactory carFactory = ProductFactory.getFactory("CarFactory");
        
        // BiYa
        Car biYa = Objects.requireNonNull(carFactory).getCar("BiYa");
        biYa.bookCar();
 
        // Gwm
        Car gwm = carFactory.getCar("Gwm");
        gwm.bookCar();
 
        // RedFlag
        Car redFlag = carFactory.getCar("RedFlag");
        redFlag.bookCar();
 
    }
}

6. 运行结果

Book a Huawei Phone.
Book a XiaoMi Phone.
Book a Apple Phone.
<====================>
Book a BiYa Car.
Book a Gwm Car.
Book a RedFlag Car.

相信，写到这里，我们可能大概对这两种设计模式的区别心里已经有了答案，我们在这里总结一下这两种设计模式的区别和联系：

1、工厂模式是生产单个同种类型的不同产品。

2、抽象工厂模式是生产不同类型的多种不同产品。在抽象工厂模式种，存在一个产品族的概念，是指不同产品在结构中功能相关联的产品组成的家族，同一产品族的不同产品由同一工厂生产，不同的工厂，生产的方式( 方法 )不同，如下图所示~

3、抽象工厂模式是对工厂模式的进一步封装，工厂模式下，只有一个抽象的产品类，对于抽象工厂模式，存在多个工厂，也就存在着多种抽象的产品类。