为何简单工厂模式
在我们的软件开发中，需要我们实现一些业务，而有一些业务是需要重复的动作，但是产出的实际是不一样的(就好比我们生活中的做饭，材料是一样的，锅碗瓢盆是一样的，但是做菜的人不一样，做出的菜就五花八门)，这时，就可以用到我这次介绍的简单工厂模式。
模式理解
简单工厂模式，需要定义一个类，专门负责创建其他类的实例，被创建的实例通常具有共同的父类，这句话运用到生活中，还是做饭，我们可以自己做饭，但是我们也可以去饭店吃饭，饭店就是简单工厂类，创建菜的实例，被创建的菜有共同的特点，那就是需要锅碗瓢盆。
此模式的要素
要想实现简单工厂模式，我们需要的要素有：
首先要有具体的角色，即具体的实例(菜肴)。
要有共同的抽象(锅碗瓢盆)。
还有创建的工厂(饭店)。
模式的利弊
在本模式中，工厂类是核心，包含对外界类给的信息的逻辑判断，根据信息创建对应的类，甲方爸爸在使用时无需关注对象是如何产生，组织关系是什么样的，无需了解这些。这样有利于软件体系的结构优化。
生活就是:
本人不想做饭了，我就想吃现成的，我只需要说一句:“我要一份西红柿炒鸡蛋，一份米饭。”，美味的菜肴哇哇送上，而我，不需要知道菜肴是怎么做的，做的多么辛苦，只需要吃就可以了，美滋滋的。
但是本模式也有弊端，正式体现在工厂类中，它包揽了所有对象实例的创建，所以当系统中需要的实例类不断增多时，可能会出现工厂类也要做相应的修改，可扩展性不太强。
弊端：
有一天，我想吃板蓝根泡面(是不是有点过分了)，去到饭店，饭店也不会做，这什么破饭店，这么简单的板蓝根泡面都不会，下次不来了，气汪汪的。
简单工厂模式演进
代码可在码云中下载(包名为a_simpleFactory)
https://gitee.com/XiaoSa12138/java-models
1. 我每做一道菜，就买一套新的锅碗瓢盆(原始)
/**
* 川菜
*/
public class ChuanCai {
public void get(){
System.out.println("麻婆豆腐.....");
}
}
/**
* 鲁菜
*/
public class LuCai {
public void get(){
System.out.println("糖醋鲤鱼.....");
}
}
/**
* 主类
*/
public class Main {
//每次都自己创建新对象
public static void main(String[] agrs) {
LuCai luCai = new LuCai();
ChuanCai chuanCai = new ChuanCai();
luCai.get();
chuanCai.get();
}
}
2.创业阶段，快没钱了，发现之前的锅碗瓢盆也能重复利用(此时有了共同的抽象)
/**
* 用一套锅碗瓢盆(共同的抽象)
*/
public interface Cai {
void get();
}
/**
* 川菜
*/
public class ChuanCai implements Cai {
public void get(){
System.out.println("麻婆豆腐.....");
}
}
/**
* 鲁菜
*/
public class LuCai implements Cai {
public void get(){
System.out.println("糖醋鲤鱼.....");
}
}
/**
* 主类
*/
public class Main {
//每次都自己创建新对象，但是用一套锅碗瓢盆
public static void main(String[] agrs) {
Cai luCai = new LuCai();
Cai chuanCai = new ChuanCai();
luCai.get();
chuanCai.get();
}
}
3.创业成功，巨有钱，饭店吧，想吃什么菜就去相应的饭店，川菜馆、鲁菜馆等(此时开始有原始的工厂)
/**
* 饭店肯定是用一套锅碗瓢盆(共同的抽象)
*/
public interface Cai {
void get();
}
/**
* 川菜
*/
public class ChuanCai implements Cai {
public void get(){
System.out.println("麻婆豆腐.....");
}
}
/**
* 鲁菜
*/
public class LuCai implements Cai {
public void get(){
System.out.println("糖醋鲤鱼.....");
}
}
/**
* 菜工厂(就是饭店)
*/
public class CaiFactory {
public static Cai getLuCai(){
return new LuCai();
}
public static Cai getChuanCai(){
return new ChuanCai();
}
}
/**
* 主类
*/
public class Main {
//每次从工厂获取对应的对象，不再自己创建
public static void main(String[] agrs) {
Cai luCai = CaiFactory.getLuCai();
Cai chuanCai = CaiFactory.getChuanCai();
luCai.get();
chuanCai.get();
}
}
4.发现一家饭店能做我想吃的所有的菜(此时对工厂做升级改进，其它不变)
/**
* 饭店肯定是用一套锅碗瓢盆(共同的抽象)
*/
public interface Cai {
void get();
}
/**
* 川菜
*/
public class ChuanCai implements Cai {
public void get(){
System.out.println("麻婆豆腐.....");
}
}
/**
* 鲁菜
*/
public class LuCai implements Cai {
public void get(){
System.out.println("糖醋鲤鱼.....");
}
}
/**
* 菜工厂
*/
public class CaiFactory {
public static Cai getCai(String type){
//方式一，根据字符串判断创建对应的对象，字符串内容自定
// try {
// if (type.equalsIgnoreCase("chuanCai")) {
// return ChuanCai.class.newInstance();
// } else if (type.equalsIgnoreCase("luCai")) {
// return LuCai.class.newInstance();
// }
// } catch (InstantiationException e) {
// e.printStackTrace();
// } catch (IllegalAccessException e) {
// e.printStackTrace();
// }
//方式二，字符串就是类的全名称，以此来创建，字符串内容固定
try {
Class cai = Class.forName(type);
return (Cai)cai.newInstance();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
}
/**
* 主类
*/
public class Main {
//每次告诉工厂需要什么对象，工厂就创建对应的对象
public static void main(String[] agrs) {
// Cai luCai = CaiFactory.getCai("luCai");
// Cai chuanCai = CaiFactory.getCai("chuanCai");
Cai luCai = CaiFactory.getCai("a_simpleFactory.d.LuCai");
Cai chuanCai = CaiFactory.getCai("a_simpleFactory.d.ChuanCai");
luCai.get();
chuanCai.get();
}
}
好了，到这简单工厂模式就说完了，这是我结合生活中的事物想到的，可能会有不妥之处，欢迎指出探讨…
