工厂模式的定义就是通过工厂创建对象，当用户需要创建大量不同的对象的时候，通过定义一个创建对象的接口，让子类自己决定创建哪一个对象，用户不再自行判断实例化哪一个对象，不用再去关心创建对象的复杂过程，
我们通过创建一个工厂类，工厂类的作用就是判断需要创建哪个对象，并实例化。
工厂模式分为简单工厂，抽象工厂和工厂方法，有时还会把简单工厂和工厂方法放在一起
简单工厂模式：
简单工厂有一个抽象的产品类，各个具体的产品类继承这个抽象类，抽象产品类中没有写任何的自定义方法（只有一个无参的构造方法）后期可能添加一些规范在里面
package demo_samplefactory;
public abstract class Product {
public Product() {
}
}
每个具体的产品需要继承上面那个抽象类，一下依次为船，车，飞机类。通过简单的输出完成我们建造交通工具的梦想
package demo_samplefactory;
public class Boat extends Product {
public Boat() {
System.out.println("建造小船");
}
}
package demo_samplefactory;
public class Car extends Product {
public Car() {
System.out.println("建造汽车");
}
}
package demo_samplefactory;
public class Plane extends Product {
public Plane() {
System.out.println("建造飞机");
}
}
工厂类中有一个判断的方法，对用户的需求做出判断，实例化哪个对象。
package demo_samplefactory;
public class Factory {
public Factory() {
}
public Product create(String product) {
if (product.equals("飞机")) {
return new Plane();
}
if (product.equals("小船")) {
return new Boat();
}
if (product.equals("汽车")) {
return new Car();
}
return null;
}
}
客户类：
package demo_samplefactory;
public class Customer {
public static void main(String[] args) {
Factory factory = new Factory();
Product car = factory.create("汽车");
Product boat = factory.create("小船");
Product plane = factory.create("飞机");
}
}
客户类需要先创建工厂类的实例，通过工厂类中的方法创建对象（造交通工具）
输出：
建造汽车 建造小船 建造飞机
以上的模式看起来解决了用户创建对象的复杂过程，但是如果需要增加一项，就需要新建一个具体的产品类，在工厂类中更改代码，这就不符合开闭原则，对扩展开放，对修改关闭，如果要大量增加产品的时候会很困难。
工厂方法模式：
工厂方法模式中有一个抽象工厂，其中有抽象的创建对象的方法，具体的工厂需要实现这个方法。具体的工厂类中有创建对应对象的语句。抽象产品类中不写任何方法，后期可以在里面添加产品的规范，具体的产品类需要继承这个类。所创建的对象就是具体的产品类的对象。
抽象工厂：
package demo_abstractfactory;
public abstract class AbstractFactory {
public abstract Product create();
}
抽象产品类：
package demo_abstractfactory;
public abstract class Product {
public Product() {
}
}
以下依次为船，车，飞机类
package demo_abstractfactory;
public class Boat extends Product {
public Boat() {
System.out.println("建造小船");
}
}
package demo_abstractfactory;
public class Car extends Product {
public Car() {
System.out.println("建造汽车");
}
}
package demo_abstractfactory;
public class Plane extends Product {
public Plane() {
System.out.println("建造飞机");
}
}
创建对象的工厂类：每个产品对应一个工厂类，一个工厂负责一项产品，各司其职
依次为船，车，飞机的工厂类：
package demo_abstractfactory;
public class BoatFactory extends AbstractFactory {
@Override
public Boat create() {
return new Boat();
}
}
package demo_abstractfactory;
public class CarFactory extends AbstractFactory {
@Override
public Car create() {
return new Car();
}
}
package demo_abstractfactory;
public class PlaneFactory extends AbstractFactory {
@Override
public Plane create() {
return new Plane();
}
}
客户类：
package demo_abstractfactory;
public class Customer {
public static void main(String[] args) {
CarFactory c = new CarFactory();
Car car = c.create();
BoatFactory b = new BoatFactory();
Boat boat = b.create();
PlaneFactory p = new PlaneFactory();
Plane plane = p.create();
}
}
相比于上面第一种介绍的方法，工厂方法模式把各个创建对象的工厂类分开，一个工厂负责一项产品，各个工厂互不干扰，当用户想要添加一项产品的时候，只需要在写一个产品类和他相对应的工厂即可，符合开闭原则，感觉抽象工厂模式和工厂方法模式很像，具体区别可以参考http://blog.csdn.net/wyxhd2008/article/details/5597975