Java设计模式三：深入理解工厂模式

红太狼 2023-07-24 11:37 19阅读 0赞

## 前言 ##

工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式，根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建，是一种创建型模式。**工厂模式屏蔽产品实现细节，需要什么产品，直接在工厂获取。**

工厂模式涉及类：创建产品的接口、产品接口实现类、工厂类

[https://blog.csdn.net/yanmiao0715/article/details/82804949][https_blog.csdn.net_yanmiao0715_article_details_82804949]

[https://www.jianshu.com/p/21d56cdd136c][https_www.jianshu.com_p_21d56cdd136c]

## **工厂模式使用场景：** ##

1.工厂模式的目的是为了实现解耦，**将对象的创建和使用分开，即应用程序将对象的创建和初始化职责交给工厂对象**。若一个对象A想要调用对象B时，如果直接通过new关键字来创建一个B实例，然后调用B实例，这样做的不好处是，当需求变更，要将B实例换成C实例时，则需要修改所有new了该实例的方法。

2.降低代码重复。如果对象B的创建过程比较复杂，并且很多地方都用到了，那么很可能出现很多重复的代码，通过统一将创建对象B的代码放到工厂里面统一管理，可以减少代码的重复率，同时也方便维护。相比于构造函数来说，复杂的初始化，会使得构造函数非常的复杂。

3.工厂模式将创建和使用分离，使用者不需要知道具体的创建过程，只需要使用即可。

### 1. 简单工厂模式 ###

该模式对对象创建管理方式最为简单，因为其仅仅简单的对不同类对象的创建进行了一层薄薄的封装。该模式通过向工厂传递类型来指定要创建的对象，其UML类图如下：

![format_png][]

**下面我们使用手机生产来讲解该模式：**

**Phone类**：手机标准接口类

public interface Phone {
        void make();
    }

**MiPhone类**：制造小米手机（Product1）实现类

public class MiPhone implements Phone {
        public MiPhone() {
            this.make();
        }
        @Override
        public void make() {
            // TODO Auto-generated method stub
            System.out.println("make xiaomi phone!");
        }
    }

**IPhone类**：制造苹果手机（Product2）实现类

public class IPhone implements Phone {
        public IPhone() {
            this.make();
        }
        @Override
        public void make() {
            // TODO Auto-generated method stub
            System.out.println("make iphone!");
        }
    }

**PhoneFactory类**：手机代工厂（Factory）

public class PhoneFactory {
        public Phone makePhone(String phoneType) {
            if(phoneType.equalsIgnoreCase("MiPhone")){
                return new MiPhone();
            }
            else if(phoneType.equalsIgnoreCase("iPhone")) {
                return new IPhone();
            }
            return null;
        }
    }

**演示：**

public class Demo {
        public static void main(String[] arg) {
            PhoneFactory factory = new PhoneFactory();
            Phone miPhone = factory.makePhone("MiPhone");            // make xiaomi phone!
            IPhone iPhone = (IPhone)factory.makePhone("iPhone");    // make iphone!
        }
    }

### 2. 工厂方法模式(Factory Method) ###

**和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂，【重点】也就是定义一个抽象工厂，其定义了产品的生产接口，但不负责具体的产品，将生产任务交给不同的派生类工厂。这样不用通过指定类型来创建对象了。**

![format_png 1][]

继续使用生产手机的例子来讲解该模式，其中和产品相关的Phone类、MiPhone类和IPhone类的定义不变。

**AbstractFactory类**：生产不同产品的工厂的抽象类

public interface AbstractFactory {
        Phone makePhone();
    }

**XiaoMiFactory类**：生产小米手机的工厂（ConcreteFactory1）

public class XiaoMiFactory implements AbstractFactory{
        @Override
        public Phone makePhone() {
            return new MiPhone();
        }
    }

**AppleFactory类**：生产苹果手机的工厂（ConcreteFactory2）

public class AppleFactory implements AbstractFactory {
        @Override
        public Phone makePhone() {
            return new IPhone();
        }
    }

**演示：**

public class Demo {
        public static void main(String[] arg) {
            AbstractFactory miFactory = new XiaoMiFactory();
            AbstractFactory appleFactory = new AppleFactory();
            miFactory.makePhone();            // make xiaomi phone!
            appleFactory.makePhone();        // make iphone!
        }
    }

### 3. 抽象工厂模式(Abstract Factory) ###

上面两种模式不管工厂怎么拆分抽象，都只是针对一类产品**Phone**（AbstractProduct），如果要生成另一种产品PC，应该怎么表示呢？

最简单的方式是把2中介绍的工厂方法模式完全复制一份，不过这次生产的是PC。但同时也就意味着我们要完全复制和修改Phone生产管理的所有代码，显然这是一个笨办法，并不利于扩展和维护。

**抽象工厂模式通过在AbstarctFactory中增加创建产品的接口，并在具体子工厂中实现新加产品的创建，当然前提是子工厂支持生产该产品。否则继承的这个接口可以什么也不干。**

其UML类图如下：

![format_png 2][]

继续通过小米和苹果产品生产的例子来解释该模式

**PC类**：定义PC产品的接口(AbstractPC)

public interface PC {
        void make();
    }

**MiPC类**：定义小米电脑产品(MIPC)

public class MiPC implements PC {
        public MiPC() {
            this.make();
        }
        @Override
        public void make() {
            // TODO Auto-generated method stub
            System.out.println("make xiaomi PC!");
        }
    }

**MAC类**：定义苹果电脑产品(MAC)

public class MAC implements PC {
        public MAC() {
            this.make();
        }
        @Override
        public void make() {
            // TODO Auto-generated method stub
            System.out.println("make MAC!");
        }
    }

下面需要修改工厂相关的类的定义：

**AbstractFactory类**：增加PC产品制造接口

public interface AbstractFactory {
        Phone makePhone();
        PC makePC();
    }

**XiaoMiFactory类**：增加小米PC的制造（ConcreteFactory1）

public class XiaoMiFactory implements AbstractFactory{
        @Override
        public Phone makePhone() {
            return new MiPhone();
        }
        @Override
        public PC makePC() {
            return new MiPC();
        }
    }

**AppleFactory类**：增加苹果PC的制造（ConcreteFactory2）

public class AppleFactory implements AbstractFactory {
        @Override
        public Phone makePhone() {
            return new IPhone();
        }
        @Override
        public PC makePC() {
            return new MAC();
        }
    }

**演示：**

public class Demo {
        public static void main(String[] arg) {
            AbstractFactory miFactory = new XiaoMiFactory();
            AbstractFactory appleFactory = new AppleFactory();
            miFactory.makePhone();            // make xiaomi phone!
            miFactory.makePC();                // make xiaomi PC!
            appleFactory.makePhone();        // make iphone!
            appleFactory.makePC();            // make MAC!
        }
    }

文章参考：

[https://www.cnblogs.com/yssjun/p/11102162.html][https_www.cnblogs.com_yssjun_p_11102162.html]

[https_blog.csdn.net_yanmiao0715_article_details_82804949]: https://blog.csdn.net/yanmiao0715/article/details/82804949
[https_www.jianshu.com_p_21d56cdd136c]: https://www.jianshu.com/p/21d56cdd136c
[format_png]: /images/20230528/726af6a482c148208a87f59514b928c0.png
[format_png 1]: /images/20230528/643d16bcd4af4c168711c2d3cae3456a.png
[format_png 2]: /images/20230528/3c8fdaba55e6406b95f15429d619194b.png
[https_www.cnblogs.com_yssjun_p_11102162.html]: https://www.cnblogs.com/yssjun/p/11102162.html