设计模式之：工厂模式
工厂模式
工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
工厂模式可以分为三类：
1）简单工厂模式（Simple Factory）
2）工厂方法模式（Factory Method）
3）抽象工厂模式（Abstract Factory）
这三种模式从上到下逐步抽象，并且更具一般性。
情景模拟+代码实现
现在有两款汽车分别是奔驰，宝马。称之为“产品”：
abstract class Car {
public Car() {
}
}
public class BenzCar extends Car {
public BenzCar() {
System.out.println("奔驰汽车！");
}
}
public class BMWCar extends Car {
public BMWCar() {
System.out.println("宝马汽车！");
}
}
有了产品当然需要客户了。
1.无工厂模式
现在有“客户”需要使用汽车，但是没有工厂怎么办？
没办法，只能自己动手，丰衣足食。
public class Main {
public static void main(String[] args) {
Car car1 = new BenzCar();//制造奔驰汽车
Car car2 = new BMWCar();//制造宝马汽车
}
}
用户需要什么汽车，只需要new一下，然后自己制造就行了。（当然我们不用管他是怎么制造汽车的）
没有工厂时代的客户真的惨，需要什么汽车还要自己制造。~.~
2.简单工厂模式（Simple Factory）
然后有人发现制造汽车有利可图，建立了汽车工厂，生产汽车。然后向客户宣布：“你们给我下订单，你给我钱，我帮你们制造想要的汽车”！
public class SimpleFactory {
/**
* 1.生产奔驰汽车 2.生产宝马汽车
*
* @return
*/
public Car create(int type) {
switch (type) {
case 1:
return new BenzCar();
case 2:
return new BMWCar();
default:
break;
}
return null;
}
}
客户喜闻乐见，这下买汽车可方便多了。只需要找到工厂下订单就行。
public class Main {
public static void main(String[] args) {
SimpleFactory factory = new SimpleFactory();//找到工厂
factory.create(1);//下订单制造奔驰汽车
factory.create(2);//下订单制造宝马汽车
}
}
3.工厂方法模式（Factory Method）
汽车给人们带来极大的便利，然后汽车的需求量越来越大,汽车的类型也越来越多。
一个工厂无法制造多种类型的汽车，也已经无法满足当前的需求量了怎么办？
开“分厂”，每个分厂制造只制造一种汽车，大大提升了效率！
interface Factory {
Car create();
}
//奔驰厂
public class BenzFactory implements Factory {
@Override
public Car create() {
return new BenzCar();
}
}
//宝马厂
public class BMWFactory implements Factory {
@Override
public Car create() {
return new BMWCar();
}
}需要奔驰车的去奔驰厂，需要宝马车的去宝马厂。
public class Main {
public static void main(String[] args) {
Factory factory = new BenzFactory();
factory.create();
Factory factory1 = new BMWFactory();
factory1.create();
}
}
4.抽象工厂模式（Abstract Factory）
时代在进步，汽车制造也要进步。现在汽车需要装空调了！
但是空调也有两个品牌：海尔，美的。
public interface Aircondition {
}
public class HaierAircondition implements Aircondition {
public HaierAircondition(){
System.out.println("+装配海尔空调！");
}
}
public class MeiderAircondition implements Aircondition{
public MeiderAircondition() {
System.out.println("+装配美的空调！");
}
}奔驰车装海尔空调，宝马汽车装美的空调！
工厂升级为可装空调的厂！
public interface AbstractFactory {
Car car();
Aircondition aircondition();
}
public class BenzHaierFactory implements AbstractFactory {
@Override
public Car car() {
return new BenzCar();
}
@Override
public Aircondition aircondition() {
return new HaierAircondition();
}
}
public class BMWMeiderFactory implements AbstractFactory {
@Override
public Car car() {
return new BMWCar();
}
@Override
public Aircondition aircondition() {
return new MeiderAircondition();
}
}然而并不是每个客户都买的起空调车：
public class Main {
public static void main(String[] args) {
AbstractFactory factory = new BenzHaierFactory();
factory.car();//购买奔驰汽车
factory.aircondition();//带空调的
AbstractFactory factory1 = new BMWMeiderFactory();
factory1.car();//购买宝马汽车
factory1.aircondition();//待美的空调的
AbstractFactory factory2= new BMWMeiderFactory();
factory2.car();//购买宝马汽车
//factory1.aircondition();//不需要空调的
}
}
5.比较：
工厂方法模式：
- 一个抽象产品类，可以派生出多个具体产品类。
- 一个抽象工厂类，可以派生出多个具体工厂类。
- 每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
- 多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
- 一个抽象工厂类，可以派生出多个具体工厂类。
- 每个具体工厂类可以创建多个具体产品类的实例。
区别：
- 工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
- 工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
总结
- 传统的无工厂模式下，客户调用方法（购买汽车），就必须知道方法的内部实现细节（汽车的制造工艺）。这对客户来说无疑是痛苦的。
- 而在简单工厂模式下，客户调用方法（购买汽车），只需要告诉方法类（工厂）自己需要哪种方法（汽车），无需知道方法的内部实现细节（汽车的制造工艺）。
- 工厂方法模式下，客户只需要找到相应的类（工厂），就能调用相应的方法（购买汽车），极大的方便了客户，提高了效率。然而其需要的类（工厂）根据需求是不断增加的，对应前期的代码投入(工厂投资，建厂)消耗是很大的，并不是完美的。
- 抽象工厂模式下，一个类运行有多个方法了（工厂可以同时汽车和空调），我们可以随意调用类中有关联的方法（汽车是否有空调）。虽然看似与工厂方法类似，但是其实现细节与内存还是有很大差异的。
工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口，但使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。
抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。
工厂方法模式是继承自一个抽象类，子类去实现某一个工厂方法，将对象生产延迟到子类中。而抽象工厂模式，一般是实现一个抽象工厂的接口，由具体的工厂去实现相应的接口，可以这样说吧，抽象工厂模式是包含工厂方法模式的。
代码下载
本文设计的Java代码：
http://download.csdn.net/download/demonliuhui/9957341
参考：
http://blog.csdn.net/lemon_tree12138/article/details/46225213