一、簡單工廠

/*
* 簡單工廠（靜態工廠）
* */

/*
* 抽象產品類
* */
interface CarProduct{
    /*
    * 抽象產品類的抽象方法show()。
    * */
    public void show();
}

/*
* 具體產品類
* */
class BigCarProduct implements CarProduct{
    public void show(){
        System.out.println("It is a BigCar");
    }
 }
 
 /*
 * 具體工廠類
 * */
class CarFacory{
    /*
    * 靜態工廠方法。
    * 例項化一個BigCarProduct物件。
    * */
    public static BigCarProduct createBigCar(){
        return new BigCarProduct();
    }
}
public class FactoryDP {
    public static void main(String[] args) {
        BigCarProduct bigcar = CarFacory.createBigCar();
        bigcar.show();
    }
}
/*
* output:
* It is a BigCar
* */
 

二、工廠方法

/*
* 工廠方法模式
* */

/*
* 抽象產品類
* */
interface CarProduct{
    public void show();
}
/*
* 具體產品類
* */
class BigCarProduct implements CarProduct{
    @Override
    public void show() {
        System.out.println("It is a BigCar");
    }
}

/*
* 抽象工廠類
* */
interface CarFactory{
    public CarProduct createCar();
}

/*
* 具體工廠類
* */
class BigCarFactory implements CarFactory{
    @Override
    /*
    * 建立產品類方法
    * */
    public BigCarProduct createCar() {
        return new BigCarProduct();
    }
}

public class FactoryDP {
    public static void main(String[] args) {
      BigCarFactory bigCarFactory = new BigCarFactory();
      BigCarProduct bigCarProduct = bigCarFactory.createCar();
      bigCarProduct.show();
    }
}
/*
*output:
*It is a BigCar
*/
 

三、抽象工廠

/*
* 抽象工廠模式
* */

/*
* 抽象產品類
* */
interface CarProduct{
    public void show();
}

/*
* 具體產品類
* */
class BigCarProduct implements CarProduct{
    @Override
    public void show() {
        System.out.println("It is a BigCar");
    }
}
class SmartCarProduct implements CarProduct{
    @Override
    public void show() {
        System.out.println("It is a SmartCar");
    }
}

/*
* 抽象工廠類
* */
interface CarFactory{
    public CarProduct createBigCar();
    public CarProduct createSmartCar();
}

/*
* 具體工廠類
* */
class CarBothFactory implements CarFactory{
    /*
    * 建立產品類方法
    * */
    @Override
    public BigCarProduct createBigCar() {
        return new BigCarProduct();
    }
    @Override
    public SmartCarProduct createSmartCar() {
        return new SmartCarProduct();
    }
}
public class FactoryDP {
    public static void main(String[] args) {
     CarBothFactory carbothFactory =  new CarBothFactory();
     carbothFactory.createBigCar().show();
     carbothFactory.createSmartCar().show();
    }
}
/*
* output:
* It is a BigCar
*It is a SmartCar
* */
 

四、總結

上面介紹了三種工廠設計模式，其實當你仔細思考他們的原理時其實都是同一個思想，即將產品的生產和產品的獲取解耦。

在上面的三種工廠模式中，對於使用者來說，不需要知道BigCar與SmartCar是如何進行建立並進行相應配置的，他們只需要獲取一個這種Car的工廠，然後呼叫工廠裡的生產方法，即可得到相應的產品。這就是將兩者解耦了，也消除了顯式的例項化操作。

而這三者又有何區別呢？

1.簡單工廠是靜態工廠，所以他的生產產品的方法是靜態的，在Java面向物件的語法中他自然的喪失了一部分特性，即動態繫結等，因為它屬於類而不是物件。

2.工廠方法和抽象工廠其實沒什麼區別，你從程式碼中就可以看到，不同之處就在於它將一個產品再度的進行了分類，而那個用來分類的標準的術語叫做產品族，這裡的產品族就是Big和Smart，當一個產品需要以一個或多個產品族進行分類時，你寫的工廠方法自然就變成了抽象工廠。