抽象工厂模式

1、抽象工厂模式简介

抽象工厂模式(Abstract Factory Pattern)在工厂模式尚添加了一个创建不同工厂的抽象接口(抽象类或接口实现)，该接口可叫做超级工厂。在使用过程中，我们首先通过抽象接口创建不同的工厂对象，然后根据不同的工厂对象创建不同的对象。

我们可以将工厂模式理解为针对一个产品维度进行分类，比如上述工厂模式下的苹果手机和华为手机；而抽象工厂模式针对的是多个产品维度的分类，比如苹果公司既制造苹果手机又制造苹果笔记本电脑，同样，华为公司既制造华为手机也制造华为笔记本电脑。

在同一个厂商有多个维度的产品时，如果使用工厂模式，则势必会存在多个独立的工厂，这样的话，设计和物理世界是不对应的，正确的做法是通过抽象工厂模式来实现。我们可以将抽象工厂类比成厂商(苹果、华为)，将通过抽象工厂创建出来的工厂类比成不同产品的生产线(手机生产线、笔记本电脑生产线)，在需要生产产品时根据抽象工厂生产。

工厂模式定义了工厂方法来实现不同厂商手机的制造。可是问题来了，我们知道苹果公司和华为公司不仅制造手机，还制造电脑。如果使用工厂模式，就需要实现两个工厂类，并且这两个工厂类没有多大关系，这样的设计显然不够优雅，那么如何实现呢？使用抽象工厂就能很好地解决上述问题。我们定义一个抽象工厂，在抽象工厂中定义好要生产的产品(手机或者电脑)，然后在抽象工厂的实现类中根据不同类型的产品和产品规格生产不同的产品返回给用户。

2、具体实现

第1类产品的手机接口及其实现类的定义如下：

public interface Phone {
    String call();
}

public class PhoneApple implements Phone {
    @Override
    public String call() {
        return "call somebody by apple phone";
    }
}

public class PhoneHuaWei implements Phone {
    @Override
    public String call() {
        return "call somebody by huawei phone";
    }
}

以上代码定义了Phone的接口及其实现类PhoneApple和PhoneHuaWei。在该接口中定义了一个打电话的方法call()，实现类根据其品牌打印相关信息。

第1类产品的手机工厂类的定义如下：

public class PhoneFactory extends AbstractFactory{
    @Override
    public Phone createPhone(String brand) {
        if("HuaWei".equals(brand)){
            return new PhoneHuaWei();
        }else if("Apple".equals(brand)){
            return new PhoneApple();
        }else{
            return null;
        }
    }

    @Override
    public Computer createComputer(String brand) {
        return null;
    }
}

以上代码定义了PhoneFactory的手机工厂类，该类继承了AbstractFactory并实现了方法createPhone(),createPhone()根据不同的此参数实例化不同品牌的手机类并返回。在createPhone()的参数为“HuaWei”时，工厂类为我们实例化一个PhoneHuaWei类的实例并返回；在createPhone()的参数为"Apple"时，工厂类为我们实例化一个PhoneApple类的实例并返回，这样便满足了工厂根据不同参数生产不同产品的需求。

第2类产品的电脑接口及实现类的定义如下：

public interface Computer {
    String internet();
}

public class ComputerApple implements Computer {
    @Override
    public String internet() {
        return "surf the internet by apple computer";
    }
}

public class ComputerHuaWei implements Computer {
    @Override
    public String internet() {
        return "surf the internet by huawei computer";
    }
}

以上代码定义了Computer的电脑接口及其实现类ComputerApple和ComputerHuaWei。在该接口中定义了一个上网的方法internet()，实现类根据其品牌打印相关信息。

第2类产品的电脑工厂类定义如下：

public class ComputerFactory extends AbstractFactory {
    @Override
    public Phone createPhone(String brand) {
        return null;
    }

    @Override
    public Computer createComputer(String brand) {
        if("HuaWei".equals(brand)){
            return new ComputerHuaWei();
        }else if("Apple".equals(brand)){
            return new ComputerApple();
        }else{
            return null;
        }
    }
}

以上代码定义了ComputerFactory的手机工厂类，该类继承了AbstractFactory并实现了方法createComputer(),createComputer()根据不同的此参数实例化不同品牌的电脑类并返回。在createComputer()的参数为“HuaWei”时，工厂类为我们实例化一个ComputerHuaWei类的实例并返回；在createComputer()的参数为"Apple"时，工厂类为我们实例化一个ComputerApple类的实例并返回，这样便满足了工厂根据不同参数生产不同产品的需求。

抽象工厂的定义如下：

public abstract class AbstractFactory {
    public abstract Phone createPhone(String brand);
    public abstract Computer createComputer(String brand);
}

以上代码定义了抽象类AbstractFactory，这个类是抽象工厂的核心类，它定义了两个方法createPhone()和createComputer()，用户在需要手机时调用其createPhone()构造一个手机(华为或者苹果品牌)即可，用户在需要电脑时调用其createComputer()构造一个电脑(华为或者苹果品牌)即可。

使用抽象工厂：

//使用抽象工厂
public static void main(String[] args) {
    PhoneFactory phoneFactory = new PhoneFactory();
    Phone huaWei = phoneFactory.createPhone("HuaWei");
    Phone apple = phoneFactory.createPhone("Apple");
    System.out.println(huaWei.call());
    System.out.println(apple.call());

    ComputerFactory computerFactory = new ComputerFactory();
    Computer computerHuaWei = computerFactory.createComputer("HuaWei");
    Computer computerApple = computerFactory.createComputer("Apple");
    System.out.println(computerHuaWei.internet());
    System.out.println(computerApple.internet());
}

以上代码使用了我们定义好的抽象工厂，在需要生产商品时，首先需要定义一个抽象的工厂类AbstractFactory，然后使用抽象的工厂类生产不同的工厂类，最终根据不同的工厂生产不同的产品。运行结果如下：