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.aygfsteel.com/pengpenglin/archive/2008/01/02/172325.html
http://www.aygfsteel.com/killme2008/archive/2007/03/15/104031.html
http://www.aygfsteel.com/alex/archive/2006/08/29/66479.html