抽象工厂模式

Posted 2022-02-02 glsy

一、模式名

抽象工厂， 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. 存在多种多组产品