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.不使用靜态工廠方法，可以形成基于繼承的等級結構。
缺點：難以擴充新種類産品           

總結

• 角色不同
  • 簡單工廠：具體工廠、抽象産品、具體産品
  • 工廠方法：抽象工廠、具體工廠、抽象産品、具體産品
  • 抽象工廠：抽象工廠、具體工廠、抽象産品族、抽象産品、具體産品
• 定義
  • 簡單工廠：由一個工廠類根據傳入的參數，動态決定應該建立哪一個産品類（繼承自一個父類或接口）的執行個體。
  • 工廠方法：定義工廠父類負責定義建立對象的公共接口，而子類則負責生成具體的對象
  • 抽象工廠：提供一個建立一系列相關或互相依賴對象的接口，而無須指定它們具體的類；具體的工廠負責實作具體的産品執行個體。
• 對比
  • 工廠方法模式解決了簡單工廠模式的“開放 - 關閉原則
  • 抽象工廠模式解決了工廠方法模式一個具體工廠隻能建立一類産品

以上為個人了解，如了解有誤歡迎各位指正