1. 简单工厂模式又称静态工厂方法模式。从命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。
1.public class CarFactory{
public static Car getCar(int type){
if(type == 1){
return new Car1();
} else {
return new Car2();
}
}
}
2. public class CarFactory{
public static Car getCar(String carClass){
String className = carClass;
Class c = Class.forName(className);
Car car = (Car)c.newInstance();
return car;
}
}
3. public class CarFactory{
public static Car getCar(String carJNDIName){
InitialContext ic = new InitialContext();
String className = ic.lookUp(carJNDIName);
Car car = (Car)Class.forName(className).newInstance();
return car;
}
}
方式1～3适合于工厂所产生的对象都是属于同一个父类型的，而从方式1～3来看，方式1无疑是最简单的，也是最容易理解和接受的，而方式2和方式3则相对来说要高级一点。高级在哪里呢？我们可以看到，方式1中对对象的创建是使用Hardcode的形式，也即是程序员需要事先知道系统里面存在多少个类型的对象及其对应的编号，一旦增加或删除、修改了对象的类型，则必然引起if-else块的改变，造成了维护的困难。
而方式2则采用了动态类加载的方式，方式3在方式2的基础上使用了JNDI，更进了一步，其好处是不用出现HardCode的方式，即便你后面的应用增加、删除了对象的类型，我的程序还是保持现在的样子，跟进一步来说：可以去掉那些讨厌的if-else语句。
2. 工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。【实质上它是让工厂实现了抽象的工厂接口，它把具体怎么生产一种东西，放在具体的工厂去实现了，所谓”延迟到子类中实现“】
示例一：
public interface Driver{
public Car driverCar();
}
public class BenzDriver implements Driver{
public Car driverCar(){
return new Benz();
}
}
public class BmwDriver implements Driver{
public Car driverCar() {
return new Bmw();
}
}
// 应该和具体产品形成对应关系 ...
// 有请暴发户先生
public class Magnate
{
public static void main(String[] args)
{
try{
Driver driver = new BenzDriver();
Car car = driver.driverCar();
car.drive();
}
……
}
示例二：
public interface Creator
{
public Prouct factory();
}
public SubCreator1 implent Creator
{
public Prouct factory()
{
return new ConcreteProduct1();
}
}
public SubCreator2 implent Creator
{
public Prouct factory()
{
return new ConcreteProduct2();
}
}
请注意：返回类型是Product型的！！
这样客户端调用是直接new 一个具体工厂的实例，然后命令它去生产，而对于具体工厂的父类（既工厂接口，接口完全可以改成子类继承父类来实现，只是这样不好，不符合OO的原则），它完全不知道什么产品被生产了，甚至它连那个具体工厂被实例化它都不知道！
3. 抽象工厂
public abstract class AbstractFactory{
public abstract Car getCar(String carClass);
public abstract Plane getPlane(String planeClass);
}
public class Factory1 extends AbstractFactory{
public Car getCar(String carClass){
// 参考上面的方式1～3
return car1;
}
public Plane getPlane(String planeClass){
// 参考上面的方式1～3
return plane1;
}
}
public class Factory2 extends AbstractFactory{
public Car getCar(String carClass){
// 参考上面的方式1～3
return car2;
}
public Plane getPlane(String planeClass){
// 参考上面的方式1～3
return plane2;
}
}
方式4是最为复杂而且也是最为强大的一种，它在实现了对象工厂抽象的基础上，又集成了工厂方法。使到不同的工厂可以生产相同类型的产品，但产品的子类可能有所不同。就像上面的工厂1和工厂2都可以生产汽车和飞机一样，他们各自之间可以生产不同系列的产品(抽象工厂)，而且每个系列下面可能有不同的型号(工厂方法)。
参考资料：
http://www.blogjava.net/pengpenglin/archive/2008/01/02/172325.html
http://www.blogjava.net/killme2008/archive/2007/03/15/104031.html
http://www.blogjava.net/alex/archive/2006/08/29/66479.html