抽象工厂模式（Abstract Factory Pattern）

Posted 2021-07-23 顧棟

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了抽象工厂模式（Abstract Factory Pattern）相关的知识，希望对你有一定的参考价值。

文章目录

抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式的定义

是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族。

使用抽象工厂模式一般要满足以下条件。

系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
系统一次只可能消费其中某一族产品，即同族的产品一起使用。

抽象工厂模式的优点

抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下。

可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
当增加一个新的产品族时不需要修改原代码，满足开闭原则。
封装性，每一个产品的实现类不是工厂类的高层模块关心的，高层模块关心接口，抽象类，工厂类需要关心如何创造对象。
产品族类的约束非公开状态，产品族的约束是在工厂类里面实现的。

抽象工厂模式的缺点

当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。

抽象工厂模式的结构

抽象工厂模式的主要角色如下。

抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

抽象工厂模式的实现

产品采用抽象类实现方式

public abstract class AbstractProductA {
    public void shareMethod() {
        System.out.println("A类产品共性方法");
    }

    /**
     * 每个产品的同名方法，不同实现
     */
    public abstract void doSomething();
}

public abstract class AbstractProductB {

    public void shareMethod() {
        System.out.println("B类产品共性方法");
    }

    /**
     * 每个产品的同名方法，不同实现
     */
    public abstract void doSomething();
}

public class ProductA1 extends AbstractProductA {
    /**
     * 每个产品的同名方法，不同实现
     */
    @Override
    public void doSomething() {
        System.out.println("A类产品A1");
    }
}

public class ProductA2 extends AbstractProductA {
    /**
     * 每个产品的同名方法，不同实现
     */
    @Override
    public void doSomething() {
        System.out.println("A类产品A2");
    }
}

public class ProductB1 extends AbstractProductB {
    /**
     * 每个产品的同名方法，不同实现
     */
    @Override
    public void doSomething() {
        System.out.println("B类产品B1");
    }
}

public class ProductB2 extends AbstractProductB {
    /**
     * 每个产品的同名方法，不同实现
     */
    @Override
    public void doSomething() {
        System.out.println("B类产品B2");
    }
}

public abstract class AbstractCreator {
    /**
     * 创建A类的产品
     */
    public abstract AbstractProductA createA();

    /**
     * 创建B类的产品
     */
    public abstract AbstractProductB createB();
}

public class Creator1 extends AbstractCreator {
    /**
     * 创建A类的A1产品
     */
    @Override
    public AbstractProductA createA() {
        return new ProductA1();
    }

    /**
     * 创建B类的B1产品
     */
    @Override
    public AbstractProductB createB() {
        return new ProductB1();
    }
}

public class Creator2 extends AbstractCreator{
    /**
     * 创建A类的A2产品
     */
    @Override
    public AbstractProductA createA() {
        return new ProductA2();
    }

    /**
     * 创建B类的B2产品
     */
    @Override
    public AbstractProductB createB() {
        return new ProductB2();
    }
}

    public static void main(String[] args) {
        AbstractCreator c1 = new Creator1();
        AbstractCreator c2 = new Creator2();

        AbstractProductA a1 = c1.createA();
        AbstractProductA a2 = c2.createA();
        AbstractProductB b2 = c2.createB();
        AbstractProductB b1 = c1.createB();

        a1.doSomething();
        a2.doSomething();
        b1.doSomething();
        b2.doSomething();
    }

产品采用接口实现方式

public interface Computer {
    /**
     * 上网
     */
    void internet();
}

public interface Phone {
    /**
     * 打电话
     */
    void call();
}

public class AppleComputer implements Computer {
    /**
     * 上网
     */
    @Override
    public void internet() {
        System.out.println("AppleComputer internet");
    }
}

public class ApplePhone implements Phone{
    /**
     * 打电话
     */
    @Override
    public void call() {
        System.out.println("ApplePhone call");
    }
}

public class HuaWeiComputer implements Computer{

    /**
     * 上网
     */
    @Override
    public void internet() {
        System.out.println("HuaWeiComputer internet");
    }
}

public class HuaWeiPhone implements Phone {
    /**
     * 打电话
     */
    @Override
    public void call() {
        System.out.println("HuaWeiPhone call");
    }
}

public abstract class AbstractFactory {
    /**
     * 创建手机
     */
    public abstract Phone createPhone(String brand);

    /**
     * 创建电脑
     */
    public abstract Computer createComputer(String brand);
}

public class ComputerFactory extends AbstractFactory {

    /**
     * 创建手机
     *
     * @param brand
     */
    @Override
    public Phone createPhone(String brand) {
        return null;
    }

    /**
     * 创建电脑
     *
     * @param brand
     */
    @Override
    public Computer createComputer(String brand) {
        if ("Apple".equals(brand)) {
            return new AppleComputer();
        } else if ("Huawei".equals(brand)) {
            return new HuaWeiComputer();
        } else {
            return null;
        }

    }
}

public class PhoneFactory extends AbstractFactory {
    /**
     * 创建手机
     *
     * @param brand
     */
    @Override
    public Phone createPhone(String brand) {
        if ("Apple".equals(brand)) {
            return new ApplePhone();
        } else if ("Huawei".equals(brand)) {
            return new HuaWeiPhone();
        } else {
            return null;
        }
    }

    /**
     * 创建电脑
     *
     * @param brand
     */
    @Override
    public Computer createComputer(String brand) {
        return null;
    }
}

public static void main(String[] args) {
    AbstractFactory phoneFactory = new PhoneFactory();
    AbstractFactory computerFactory = new ComputerFactory();
    Phone phone1 = phoneFactory.createPhone("Apple");
    Phone phone2 = phoneFactory.createPhone("Huawei");
    Computer computer1 = computerFactory.createComputer("Apple");
    Computer computer2 = computerFactory.createComputer("Huawei");
    computer1.internet();
    computer2.internet();
    phone1.call();
    phone2.call();
}