简单工厂模式
在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的，但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助功能的对象。 在这些情况,新对象的建立就是一个 “过程”，不仅是一个操作，像一部大机器中的一个齿轮转动。
模式的问题：
你如何能轻松方便地构造对象实例，而不必关心构造对象实例的细节和复杂过程呢？
解决方案：
建立一个工厂来创建对象
分类
工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
工厂模式可以分为三类：
1）简单工厂模式（Simple Factory）
2）工厂方法模式（Factory Method）
3）抽象工厂模式（Abstract Factory）
这三种模式从上到下逐步抽象，并且更具一般性。
GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。
将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。
什么是简单工厂模式
简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例，被创建的实例通常都具有共同的父类。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。
模式结构
简单工厂模式包含如下角色：
Factory：工厂角色
Product：抽象产品角色
ConcreteProduct：具体产品角色
| 工厂角色（Factory） |
是简单工厂模式的核心，它负责实现创建所有具体产品类的实例。工厂类可以被外界直接调用，创建所需的产品对象。 |
| 抽象产品角色（Product）
|
是所有具体产品角色的父类，它负责描述所有实例所共有的公共接口。
|
| 具体产品角色（Concrete Product）
|
继承自抽象产品角色，一般为多个，是简单工厂模式的创建目标。工厂类返回的都是该角色的某一具体产品。
|
UML图
在没有了解简单工厂之前，我们是直接new 对象创建实例的，假如我们现在有一个Apple类和一个Banana类
public class Apple {
public void eat(){
System.out.println("吃苹果");
}
}public class Banana {
public void eat(){
System.out.println("吃香蕉");
}
}创建实例：
public static void main(String[] args) {
Apple apple=new Apple();
Banana banana=new Banana();
apple.eat();
banana.eat();
}运行结果：
吃苹果
吃香蕉
显然我们可以抽象出一个接口类Fruit，
public interface Fruit {
public void eat();
}这样Apple类和Banana类可以实现Fruit类
public class Apple implements Fruit{
public void eat(){
System.out.println("吃苹果");
}
}public class Banana implements Fruit{
public void eat(){
System.out.println("吃香蕉");
}
}创建实例
public static void main(String[] args) {
//用到了多态
Fruit apple=new Apple();
Fruit banana=new Banana();
apple.eat();
banana.eat();
}运行结果：
吃苹果
吃香蕉
使用简单工厂模式创建一个类来负责创建Apple和Banana类的实例
public class FruitFactory {
public Fruit eatApple(){
return new Apple();
}
public Fruit eatBanana(){
return new Banana();
}
}这样就可以通过创建FruitFactory去实例化Apple和Banana类
public static void main(String[] args) {
Fruit apple = new FruitFactory().eatApple();
Fruit banana = new FruitFactory().eatBanana();
apple.eat();
banana.eat();
}运行结果
吃苹果
吃香蕉
改进1：将FruitFactory工厂类中的方法改为静态的，这样可以直接调用它的方法
public class FruitFactory {
public static Fruit eatApple(){
return new Apple();
}
public static Fruit eatBanana(){
return new Banana();
}
} public static void main(String[] args) {
Fruit apple = FruitFactory.eatApple();
Fruit banana = FruitFactory.eatBanana();
apple.eat();
banana.eat();
}运行结果：
吃苹果
吃香蕉
这样就一步一步的完成了一个简单工厂的实现，但是，在工厂类中的两个方法功能类似，我们可以改造成一个吃水果的方法
通过给出的苹果名称去获得对应的水果实例
public class FruitFactory {
public static Fruit getFruit(String type){
if (type.equalsIgnoreCase("apple")){
return new Apple();
}else if (type.equalsIgnoreCase("banana")){
return new Banana();
}else {
System.out.println("找不到该水果");
return null;
}
}
}创建实例
public static void main(String[] args) {
Fruit apple = FruitFactory.getFruit("apple");
Fruit banana = FruitFactory.getFruit("banana");
apple.eat();
banana.eat();
}运行结果
吃苹果
吃香蕉
这种方式呢不易扩展，如果新加一种水果就要修改工厂类的代码，那么也可以使用反射的方法去获取实例，但是用户肯定不会通过反射的方法获得对象实例的。
public class FruitFactory {
public static Fruit getFruit(String type) {
try {
Class fruit = Class.forName(type);
return (Fruit) fruit.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
} public static void main(String[] args) {
Fruit apple = FruitFactory.getFruit("设计模式.普通工厂模式.Apple");//注意：此处填完整类名
Fruit banana = FruitFactory.getFruit("设计模式.普通工厂模式.Banana");
apple.eat();
banana.eat();
}运行结果
吃苹果
吃香蕉
设计模式都是一步一步推导验证而来的，从推导的过程中我们更能体会到设计模式的优缺点。
优点
再简单工厂模式中，工厂类是整个模式的关键所在，它包含必要的判断逻辑，能够根据给定的信息去创建具体类的实例，用户在使用时可以根据工厂类去创建所需的实例，而无需了解该对象实例是如何创建的。
缺点
当然由于工厂类集中了所有类实例的创建逻辑，当系统中的具体产品类不断增多时，工厂类也需要做相应的修改，扩展性不是很好
模式适用环境
在以下情况下可以使用简单工厂模式：
工厂类负责创建的对象比较少：由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。
客户端只知道传入工厂类的参数，对于如何创建对象不关心：客户端既不需要关心创建细节，甚至连类名都不需要记住，只需要知道类型所对应的参数。