java 简单工厂模式

简单工厂

工厂是一种创建型的设计模式，常用于封装变化，一般遵循那里有变化就封装那里的原则。

简单工厂模式又 叫静态工厂方法模式（Static FactoryMethod Pattern）,是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

 以一个java面试题为例 --> 使用java实现一个计算机控制台程序，要求输入数的运算，得到结果。 

下面是题目最原始的做法。

public class Computer {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入第一个数字：");
        float firstNum  = in.nextFloat();
        System.out.println("请输入第二个数字：");
        float secondNum  = in.nextFloat();
        System.out.println("请输入运算符号：");
        String countQuato = in.next();
        if("+".equals(countQuato)){
            System.out.println("result : "+(firstNum+secondNum));
        }else if("-".equals(countQuato)){
            System.out.println("result : "+(firstNum-secondNum));
        }else if("*".equals(countQuato)){
            System.out.println("result : "+(firstNum*secondNum));
        }else if("/".equals(countQuato)){
            System.out.println("result : "+(firstNum/secondNum));
        }
    }

上面的写法实现虽然简单，但是却没有面向对象的特性，代码拓展性差，显然不是出题者想要考察的意图。 
(工厂模式一般遵循那里有变化就封装那里的原则)，在面向对象编程语言中，一切都是对象，所以上面 运算符号(既然这里有变化那么我们就进行封装)  也应当作对象来处理。

定义一个接口

public interface Operation {
    float getResult(float one,float two);
}

把符号当做对象处理，实现Operation接口

public class addOperation implements Operation {//加法
    @Override
    public float getResult(float one,float two) {
        return one + two;
    }
}

public class SubtractOperation implements Operation {//减法
    @Override
    public float getResult(float one, float two) {
        return one - two;
    }
}

使用简单工厂模式实现根据不同的情况创建不同的对象。

public class OperationFactory {

    public static Operation getOperation(String operator){
        switch (operator){
            case "+":
                return new addOperation();
            case "-":
                return new SubtractOperation();
                default:
                    break;
        }
        return null;
    }
}

调用：

    public static void main(String[] args) {
        Operation operation = OperationFactory.getOperation("+");
        System.out.println(operation.getResult(10000, 10000));
    }

结果：

 20000.0 

这里 我们以一位同学去买水果为示例

定义一个买的接口

//买水果的接口
public interface IFruits {
    void buy();
}

创建实现接口的实体类

public class Apple implements IFruits {
    @Override
    public void buy() {
        System.out.println("欢迎来购买苹果，^_^ ");
    }
}

public class Banana implements IFruits {
    @Override
    public void buy() {
        System.out.println("欢迎来购买香蕉，^_^ ");
    }
}

创建学生类

public class Student {
    public static void main(String[] args) {
　　　　 //让其子类自已决定实例化哪一个类
        IFruits banana = new Banana();
        banana.buy();
    }
}

运行结果：

欢迎来购买香蕉，^_^ 

从Student类中，可以看到学生只能够买香蕉。如果需要买苹果就需要new Apple()....

所以 new Banana() 就是一个变化点，既然是变化点，那么我们进行封装。

创建一个水果店。

public class FruitsShop {
    
    public static IFruits getFruit(String fruitName){
        switch (fruitName){
            case "Apple":
                return new Apple();
            case "Banana":
                return new Banana();
                default:
                    throw new IllegalArgumentException("没有你想要的"+fruitName+"水果");
        }
    }
    
}

 修改学生类里面的代码

public class Student {
    public static void main(String[] args) {

        System.out.print("你好，你想买什么水果呢？");
        Scanner in = new Scanner(System.in);
        IFruits fruit = FruitsShop.getFruit(in.next());
        fruit.buy();
    }
}

运行结果：

你好，你想买什么水果呢？Banana
欢迎来购买香蕉，^_^ 

到这里，我们就已经实现了一个简单工厂模式。

简单工厂特点:

优点：　　

　　1、一个调用者想创建一个对象，只要知道其实现类名称就可以了。

　　2、扩展性高，如果想增加一个产品，只要扩展一个接口实现类就可以。

　　3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：

　　1、FruitsShop代码跟IFruit代码紧耦合。

　　2、每次要添加/删除/修改 都要需要改FruitsShop这个类。

 代码示例地址：https://github.com/oukele/simpleFactory/tree/master