菜鸟之路：设计模式入门篇——简单工厂模式

Myth丶恋晨 2022-05-20 05:08 204阅读 0赞

# 简单工厂模式 #

## 1.什么是工厂？ ##

## 用一个单独的类来做这个类创造实例的过程，这就是工厂。 ##

## 2.它解决了那些问题？   简单工厂模式解决了对象的创建问题。 ##

## 3.什么时候去使用简单工厂模式？ ##

## 用于已知某些条件后，对类的选择，而这些类都是同一父类的子类。 ##

计算器示例：

1.抽象一个基类（JiSuan），提供一个计算方法；

JiSuan类：

/**
     * 作者：LKP
     * 时间：2018/7/12
     * 计算器抽象类
     */
    public abstract class JiSuan {
        private double numOne;
        private double numTwo;
    
        public double getNumOne() {
            return numOne;
        }
    
        public void setNumOne(double numOne) {
            this.numOne = numOne;
        }
    
        public double getNumTwo() {
            return numTwo;
        }
    
        public void setNumTwo(double numTwo) {
            this.numTwo = numTwo;
        }
    
        //计算结果
        public double JiSuan(){
            return 0d;
        }
    }

2.创建两个子类基础该基类，分别是JiaFa子类和JianFa子类，同时实现计算结果方法；

JiaFa子类：

/**
     * 作者：LKP
     * 时间：2018/7/12
     * 加法类
     */
    public class JiaFa extends JiSuan {
    
        @Override
        public double JiSuan() {
            return getNumOne()+getNumTwo();
        }
    }

JianFa子类：

/**
     * 作者：LKP
     * 时间：2018/7/12
     * 减法类
     */
    public class JianFa extends JiSuan {
        @Override
        public double JiSuan() {
            return getNumOne()-getNumTwo();
        }
    }

3.创建一个计算工厂类（JiSuanFactory）

/**
     * 作者：LKP
     * 时间：2018/7/12
     * 计算工厂类
     */
    public class JiSuanFactory {
        public static JiSuan createJiSuan(String yunSuanFu){
            JiSuan open = null;
            switch (yunSuanFu){
                case "+":
                    open = new JiaFa();
                    break;
                case "-":
                    open = new JianFa();
                    break;
            }
            return open;
        }
    }

4.客户端代码

加法计算：

/**
     * 作者：LKP
     * 时间：2018/7/12
     */
    public class MainClass {
        public static void main(String[] args){
            JiSuan jiSuan = JiSuanFactory.createJiSuan("+");
            jiSuan.setNumOne(10);
            jiSuan.setNumTwo(20);
            double number = jiSuan.JiSuan();
            System.out.println("计算结果为："+number);
        }
    }

运行结果：

![70][]

减法计算：

/**
     * 作者：LKP
     * 时间：2018/7/12
     */
    public class MainClass {
        public static void main(String[] args){
            JiSuan jiSuan = JiSuanFactory.createJiSuan("-");
            jiSuan.setNumOne(10);
            jiSuan.setNumTwo(20);
            double number = jiSuan.JiSuan();
            System.out.println("计算结果为："+number);
        }
    }

运行结果：

![70 1][]

如果需要加入除法和乘法，只需新增一个除法子类和乘法子类，修改一下工厂类里面的switch选择器即可。

来看看这几个类的结构图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xrcDE2MDM2NDU3NTY_size_16_color_FFFFFF_t_70][]

优点：工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建那个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。

缺点：由于工厂类集中了所有实例的创建逻辑，这就直接导致一旦这个工厂出了问题，所有的客户端都会受到牵连；而且由于简单工厂模式的产品是基于一个共同的抽象类或者接口，这样一来，一旦产品的种类增加的时候，既有不同的产品接口或者抽象类的时候，工厂类就需要判断何时创建何种种类的产品，这就和创建何种种类的产品相互混淆在了一起，违背了单一职责，导致系统丧失灵活性和可维护行。而且更重要的是，简单工厂模式违背了“开发封闭原则”，就是违背了“系统对扩展开放，对修改关闭”的原则，因为当我新增加一个产品的时候必须修改工厂类，相应的工厂类就需要重新编译一遍。

编程是一门技术，更加是一门艺术！！！

[70]: /images/20220520/12fb7f10bf334dd5ba2f3cc2cbbed1e2.png
[70 1]: /images/20220520/0bb50a9e99604e808525edb4100948d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xrcDE2MDM2NDU3NTY_size_16_color_FFFFFF_t_70]: /images/20220520/450be355245e4949a438f764d03c1024.png