抽象工厂模式

一、模式名

抽象工厂， Abstract Factory

二、解决的问题

抽象工厂由“抽象”和"工厂"两个词组成，前者代表了使用了抽象类，后者代表了实现了工厂组装零件的模式。都知道，工厂完成零部件的生产后，再组装成对应的产品，抽象工厂正是实现了这个过程。

抽象工厂用于存在大量可拓展组件，并需要组装这些组件的场景。

三、解决方案

抽象工厂模式的UML图如下所示。

代码如下：

public class AbstractFactoryExer {
    public static void main(String[] args) {
        AbstractPhoneFactory factory = AbstractPhoneFactory.getFactory(2);
        AbstractCamera camera = factory.createCamera();
        AbstractMicrophone microphone = factory.createMicrophone();
        AbstractScreen screen = factory.createScreen();

        screen.show();
        microphone.talk();
        camera.photo();
    }
}

// 摄像头抽象类
abstract class AbstractCamera {
    abstract void photo();
}

// 屏幕抽象类
abstract class AbstractScreen {
    abstract void show();
}

// 麦克风抽象类
abstract class AbstractMicrophone {
    abstract void talk();
}

// 抽象工厂抽象类
abstract class AbstractPhoneFactory {
    abstract AbstractCamera createCamera();
    abstract AbstractScreen createScreen();
    abstract AbstractMicrophone createMicrophone();
    // 获取工厂
    static AbstractPhoneFactory getFactory(int type) {
        if (type == 0) {
            return new Huawei();
        } else if (type == 1) {
            return new Xiaomi();
        } else {
            return new Apple();
        }
    }
}

class SonyCamera extends AbstractCamera {
    @Override
    void photo() {
        System.out.println("photo by sony camera");
    }
}

class LeicaCamera extends AbstractCamera {
    @Override
    void photo() {
        System.out.println("photo by leica camera");
    }
}

class CanonCamera extends AbstractCamera {
    @Override
    void photo() {
        System.out.println("photo by canon camera");
    }
}

class KangningScreen extends AbstractScreen {
    @Override
    void show() {
        System.out.println("kangning show");
    }
}

class JDFScreen extends AbstractScreen {
    @Override
    void show() {
        System.out.println("jdf show");
    }
}

class SharpScreen extends AbstractScreen {
    @Override
    void show() {
        System.out.println("sharp show");
    }
}

class NingdeMicrophone extends AbstractMicrophone {
    @Override
    void talk() {
        System.out.println("ningde talk");
    }
}

class LenovoMicrophone extends AbstractMicrophone {
    @Override
    void talk() {
        System.out.println("lenovo talk");
    }
}

class FeTriangleMicrophone extends AbstractMicrophone {
    @Override
    void talk() {
        System.out.println("fetriangle talk");
    }
}

class Huawei extends AbstractPhoneFactory {

    public Huawei() {
        System.out.println("huawei");
    }

    @Override
    AbstractCamera createCamera() {
        return new LeicaCamera();
    }

    @Override
    AbstractScreen createScreen() {
        return new SharpScreen();
    }

    @Override
    AbstractMicrophone createMicrophone() {
        return new NingdeMicrophone();
    }
}

class Xiaomi extends AbstractPhoneFactory {

    public Xiaomi() {
        System.out.println("xiaomi");
    }

    @Override
    AbstractCamera createCamera() {
        return new SonyCamera();
    }

    @Override
    AbstractScreen createScreen() {
        return new JDFScreen();
    }

    @Override
    AbstractMicrophone createMicrophone() {
        return new FeTriangleMicrophone();
    }
}

class Apple extends AbstractPhoneFactory {

    public Apple () {
        System.out.println("apple");
    }

    @Override
    AbstractCamera createCamera() {
        return new CanonCamera();
    }

    @Override
    AbstractScreen createScreen() {
        return new SharpScreen();
    }

    @Override
    AbstractMicrophone createMicrophone() {
        return new FeTriangleMicrophone();
    }
}

抽象工厂模式在某些形式上和工厂方法模式很像，但是工厂方法模式只用于存在一组产品的情况，本质上不太符合工厂的特点，一般的工厂都会生产不止一组产品，一般都会有多种产品，所以提出了抽象工厂模式。

抽象工厂模式可以用于存在多种产品的情景下，比如上面举的手机厂商的例子，像华为、小米、苹果等手机厂商，负责手机设计和组装的，涉及的手机零部件有很多，可能某些手机厂商会使用同一个下游公司的产品。这样使用抽象工厂模式，可以方便地构造新的工厂。

抽象工厂模式可以方便地新增工厂，但是如果需要新增产品，需要修改的地方会有很多。

常用场景：

1. 存在多种多组产品