第一篇、工厂模式详解（三种）

Dear 丶 2022-03-02 14:28 195阅读 0赞

## 一、**什么是工厂设计模式？** ##

工厂设计模式，顾名思义，就是用来生产对象的，在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则，如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：**解耦**

本篇主要介绍三种工厂设计模式的使用：  
**1、简单工厂**  
**2、工厂方法**  
**3、抽象工厂**

## 二、简单工厂设计模式 ##

定义：一个工厂方法，依据传入的参数，生成对应的产品对象；  
角色：  
**1、抽象产品**  
**2、具体产品**  
**3、具体工厂**  
**4、产品使用者**  
使用说明：先将产品类抽象出来，比如，伊利和蒙牛都属于牛奶，抽象出来一个牛奶类Milk，伊利和蒙牛就是具体的产品类，然后创建一个牛奶工厂，分别用来创建伊利和蒙牛；代码如下：

牛奶接口：

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

具体类 蒙牛

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

具体类 三鹿

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

具体类 特仑苏

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

具体类 伊利

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"));
    
            //知其然，知其所以然，知其所必然
    
        }
    }

就这样，一个非常简单的工厂设计模式就完成了，但是有没有发现什么问题呢？  
对，那就是如果我想喝其他牛奶呢？所以，以上的这种方式，每当我想添加一种产品，就必然要修改工厂类，这显然违反了开闭原则，亦不可取；所以简单工厂只适合于产品对象较少，且产品固定的需求，对于产品变化无常的需求来说显然不合适；所以我们来看下一种方式；

## 三、工厂方法设计模式 ##

定义：将工厂提取成一个接口或抽象类，具体生产什么产品由子类决定；  
角色：  
**抽象产品类**  
**具体产品类**  
**抽象工厂类**  
**具体工厂类**  
使用说明：和上例中一样，产品类抽象出来，这次我们把工厂类也抽象出来，生产什么样的产品由子类来决定；  
代码如下：  
牛奶接口 蒙牛类和伊利类 代码和上例一样

工厂接口

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

蒙牛工厂

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

三鹿工厂

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

特仑苏工厂

public class TelunsuFactory implements Factory {
    
        @Override
        public Milk getMilk() {
            return new Telunsu();
        }
    }

伊利工厂

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

使用

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

以上这种方式，虽然解耦了，也遵循了开闭原则，但是问题根本还是没有解决啊，换汤没换药，如果我需要的产品很多的话，需要创建非常多的工厂，所以这种方式的缺点也很明显；

## 四、抽象工厂设计模式 ##

定义：为创建一组相关或者是相互依赖的对象提供的一个接口，而不需要指定它们的具体类。  
角色：和工厂方法一样  
抽象工厂和工厂方法的模式基本一样，区别在于，工厂方法是生产一个具体的产品，而抽象工厂可以用来生产一组相同，有相对关系的产品；重点在于一组，一批，一系列；

工厂接口或抽象类

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();
        }
    }

以上例子可以看出，抽象工厂可以解决一系列的产品生产的需求，对于大批量，多系列的产品，用抽象工厂可以更好的管理和扩展；

**三种工厂方式总结：**  
1、对于简单工厂和工厂方法来说，两者的使用方式实际上是一样的，如果对于产品的分类和名称是确定的，数量是相对固定的，推荐使用简单工厂模式；  
2、抽象工厂用来解决相对复杂的问题，适用于一系列、大批量的对象生产；