《大话设计模式》——读后感 （1）代码无错就是优？——简单工厂模式

本篇是我学习设计模式后的第一篇文章，由于本模式也比较简单，在此我就多啰嗦一下。

 

学习本模式之前请下看一下我的《大话设计模式铺垫》文章，然后回答思考如下问题：

1、UML类图看懂了吗？
2、java的3大特性真的懂了吗？知道为什么要封装、继承、多态了吗？

对于和我一样的菜鸟而言，我根本就不知道什么是设计模式，那怎么办？学呗。怎么样的学习设计模式呢？看UML类图，然后结合代码加以理解，废话不多刷，先上图：

 从图中我独处了如下信息：

1、运算类是个抽象类，而不是接口。（不懂就去看UML类图）

2、加、减、乘、除法类是具体的实现类

3、我看到了封装、继承、多态的影子了

按照简单工厂的UML类图，我的代码如下：

首先模拟抽象类（思考一下用接口行不行，个人喜欢剑走偏锋，我就要试试interface行不行）

package com.sjmx.slpFactory;

public interface Operation {
    public double getResult(double a,double b);
}

加法实现类：

package com.sjmx.slpFactory;

public class OperationAdd implements Operation {

    @Override
    public double getResult(double a, double b) {
        return a+b;
    }

}

减法类：

package com.sjmx.slpFactory;

public class OperationDelete implements Operation {

    @Override
    public double getResult(double a, double b) {
        return a-b;
    }

}

乘法类：

package com.sjmx.slpFactory;

public class OperationMulti implements Operation {

    @Override
    public double getResult(double a, double b) {
        return a*b;
    }

}

除法类：

package com.sjmx.slpFactory;

public class OperationDiv implements Operation {

    @Override
    public double getResult(double a, double b) {
        return b!=0?a/b:0;
    }

}

简单工厂类：

package com.sjmx.slpFactory;

public class Factory {
    
    public static Operation getInstance(String type){
        
        Operation o ;
        
        switch(type){
            case "+":
                o = new OperationAdd();
                break;
            case "-":
                o = new OperationDelete();
                break;
            case "*":
                o = new OperationMulti();
                break;
            case "/":
                o = new OperationDiv();
                break;
            default:
                o = null;
        }
        return o;
        
    }
}

客户端代码：

package com.sjmx.slpFactory;

public class Client {
    
    public static void main(String[] args) {
        
        double result;
        Operation oper;
        
        oper= Factory.getInstance("+");
        result = oper.getResult(3, 9);
        System.out.println(result);
        System.out.println("---------------");
        
        oper = Factory.getInstance("-");
        result = oper.getResult(3, 9);
        System.out.println(result);
        System.out.println("---------------");
        
        oper = Factory.getInstance("*");
        result = oper.getResult(3, 9);
        System.out.println(result);
        System.out.println("---------------");
        
        oper = Factory.getInstance("/");
        result = oper.getResult(9, 0);
        System.out.println(result);
        
    }
    
}

运行结果：

简单工厂模式应用场景：

    感觉简单工厂模式多用于 解决对象的创建 问题。比如你写了一些类，但是到底创建哪一个类？实例化对象的时候会不会因为创建太多了弄混？
这个时候就应该考虑用一个 单独的类来做这个创建实例的过程 这就是工厂！

在本模式中涉及到了3大特性了吗？
    加、减、乘、除各自干各自的事情，互相不影响，我们理解为封装。而它们都有类似的方法名，因为它们和Operation接口中的方法名是一致的，
这是继承的原因。最后我们在客户端中只需要执行Operation oper = Factory.getInstance("+")就知道具体要使用什么运算类了，因为我们把所有的
逻辑都封装在Factory类里面了，而不管加、减、乘、除都只不过是Operation接口的具体实现类而已，此处就是利用多态，确保了客户端只需要知道有这么
个Operation存在就可以了，根本不需要关心是哪个具体运算类在运行！

最后强调一下：任何的涉及模式都有相似的部分，你中有我，我中有你!比如说简单工厂模式和策略模式进行结合，使策略模式更加的简洁，降低业务与逻辑的耦合度。还有外观涉及模式和建造者模式结构非常的相似，只不过外观模式侧重各个子系统的完美结合，而建造者模式则侧重同一个子系统内部各个方法的组合，相似的部分太多了！接下来的涉及模式，我都会尽量点出来，供大家思考！