Factory工厂类设计模式

旧城等待， 2022-04-22 10:54 161阅读 0赞

> **文章最前**： 我是Octopus，这个名字来源于我的中文名--章鱼；我热爱编程、热爱算法、热爱开源。所有源码在我的个人[github][] ；这博客是记录我学习的点点滴滴，如果您对 Python、Java、AI、算法有兴趣，可以关注我的动态，一起学习，共同进步。

**相关文章：**

1.  [Command命令设计模式][Command]
2.  **[Singleton单例设计模式][Singleton]**
3.  **[Decorator装饰设计模式][Decorator]**
4.  **[Template模板模式][Template]**
5.  **[Strategy策略设计模式][Strategy]**
6.  **[Proxy代理设计模式][Proxy]**
7.  **[Factory工厂类设计模式][Factory]**
8.  **[设计模式的6大基本原则][6]**

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

**文章目录：**

1.简单工厂设计模式

2.创建实例工厂

3.抽象工厂

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

工厂模式属于创建型设计模式，它提供了一种创建对象的最佳方式。

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

### **1.简单工厂设计模式** ###

先定义个接口：

public interface Milk {
        /**
         * 获取一个标准产品
         * @return
         */
        public String getName();
    
    }

再定义接口的实现类1：

public class Mengniu implements Milk {
        @Override
        public String getName() {
            return "蒙牛";
        }
    }

定义接口的实现类2：

public class Sanlu implements  Milk{
        @Override
        public String getName() {
            return "三鹿";
        }
    }

定义接口的实现类3：

public class Telunsu implements Milk {
        @Override
        public String getName() {
            return "特仑苏";
        }
    }

定义接口实现类4：

public class Yili implements  Milk {
        @Override
        public String getName() {
            return "伊利";
        }
    }

**简单工厂实现类：**

public class SimpleFactory {
        public Milk getMilk(String name){
            if("特仑苏".equals(name)){
                return new Telunsu();
            }else if("伊利".equals(name)){
                return new Yili();
            }else if("蒙牛".equals(name)){
                return new Mengniu();
            }else {
                System.out.println("不能生产您所需的产品");
                return null;
            }
        }
    }

**测试简单工厂模式：**

public class SimpleFactoryTest {
        public static void main(String[] args) {
            //这个new的过程实际上一个比较复杂的过程
            //有人民币及不需要自己new了
           // System.out.println(new Telunsu().getName());
    
            //小作坊式的生产模式
            //用户本身不再关心生产的过程，而只需要关心这个结果
    
            //假如：特仑苏、伊利、蒙牛
            //成分配比都是不一样的
            SimpleFactory factory = new SimpleFactory();
    
            //把用户的需求告诉工厂
            //创建产品的过程隐藏了，对于用户而且完全不清楚是怎么产生的
            System.out.println(factory.getMilk("AAA"));
        }
    }

**定义**：一个创建产品对象的工厂接口，将实际创建工作推迟到子类工厂当中。

**问题描述**：简单工厂模式中，只要添加新的产品类，就得去修改工厂类，这样做势必违反了开闭原则。

**解决方案**：新增抽象工厂类，让抽象产品对应抽象工厂，让具体产品对应具体工厂，实际的创建工作推迟到子类工厂中去做。

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

### **2.创建实例工厂** ###

定义工厂实现类1：

public class MengniuFactory implements  Factory {
        @Override
        public Milk getMilk() {
            return new Mengniu();
        }
    }

定义工厂实现类2：

public class SanluFactory implements  Factory {
        @Override
        public Milk getMilk() {
            return new Sanlu();
        }
    }

定义工厂实现类3：

/**
     * 事情变得越来越专业
     *
     */
    public class TelunsuFactory implements Factory {
        @Override
        public Milk getMilk() {
            return new Telunsu();
        }
    }

定义工厂实现类4：

public class YiliFactory implements Factory {
        @Override
        public Milk getMilk() {
            return new Yili();
        }
    }

实现工厂模式：

/**
     * 工厂模型
     *
     */
    public interface Factory {
    
        //工厂必然具有生产产品技能，统一的产品出口
        Milk getMilk();
    
    }

测试实例工厂模式:

public class FactoryTest {
        public static void main(String[] args) {
            //System.out.println(new Factory().getMilk(););
            //货比三家
            //不知道谁好谁好谁坏
            //配置，可能会配置错
            Factory factory = new SanluFactory();
            System.out.println(factory.getMilk());
    
        }

分工明确，每种牛奶都有自己的生产流程和工序，用户只有选择权，没有决定权，内部细节对用户隐藏，扩展时候只需要扩展就好了，不必修改工厂类

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

### **3.抽象工厂** ###

**优点：**

1、抽象工厂模式隔离了具体类的生产，使得客户并不需要知道什么被创建。

2、当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

3、增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。

**缺点：**

增加新的产品等级结构很复杂，需要修改抽象工厂和所有的具体工厂类。

1.抽象工厂类：

/**
     *
     * 抽象工厂是用户的主入口
     * 在Spring中应用得最为广泛的一种设计模式
     * 易于扩展
     */
    public abstract class AbstractFactory {
    
        //公共的逻辑
        //方便于统一管理
    
        /**
         * 获得一个蒙牛品牌的牛奶
         * @return
         */
        public  abstract Milk getMengniu();
    
        /**
         * 获得一个伊利品牌的牛奶
         * @return
         */
        public abstract  Milk getYili();
    
        /**
         * 获得一个特仑苏品牌的牛奶
         * @return
         */
        public  abstract  Milk getTelunsu();
    
        public abstract Milk getSanlu();
    
    }

具体的工厂类：

public class MilkFactory extends  AbstractFactory {
        @Override
        public Milk getMengniu() {
            return new Mengniu();
        }
    
        @Override
        public Milk getYili() {
            return new Yili();
        }
    
        @Override
        public Milk getTelunsu() {
            return new Telunsu();
        }
    
        @Override
        public Milk getSanlu() {
            return new Sanlu();
        }
    }

具体的测试类：

public class AbstractFactoryTest {
        public static void main(String[] args) {
            MilkFactory factory = new MilkFactory();
            //对于用户而言，更加简单了
            //用户只有选择的权利了，保证了程序的健壮性
            System.out.println(factory.getSanlu());
        }
    }

扩展时候，需要修改抽象工厂和具体的类，违背了“开闭原则”

[github]: https://github.com/zhangyu345293721
[Command]: https://blog.csdn.net/zy345293721/article/details/82429423
[Singleton]: https://blog.csdn.net/zy345293721/article/details/82153881
[Decorator]: https://blog.csdn.net/zy345293721/article/details/81838635
[Template]: https://blog.csdn.net/zy345293721/article/details/83819394
[Strategy]: https://blog.csdn.net/zy345293721/article/details/81290896
[Proxy]: https://blog.csdn.net/zy345293721/article/details/81183998
[Factory]: https://blog.csdn.net/zy345293721/article/details/83716363
[6]: https://blog.csdn.net/zy345293721/article/details/83500802