工厂模式（Factory Pattern）

我不是女神ヾ 2022-12-04 14:59 144阅读 0赞

### **23种设计模式系列目录** ###

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

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

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

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

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

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

**--------------------------------------------------------------------------------------------------------------------------**

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

**1. 工厂模式定义**

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

**3. 工厂模式代码实现**

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

**5. 工厂模式使用场景**

**--------------------------------------------------------------------------------------------------------------------------**

### **1. 工厂模式定义** ###

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

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

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

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

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

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

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NzU2Njgy_size_16_color_FFFFFF_t_70][]

**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. 工厂模式代码实现** ###

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NzU2Njgy_size_16_color_FFFFFF_t_70 1][]

**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"三种协议，可以把这三种协议作为产品类，共同实现一个接口。

[23_Singleton Pattern]: https://blog.csdn.net/qq_36756682/article/details/104422494
[23_Proxy Pattern]: https://blog.csdn.net/qq_36756682/article/details/108430743
[23_Adapter Pattern]: https://blog.csdn.net/qq_36756682/article/details/108458064
[23_Factory Pattern]: https://blog.csdn.net/qq_36756682/article/details/108463999
[23_Abstract Factory Pattern]: https://blog.csdn.net/qq_36756682/article/details/108470482
[23_Decorator Pattern]: https://blog.csdn.net/qq_36756682/article/details/108590027
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NzU2Njgy_size_16_color_FFFFFF_t_70]: /images/20221123/efb060b08f894126956b46461be96b8f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NzU2Njgy_size_16_color_FFFFFF_t_70 1]: /images/20221123/dc5491f9f79f4bd89d8e735e566ad7ea.png