面试官都爱问的java设计模式（工厂模式）

偏执的太偏执、 2024-04-17 20:09 10阅读 0赞

**简言：**

java有二十三种设计模式，面试时几乎面试官都会问你知道哪些设计模式，单例模式，装饰模式，工厂模式，外观模式，建造者模式，适配器模式等等，不单单面试中需要你的了解渗透，在实际开发中也是大有用途的。今天主要说的是工厂模式，会以案例的形式讲解。

**简单理解什么是工厂：**

**简单说，就是到底要实例化谁，会不会增加实例化对象，所以要用一个单独的类做这个创建实例的过程，就是工厂；**

今天主要讲解分为三部分：

> 1.什么是简单工厂模式
> 
> 2.什么是工厂方法模式
> 
> 3.两者之间的对比（优缺点）

我们今天通过“计算器” 功能对工厂模式进行讲解：

**一。简单工厂模式**

工厂类代码：

public class OperationFactory {
    
        public static Operation createOperatie(String operate) {
            Operation oper = null;
            switch (operate) {
                case "+":
                    oper = new OperationAdd();
                    break;
                case "-":
                    oper = new OperationSub();
                    break;
                case "*":
                    oper = new OperationMul();
                    break;
                case "/":
                    oper = new OperationDiv();
                    break;
    
            }
            return  oper;
        }
    
    }

客户端实现：

/**
         * 简单工厂模式
         * */
        private void initUI() {
            Operation oper = OperationFactory.createOperatie("+");
            oper.setNumA(1);
            oper.setNumB(2);
            double v = oper.GetResult();
            Toast.makeText(FactoryActivity.this, "结果为：" + v, Toast.LENGTH_SHORT).show();
        }

通过代码我们能看出，只要输入运算符号，工厂就实例出合适的对象，通过多态反馈给父类实现的结果；

如果我们添加复杂的运算，比如立方根等，我们添加运算的子类就够了，在工厂类中添加分支，就能实现。

我将功能运算类分享给大家（计算加减乘除类）

/**
     * 计算加法类 并返回结果
     * */
    public class OperationAdd extends Operation {
    
    
        @Override
        public double GetResult() {
            double result = 0;
            result = this.getNumA() + this.getNumB();
            return result;
        }
    }
    
    /**
     * 计算减法类 并返回结果
     * */
    public class OperationSub extends Operation{
    
        @Override
        public double GetResult() {
            double result = 0;
            result = this.getNumA() - this.getNumB();
            return result;
        }
    }
    
    /**
     * 计算乘法类 并返回结果
     * */
    public class OperationMul extends Operation {
    
            @Override
            public double GetResult() {
                double result = 0;
                result = this.getNumA() *  this.getNumB();
                return result;
            }
    }
    
    
    /**
     * 计算除法类并返回结果
     * */
    public class OperationDiv extends Operation {
        @Override
        public double GetResult() {
            double result = 0;
            if (this.getNumB() == 0) {
                return 0;
            } else {
                result = this.getNumA() / this.getNumB();
                return result;
            }
    
        }
    }

**二.工厂方法模式**

**步骤:**

1.创建一个工厂接口，运算类分别实现该接口

/**
     * 创建一个工厂接口
     * */
    public interface IFatory {
        Operation CreateOperation();
    }

2.运算类建一个具体工厂去实现这个接口

/**
     * 创建一个加法工厂，实现工厂接口
     * */
    public class AddFatory implements IFatory {
        @Override
        public Operation CreateOperation() {
            return new OperationAdd();
        }
    }
    
    
    /**
     * 创建一个减法工厂，实现工厂接口
     * */
    public class SubFactory implements IFatory {
        @Override
        public Operation CreateOperation() {
            return new OperationSub();
        }
    }
    
    /**
     * 创建一个除法工厂，实现工厂接口
     * */
    public class DivFactory implements IFatory {
        @Override
        public Operation CreateOperation() {
            return new OperationDiv();
        }
    }
    
    
    /**
     * 创建一个乘法工厂，实现工厂接口
     * */
    
    public class MulFactory implements IFatory {
        @Override
        public Operation CreateOperation() {
            return new OperationMul();
        }
    }

在客户端实现功能得到结果：

/**
         * 工厂方法模式
         * */
        private void initUI2() {
            IFatory operFactory = new AddFatory();
            Operation operation = operFactory.CreateOperation();
            operation.setNumA(3);
            operation.setNumB(5);
            double v = operation.GetResult();
            Toast.makeText(FactoryActivity.this, "结果为：" + v, Toast.LENGTH_SHORT).show();
        }

**三： 简单工厂 VS 工厂方法**

他们的区别所在，**简单工厂模式的最大优点就在于工厂类中包含了必要的逻辑判断，根据客户端的选择动态的实例化相关的类，**

**对于客户端来说，祛除了与产品的依赖**，

当时如果加入一个立方根功能。我们要在运算的工厂类方法中添加case 分支，相当于对外扩展开放了，对修改也开放了，**违背了**

**开放--封闭原则**；这个时候我们选择了工厂方法：

两者的结构图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3drX2JlaWNhaQ_size_16_color_FFFFFF_t_70][]           ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3drX2JlaWNhaQ_size_16_color_FFFFFF_t_70 1][]

**总结：**

**工厂方法约束了简单工厂违背的开放-封闭原则的缺点，又保持了封装对象创建过程的优点。它们都是集中封装了对象的创建，更换对象时，不需要大的改动，降低了客户程序与产品对象的耦合，工厂方法模式就是简单工厂模式的进一步的优化，由于使用了多态性，保持了简单工厂模式的优点，克服了缺点；**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3drX2JlaWNhaQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190831112013989.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3drX2JlaWNhaQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3drX2JlaWNhaQ_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/d85f59a0aff047c299814a84ec1294fa.png