工厂模式面试题

001什么是工厂设计模式？

工厂模式提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。实现了创建者和调用者分离，工厂模式分为简单工厂、工厂方法、抽象工厂模式。

002什么是简单工厂模式？

简单工厂模式又叫静态方法模式（因为工厂类定义了一个静态方法）现实生活中，工厂是负责生产产品的；同样在设计模式中，简单工厂模式我们可以理解为负责生产对象的一个类，称为“工厂类”。

003简单工厂模式解决的问题？

将“类实例化的操作”与“使用对象的操作”分开，让使用者不用知道具体参数就可以实例化出所需要的“产品”类，从而避免了在客户端代码中显式指定，实现了解耦。即使用者可直接消费产品而不需要知道其生产的细节

004简单工厂设计模式的实现。

简单工厂模式：把对象的创建放到一个工厂类中，通过参数来创建不同的对象。

/**
 * 简单工厂类
 */
public class SimpleFactory {
    /**
     * 生产工厂
     */
    public static OSSConfig createOSSConfig(String name) {
        OSSConfig config = null;
        switch (name) {
            case "alibaba":
                config = new AlibabaOSSConfig();
                break;
            case "tencent":
                config = new TencentOSSConfig();
                break;
            default:
                break;
        }
        return config;
    }
}

005简单工厂模式的优点？

将创建实例的工作与使用实例的工作分开，使用者不必关心类对象如何创建，实现了解耦；
把初始化实例时的工作放到工厂里进行，使代码更容易维护。 更符合面向对象的原则 & 面向接口编程，而不是面向实现编程。

006简单工厂模式的缺点？

1)工厂类集中了所有实例（产品）的创建逻辑，一旦这个工厂不能正常工作，整个系统都会受到影响；
2)违背“开放 - 关闭原则”，一旦添加新产品就不得不修改工厂类的逻辑，这样就会造成工厂逻辑过于复杂。
3)简单工厂模式由于使用了静态工厂方法，静态方法不能被继承和重写，会造成工厂角色无法形成基于继承的等级结构。

007简单工厂模式的应用场景？

客户如果只知道传入工厂类的参数，对于如何创建对象的逻辑不关心时；
当工厂类负责创建的对象（具体产品）比较少时。

008什么是工厂方法模式？

工厂方法模式，又称工厂模式、多态工厂模式和虚拟构造器模式，通过定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。

009工厂方法模式的具体实现。

工厂方法模式: 每种产品由一种工厂来创建，一个工厂处理一个对象。
角色组成
1. 抽象工厂: 定义工厂类所具有的基本的操作
2. 具体工厂：该类必须继承抽象工厂，实现抽象工厂定义的方法，返回一个对象
3. 抽象产品：定义了抽象产品具有的基本操作
4. 产品实现类：实现抽象产品类对定义的抽象方法，和具体工厂一一对应；

/**
 * 抽象产品: 配置接口
 */
interface OSSConfig {
    /**
     * 初始化OSS配置
     */
    void init();
}
/**
 * 具体产品: 阿里云OSS配置
 */
class AlibabaOSSConfig implements OSSConfig {
    @Override
    public void init() {
        System.out.println("初始化--阿里云--OSS配置");
    }
}
/**
 * 具体产品: 腾讯云OSS配置
 */
class TencentOSSConfig implements OSSConfig {
    @Override
    public void init() {
        System.out.println("初始化--腾讯云--OSS配置");
    }
}
/**
 * 抽象工厂
 */
interface Factory {
    OSSConfig createOSSConfig();
}
/**
 * 具体工厂: 腾讯云工厂
 */
class TencentOSSFactory implements Factory {
    @Override
    public OSSConfig createOSSConfig() {
        return new TencentOSSConfig();
    }
}
/**
 * 具体工厂: 阿里云工厂
 */
class AlibabaOSSFactory implements Factory {
    @Override
    public OSSConfig createOSSConfig() {
        return new AlibabaOSSConfig();
    }
}
/**
 * 工厂设计模拟类
 */
public class FactoryMethod {
    public static void main(String[] args) {
        AlibabaOSSFactory alibabaOSSFactory = new AlibabaOSSFactory();
        OSSConfig alibabaConifg = alibabaOSSFactory.createOSSConfig();
        alibabaConifg.init();

        TencentOSSFactory tencentOSSFactory = new TencentOSSFactory();
        OSSConfig tencentConfig = tencentOSSFactory.createOSSConfig();
        tencentConfig.init();
    }
}

010工厂方法模式解决的问题？

工厂方法模式把具体产品的创建推迟到工厂类的子类（具体工厂）中，此时工厂类不再负责所有产品的创建，而只是给出具体工厂必须实现的接口，这样工厂方法模式在添加新产品的时候就不修改工厂类逻辑而是添加新的工厂子类，符合开放封闭原则，克服了简单工厂模式中缺点。

011工厂方法模式的优点？

1)更符合开-闭原则
新增一种产品时，只需要增加相应的具体产品类和相应的工厂子类即可
简单工厂模式需要修改工厂类的判断逻辑
2)符合单一职责原则
每个具体工厂类只负责创建对应的产品
简单工厂中的工厂类存在复杂的switch逻辑判断
3)不使用静态工厂方法，可以形成基于继承的等级结构。
简单工厂模式的工厂类使用静态工厂方法
总结：工厂模式可以说是简单工厂模式的进一步抽象和拓展，在保留了简单工厂的封装优点的同时，让扩展变得简单，让继承变得可行，增加了多态性的体现。

012工厂方法模式的缺点？

1)添加新产品时，除了增加新产品类外，还要提供与之对应的具体工厂类，系统类的个数将成对增加，在一定程度上增加了系统的复杂度；同时，有更多的类需要编译和运行，会给系统带来一些额外的开销；
2)由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。
3)虽然保证了工厂方法内的对修改关闭，但对于使用工厂方法的类，如果要更换另外一种产品，仍然需要修改实例化的具体工厂类；一个具体工厂只能创建一种具体产品。

013工厂方法模式的应用场景。

1)当一个类不知道它所需要的对象的类时，在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可；
2)当一个类希望通过其子类来指定创建对象时，在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。
3)将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。

014什么是抽象工厂模式？

抽象工厂模式，即Abstract Factory Pattern，提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类；具体的工厂负责实现具体的产品实例。 允许使用抽象的接口来创建一组相关产品，而不需要知道或关心实际生产出的具体产品是什么，这样就可以从具体产品中被解耦。

015抽象工厂模式的具体实现。

抽象工厂模式：工厂方法模式的进一步延伸。
角色组成
1. 抽象工厂: 定义工厂类所具有的基本的操作
2. 具体工厂：具体工厂实现了抽象工厂，每个工厂方法返回多个具体对象
3. 抽象类接口：定义了产品具有的基本操作,提供一组所有类都具有的业务方法
4. 抽象类：用于实现抽象接口所定义的业务方法,只做抽象接口，具体由产品实现类处理
5. 产品实现类：实现抽象产品类对定义的抽象方法，和具体工厂一对多；

/**
 * 抽象产品: 配置接口
 */
interface OSSConfig {
    /**
     * 初始化OSS配置
     */
    void init();
}
/**
 * 具体产品: 阿里云OSS配置
 */
abstract class AlibabaOSSConfig implements OSSConfig {
    public abstract void init();
}
/**
 * 具体产品: 阿里云OSS配置Test环境
 */
class AlibabaTstOSSConfig extends AlibabaOSSConfig {
    @Override
    public void init() {
        System.out.println("初始化--阿里云--test环境--OSS配置");
    }
}
/**
 * 具体产品: 阿里云OSS配置生产环境
 */
class AlibabaPreOSSConfig extends AlibabaOSSConfig {
    @Override
    public void init() {
        System.out.println("初始化--阿里云--Pre环境--OSS配置");
    }
}
/**
 * 抽象产品: 腾讯云OSS配置
 */
abstract class TencentOSSConfig implements OSSConfig {
    public abstract void init();
}
/**
 * 抽象产品: 腾讯云OSS配置
 */
class TencentProOSSConfig extends TencentOSSConfig {
    @Override
    public void init() {
        System.out.println("初始化--腾讯云--Pre环境--OSS配置");
    }
}
/**
 * 抽象工厂
 */
interface Factory {
    /**
     * 获取测试环境配置
     */
    OSSConfig createOSSTestConfig();

    /**
     * 获取生成环境配置
     */
    OSSConfig createOSSPreConfig();
}
/**
 * 具体工厂: 腾讯云工厂
 */
class TencentOSSFactory implements Factory {

    @Override
    public OSSConfig createOSSTestConfig() {
        return null;
    }

    @Override
    public OSSConfig createOSSPreConfig() {
        return new TencentProOSSConfig();
    }
}
/**
 * 具体工厂: 腾讯云工厂
 */
class AlibabaOSSFactory implements Factory {

    @Override
    public OSSConfig createOSSTestConfig() {
        return new AlibabaTstOSSConfig();
    }

    @Override
    public OSSConfig createOSSPreConfig() {
        return new AlibabaPreOSSConfig();
    }
}
/**
 * 工厂设计模拟类
 * 产品接口可以定义OSS配置的操作接口，不同的厂商实现都去实现接口，通过工厂动态生成配置
 */
public class AbstractFactory {
    public static void main(String[] args) {
        // 阿里云oss配置
        AlibabaOSSFactory alibabaOSSFactory = new AlibabaOSSFactory();
        OSSConfig alibabaConifg = alibabaOSSFactory.createOSSPreConfig();
        alibabaConifg.init();
        OSSConfig alibabaTestConifg = alibabaOSSFactory.createOSSTestConfig();
        alibabaTestConifg.init();
		
		// 腾云云oss配置
        TencentOSSFactory tencentOSSFactory = new TencentOSSFactory();
        OSSConfig tencentConifg = tencentOSSFactory.createOSSPreConfig();
        tencentConifg.init();
    }
}

016抽象工厂模式的优点。

1)降低耦合
抽象工厂模式将具体产品的创建延迟到具体工厂的子类中，这样将对象的创建封装起来，可以减少客户端与具体产品类之间的依赖，从而使系统耦合度低，这样更有利于后期的维护和扩展；
2)更符合开-闭原则
新增一种产品类时，只需要增加相应的具体产品类和相应的工厂子类即可
3)符合单一职责原则
每个具体工厂类只负责创建对应的产品
4)不使用静态工厂方法，可以形成基于继承的等级结构。

017抽象工厂模式的缺点。

抽象工厂模式很难支持新种类产品的变化。这是因为抽象工厂接口中已经确定了可以被创建的产品集合，如果需要添加新产品，此时就必须去修改抽象工厂的接口，这样就涉及到抽象工厂类的以及所有子类的改变，这样也就违背了“开发——封闭”原则。

018抽象工厂模式的应用场景。

1)一个系统不要求依赖产品类实例如何被创建、组合和表达的表达，这点也是所有工厂模式应用的前提。
2)这个系统有多个系列产品，而系统中只消费其中某一系列产品
3)系统要求提供一个产品类的库，所有产品以同样的接口出现，客户端不需要依赖具体实现。

019工厂模式和抽象工厂模式对比？

工厂方法模式：具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：具体工厂类可以创建多个具体产品类的实例。