初学Java设计模式随记 -- 工厂模式（Factory Pattern）
在阎宏《JAVA与设计模式》中 ，工厂模式（Factory Pattern）分为下列几种形态：
1.简单工厂（Simple Factory）模式： 又称静态工厂方法模式（Static Factory Method Pattern）.
2.工厂方法（Factory Method）模式：又称多态性（Polymorphic Factory）模式或虚拟构造子（Virtual Construtor）模式。
3.抽象工厂（Abstract Factory）模式：又称工具箱（Kit或Toolkit）模式。
在《GOF设计模式》中，主要是工厂方法（Factory Method）模式和抽象工厂（Abstract Factory）模式
先不考虑工厂模式有几种形态，从工厂模式的名称来看，工厂模式似乎很容易理解，反映到现实中的例子，比如：
一汽大众(工厂角色)生产了很多汽车(抽象产品类角色)，其中有一款叫做奥迪A6(具体产品角色)。
这是一个被用烂了的例子。那么，把这个例子再稍微形象化一些：一个客户要买这款奥迪A6汽车。
它的Java实现如下，例子1（使用工厂模式）：
汽车（抽象产品类角色）：
/*
* 无论哪个工厂生产的汽车，都是汽车 （抽象产品类）
*/
public abstract class Car {
public String name;
}
奥迪A6（具体产品角色）：
/*
* 奥迪A6，是一汽大众生产的一款汽车 （具体产品类）
*/
public class AudiA6Car extends Car {
public AudiA6Car(){
this.name = "奥迪A6";
}
public String toString(){
return "一辆"+ this.name;
}
}
一汽大众（工厂角色）：
定义了一个静态的工厂方法manufactureCar()，来返回一个Car类型的对像。
/*
* 生产汽车的工厂，一汽大众 （工厂类）
*/
public class CarFactory {
/*
* 生产汽车（通过一个静态方法来得到一辆汽车的对象）
*/
public static Car manufactureCar(){
return new AudiA6Car();
}
}
买这款奥迪A6汽车的一个顾客A（客户端）：
/*
* 购买汽车的顾客A(客户端)
*/
public class CustomerA {
public static void main(String[] args){
// 通过汽车工厂来制造出了一辆汽车
Car myCar = CarFactory.manufactureCar();
System.out.println("一辆汽车被造好，并且出厂了。");
// 顾客得到了一辆汽车，十分的高兴
System.out.println("我终于买了"+myCar+"。真是太好了！");
}
}
当看到这个例子的时候（还有很多这样类似的例子），第一感觉，工厂模式挺简单的，很容易理解嘛。
但这时，有这样两个问题：如果不用工厂模式，那么以前是怎么实现的呢？以前的实现方式会有什么问题？
例子2（不使用工厂模式）：
汽车（抽象产品类角色）：代码与例子1的相同。
奥迪A6（具体产品角色）：代码与例子1的相同。
买这款奥迪A6汽车的一个顾客B（客户端）：
/*
* 购买汽车的顾客B(客户端)
*/
public class CustomerB {
public static void main(String[] args){
// 一辆汽车被造出来了
Car myCar = new AudiA6Car();
System.out.println("一辆汽车被造好。");
// 顾客得到了一辆汽车，十分的高兴
System.out.println("我终于买了"+myCar+"。真是太好了！");
}
}
比较一下使用模式和不使用模式的不同：
1.例子1（使用设计模式）比例子2（不使用设计模式）多了1个工厂类。
2.在客户端（顾客A和顾客B），例子1（工厂模式）没有使用new方法，而是使用了一个工厂方法manufactureCar()；例子2（没有工厂模式）使用了new方法。是因为不使用new比使用new好？仔细研究发现，其实，工厂模式也使用了new,只是把它放在了工厂类的工厂方法manufactureCar里，而不是客户端。
这么看，使用设计模式也没有什么优势呀，客户端代码行数相同，而且，还多了1个类。
好吧，再想想，买一辆汽车有那么简单吗？汽车的构成可是非常复杂的。它要有轮子，方向盘，座椅，发动机，颜色等等。
再丰富一下这个例子。
这次，先看看不使用设计模式的例子。例子3（不使用设计模式）：
汽车（抽象产品类角色）：
/*
* 无论哪个工厂生产的汽车，都是汽车 （抽象产品类）
*/
public abstract class Car {
public String name;
}
奥迪A6（具体产品角色）：
为汽车添加了很多属性，那么对象的创建过程就变复杂了。
/*
* 奥迪A6，是一汽大众生产的一款汽车 （具体产品类）
*/
public class AudiA6Car extends Car {
private String wheels;
private String steering_wheel;
private String car_seats;
private String car_color;
private String engine;
public AudiA6Car(){
this.name = "奥迪A6";
}
//给汽车涂上颜色
public void setCar_color(String car_color) {
this.car_color = car_color;
}
//给汽车装上座椅
public void setCar_seats(String car_seats) {
this.car_seats = car_seats;
}
//给汽车装上发动机
public void setEngine(String engine) {
this.engine = engine;
}
//给汽车装上方向盘
public void setSteering_wheel(String steering_wheel) {
this.steering_wheel = steering_wheel;
}
//给汽车装上车轮
public void setWheels(String wheels) {
this.wheels = wheels;
}
// 还需要装上其他的很多部件。。。。。。
// 一辆装好的汽车
public String toString(){
return "一辆"+ this.name+"[" + this.car_color + "," + this.car_seats+"," + this.engine
+ "," + this.steering_wheel + "," + this.wheels +"]";
}
}
买这款奥迪A6汽车的一个顾客B（客户端）：
/*
* 购买汽车的顾客B(客户端)
*/
public class CustomerB {
public static void main(String[] args){
// 奥迪车的架子给了顾客B,部件要顾客B自己装了。
AudiA6Car myCar = new AudiA6Car();
// 涂上颜色
myCar.setCar_color("黑色");
// 装上座椅
myCar.setCar_seats("座椅");
// 装上发动机
myCar.setEngine("发动机");
// 装上方向盘
myCar.setSteering_wheel("方向盘");
// 装上车轮
myCar.setWheels("四个轮子");
// 装上其他的部件。。。。。。
System.out.println("顾客自己装好了"+myCar);
// 顾客自己组装了一辆汽车
System.out.println("累死我了，哪有买汽车还得自己组装的呀？？！！ 这样的汽车能开吗？以后再也不能买奥迪了！！！");
}
}
运行结果：
顾客自己装好了一辆奥迪A6[黑色,座椅,发动机,方向盘,四个轮子] 累死我了，哪有买汽车还得自己组装的呀？？！！ 这样的汽车能开吗？以后再也不能买奥迪了！！！
顾客很不高兴，汽车的组装太复杂了，怎么买一辆汽车还要自己组装？这辆汽车能开吗？性能和安全有保证吗？
看看由工厂来组装汽车会是什么样子，例子4（使用工厂模式）：
汽车（抽象产品类角色）： 代码与例子3的相同。
奥迪A6（具体产品角色）：代码与例子3的相同。
一汽大众（工厂角色）：
复杂的组装过程还是有工厂来做吧。
/*
* 生产汽车的工厂，一汽大众 （工厂类）
*/
public class CarFactory {
/*
* 生产汽车（通过一个静态方法来得到一辆汽车的对象）
*/
public static Car manufactureCar(){
AudiA6Car oneCar = new AudiA6Car();
// 涂上颜色
oneCar.setCar_color("黑色");
// 装上座椅
oneCar.setCar_seats("座椅");
// 装上发动机
oneCar.setEngine("发动机");
// 装上方向盘
oneCar.setSteering_wheel("方向盘");
// 装上车轮
oneCar.setWheels("四个轮子");
// 装上其他的部件。。。。。。
System.out.println("汽车在工厂组装好了");
// 一辆汽车造好了
return oneCar;
}
}
买这款奥迪A6汽车的一个顾客A（客户端）：
/*
* 购买汽车的顾客A(客户端)
*/
public class CustomerA {
public static void main(String[] args){
// 通过汽车工厂来制造出了一辆汽车
Car myCar = CarFactory.manufactureCar();
// 顾客得到了一辆汽车，十分的高兴
System.out.println("我终于买了"+myCar+"。真是太好了！去兜风去。。。");
}
}
运行结果：
汽车在工厂组装好了 我终于买了一辆奥迪A6[黑色,座椅,发动机,方向盘,四个轮子]。真是太好了！去兜风去。。。
顾客A很轻松地买了一辆奥迪A6，高兴地开着车兜风去了。。。
通过比较例子3和例子4，工厂模式的优势体现出来了：
利用工厂模式可以将对象的创建过程和使用进行分离（也就是解藕），可以将复杂的对象创建过程由工厂类进行了封装。
1.这样一来，客户端使用起来就显得非常轻松。
例如：如果客户想要红色的奥迪A6，那么，很简单，厂家给发一款红色的就可以了。客户只要高高兴兴地去开它就行了。
2.而且，这个系统，职责分明，思路清晰。
例如：如果出了车祸，如果是因为刹车问题造成的，那么就要找厂商；如果是因为顾客酒驾造成的，就要找顾客。
确定正确的调查对象，找到问题的真正原因，才能找到合适的解决方法，就不会有误判和冤案了。
3.此外，这样还起到了可以重用的作用。
例如： 无论有多少客户都买，只要买的是同一款，那么，只要用一套生产线就可以了，节省了很多时间和资源。
4.在将来的维护和修改时，就会减少使用对象的影响。
例如：客户不需要知道奥迪A6是怎么组装的。原来可能是由人手工装的；后来，是用机器装的；再后来，用了一套更先进的设备装的。这些都与客户无关，因为，客户买车，是为了开车，不需要了解车是怎么组装的。
再例如：多个客户购买了同一款汽车，如果这款汽车的刹车都有问题，那么，只需要修改一个工厂类就可以了，客户在使用过程中不会感觉到有什么变化，就不需要改变自己的使用方式了。
遗留的问题：
当我们使用JDBC对数据库进行操作的时候，是不是就用到了工厂模式？无论是连接Oracle还是MySQL,我们是不是写起来很简单？是不是不需要关心每种数据库的连接细节？是不是很容易就实现了从MySQL到Oracle的移植？是不是只是用了工厂模式？
工厂模式的应用似乎有很多，而且往往是和其他设计模式一起使用，在实际的项目和框架中都是怎么使用工厂模式的？
好了，来个小小的总结：
一个系统的好坏，不是类越少就越好，通过使用设计模式，进行了解藕和封装，使得设计更加合理，系统看起来职责分明、清晰，维护和扩展也更容易。
但是，使用了设计模式，也并不能说就是合理的。就像例子1和例子2，设计模式就没有带来什么优势，反而，使得系统显得繁琐了。