java工廠模式

講解三種工廠模式，並比較各自優缺點

簡單工廠

/**
 * @author Gjing
 * 抽象產品
 **/
interface Product {
    void create();
}

/**
 * 產品A
 */
class ProductA implements Product {
    @Override
    public void create() {
        System.out.println("產品A");
    }
}

/**
 * 產品B
 */
class ProductB implements Product {
    @Override
    public void create() {
        System.out.println("產品B");
    }
}

/**
 * 產品工廠
 */
class ProductFactory {
    Product getProduct(Integer type) {
        switch (type) {
            case 1:
                return new ProductA();
            case 2:
                return new ProductB();
            default:
                throw new NullPointerException("沒有你要的產品");
        }
    }
}

調用：

/**
* @author Gjing
**/
public class Test {
   public static void main(String[] args) {
       ProductFactory factory = new ProductFactory();
       Product productA = factory.getProduct(1);
       productA.create();
       Product productB = factory.getProduct(2);
       productB.create();
   }
}

工廠模式

• 工廠

/**
 * @author Gjing
 * 抽象工廠
 **/
public interface Factory {
    /**
     * 生產產品
     * @return Product
     */
    Product create();
}

/**
 * @author Gjing
 * 創建產品A 的工廠A
 **/
class FactoryA implements Factory {
    @Override
    public Product create() {
        return new ProductA();
    }
}

/**
 * @author Gjing
 * 工廠B負責創建產品B
 **/
class FactoryB implements Factory {
    @Override
    public Product create() {
        return new ProductB();
    }
}

• 產品

/**
 * @author Gjing
 * 抽象產品
 **/
interface Product {
    void create();
}

/**
 * 產品A
 */
class ProductA implements Product {
    @Override
    public void create() {
        System.out.println("產品A");
    }
}

/**
 * 產品B
 */
class ProductB implements Product {
    @Override
    public void create() {
        System.out.println("產品B");
    }
}

調用

public class Test {
    public static void main(String[] args) {
        FactoryA factoryA = new FactoryA();
        factoryA.create().create();

        FactoryB factoryB = new FactoryB();
        factoryB.create().create();
    }
}

抽象工廠模式

• 工廠

/**
 * @author Gjing
 **/
public interface Factory {
    Product getProductA();

    Product getProductB();
} 

class FactoryA implements Factory {
    @Override
    public Product getProductA() {
        return new ProductAa();
    }

    @Override
    public Product getProductB() {
        return new ProductBb();
    }
}

• 產品

/**
 * @author Gjing
 * 抽象產品
 **/
abstract class Product {
    abstract void create();
}

/**
 * 抽象產品A
 */
abstract class ProductA extends Product {
    @Override
    abstract void create();
}

/**
 * 抽象產品A的具體某個產品
 */
class ProductAa extends ProductA {
    @Override
    void create() {
        System.out.println("產品A");
    }
}

/**
 * 抽象產品B
 */
abstract class ProductB extends Product {
    @Override
    abstract void create();
}

/**
 * 抽象產品B的具體某個產品
 */
class ProductBb extends ProductB {
    @Override
    void create() {
        System.out.println("產品B");
    }
}

調用

public class Test {
    public static void main(String[] args) {
        Factory factory = new FactoryA();
        factory.getProductA().create();
        factory.getProductB().create();
    }
}

---

以上爲三種不同工廠模式，他們各自的優缺點是啥？

• 簡單工廠

優點：將創建使用工作分開，不必關心類對象如何創建，實現瞭解耦；
缺點：違背“開放 - 關閉原則”，一旦添加新產品就不得不修改工廠類的邏輯，這樣就會造成工廠邏輯過於複雜。

• 工廠模式

a. 優點:      
    1. 符合開-閉原則：新增一種產品時，只需要增加相應的具體產品類和相應的工廠子類即可    
    2. 符合單一職責原則：每個具體工廠類只負責創建對應的產品     
b. 缺點：    
    1. 增加了系統的複雜度：類的個數將成對增加      
    2. 增加了系統的抽象性和理解難度     
    3. 一個具體工廠只能創建一種具體產品

• 抽象工廠

優點：
1.降低耦合
2.符合開-閉原則
3.符合單一職責原則
4.不使用靜態工廠方法，可以形成基於繼承的等級結構。
缺點：難以擴展新種類產品

總結

• 角色不同

  • 簡單工廠：具體工廠、抽象產品、具體產品
  • 工廠方法：抽象工廠、具體工廠、抽象產品、具體產品
  • 抽象工廠：抽象工廠、具體工廠、抽象產品族、抽象產品、具體產品

• 定義

  • 簡單工廠：由一個工廠類根據傳入的參數，動態決定應該創建哪一個產品類（繼承自一個父類或接口）的實例。
  • 工廠方法：定義工廠父類負責定義創建對象的公共接口，而子類則負責生成具體的對象
  • 抽象工廠：提供一個創建一系列相關或相互依賴對象的接口，而無須指定它們具體的類；具體的工廠負責實現具體的產品實例。

• 對比

  • 工廠方法模式解決了簡單工廠模式的“開放 - 關閉原則
  • 抽象工廠模式解決了工廠方法模式一個具體工廠只能創建一類產品

---

以上爲個人理解，如理解有誤歡迎各位指正