工厂模式（Factory Pattern）

23种设计模式系列目录

23种设计模式之单例模式（Singleton Pattern）

23种设计模式之代理模式（Proxy Pattern）

23种设计模式之适配器模式（Adapter Pattern）

23种设计模式之工厂模式（Factory Pattern）

23种设计模式之抽象工厂模式（Abstract Factory Pattern）

23种设计模式之装饰器模式（Decorator Pattern）

--------------------------------------------------------------------------------------------------------------------------

读完本篇文章将会了解以下问题

1. 工厂模式定义

2. 简单工厂模式代码实现

3. 工厂模式代码实现

4. 两种工厂模式的优缺点分析

5. 工厂模式使用场景

--------------------------------------------------------------------------------------------------------------------------

1. 工厂模式定义

       工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

       目的：定义一个工厂接口或抽象类，具体工厂类继承抽象类或实现工厂接口，使所需实例对象的创建过程延迟到工厂类进行。

       何时使用：明确地计划不同条件下创建不同实例，或者子类中构造函数参数复杂且我们并不需要了解那么多的参数时。

       如何解决：具体工厂类实现工厂接口或继承工厂抽象类，复写原有方法。

       关键代码：所需实例对象的创建过程在具体工厂类内实现。

2. 简单工厂模式代码实现

       简单工厂模式不属于23种设计模式，因为其工厂类创建方式采用静态方法创建，所以又叫静态工厂模式。

Computer类：电脑抽象类

public abstract class Computer {
    /**
     * 产品的抽象方法，由具体的产品类去实现
     */
    public abstract void start();
}

HpComputer类：惠普电脑类

public class HpComputer extends Computer{
    @Override
    public void start() {
        System.out.println("HpComputer is turnning on");
    }
}

LenovoComputer类：联想电脑类

public class LenovoComputer extends Computer{
    @Override
    public void start() {
        System.out.println("LenovoComputer is turnning on");
    }
}

ComputerFactory类：电脑工厂类

public class ComputerFactory {
    public static Computer createComputer(String type) {
        Computer mComputer = null;
        switch (type) {
            case "lenovo":
                mComputer = new LenovoComputer();
                break;
            case "hp":
                mComputer = new HpComputer();
                break;
            default:
                break;
        }
        return mComputer;
    }
}

测试方法：

public static void main(String[] args) {
        Computer lenovo = ComputerFactory.createComputer("lenovo");
        Computer hp = ComputerFactory.createComputer("hp");
        lenovo.start();
        hp.start();
}

3. 工厂模式代码实现

       工厂模式照比简单工厂模式来说，其改变为特定的产品由特定的工厂产生（惠普电脑工厂只生产惠普的电脑）。

Computer：电脑抽象类

public abstract class Computer {
    /**
     * 产品的抽象方法，由具体的产品类去实现
     */
    public abstract void start();
}

HpComputer：惠普电脑类

public class HpComputer extends Computer {
    @Override
    public void start() {
        System.out.println("HpComputer is turnning on");
    }
}

LenovoComputer：联想电脑类

public class LenovoComputer extends Computer {
    @Override
    public void start() {
        System.out.println("LenovoComputer is turnning on");
    }
}

Factory：抽象工厂类

public abstract class Factory {
    /**
     * 工厂的抽象方法，由具体的工厂类去实现
     */
    public abstract Computer createProduct();
}

HpComputerFactory：惠普电脑工厂类

public class HpComputerFactory extends Factory{
    @Override
    public Computer createProduct() {
        return new HpComputer();
    }
}

LenovoComputerFactory：联想电脑工厂类

public class LenovoComputerFactory extends Factory{
    @Override
    public Computer createProduct() {
        return new LenovoComputer();
    }
}

测试方法：

public class practice {
    public static void main(String[] args) {
        Factory hpComputerFactory = new HpComputerFactory();
        Factory lenovoComputerFactory = new LenovoComputerFactory();
        hpComputerFactory.createProduct().start();
        lenovoComputerFactory.createProduct().start();
    }
}

4. 两种工厂模式的优缺点分析

简单工厂优点：

         1、工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例。

         2、客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可。

简单工厂缺点：

         1、简单工厂模式会增加系统中类的个数，而且对于创建产品实例的判断都写在了工厂类里，在一定程序上增加了系统的复杂度和理解难度。

         2、系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，不利于系统的扩展和维护。

         3、简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。

工厂模式优点：

         1、一个调用者想创建一个对象，只要知道其名称就可以了。

         2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

         3、屏蔽产品的具体实现，调用者只关心产品的接口

工厂模式缺点：

         1、每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

5.工厂模式使用场景

        1、MyBatis数据源模块利用工厂模式生产数据源。

        2、设计一个连接服务器的框架，需要"POP3"、"IMAP"、"HTTP"三种协议，可以把这三种协议作为产品类，共同实现一个接口。