設計模式應知應會——抽象工廠模式

1、簡單工廠模式

定義： 專門定義一個類用來負責建立其餘類的實例，被建立的類一般具備共同的父類(沒有也行)

//產品類：
public interface Product {
    void hasFeature();
}

//繼承產品的子類A產品
public class ProductA implements Product {
      public void hasFeature() {
          System.out.println("A產品的特色：好看！");
      }
  }

//繼承產品的子類B產品
public class ProductB implements Product {
    public void hasFeature() {
        System.out.println("B產品的特色：實用！");
    }
}
複製代碼

對於產品實例的建立，咱們能夠建立一個工廠來負責建立他們，須要什麼樣的產品傳入相應的產品參數

public class ProductFactory {
    public static Product createProduct(ProductType pt) throws Exception {
        switch (pt) {
            case PRODUCT_A:
                return new ProductA();
            case PRODUCT_B:
                return new ProductB();
            default:
                throw new Exception("請輸入正確產品,才能夠生產！");
        }
    }
}

public enum ProductType {
    PRODUCT_A,
    PRODUCT_B
}

//調用工廠爲咱們建立對象
public class ToolUser {
    public static void main(String[] args) {
        try {
            //根據傳入的參數選擇建立的產品
            Product pa = ProductFactory.createProduct(ProductType.PRODUCT_A);
            pa.hasFeature();
            ProductB pb = (ProductB) ProductFactory.createProduct(ProductType.PRODUCT_B);
            pb.hasFeature();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
複製代碼

這種模式能夠管理對象的建立，可是若是再生產一種產品C，須要改動工廠和枚舉，耦合性比較大。

2、工廠方法模式

定義： 建立一個生產對象的接口，讓子類決定實例化哪個類。工廠方法使一個類的實例化延遲到其子類.

爲了解決上述耦合過強的問題，咱們將工廠類變得抽象，在工廠方法模式中，核心的工廠類再也不負責全部的產品的建立，而是將具體建立的工做交給子類去作，工廠自身只提供建立產品的接口。

//工廠的做用就是生產產品
public interface Factory {
     Product createProduct();
}

//A工廠負責生產A產品
public class ProductAFactory implements Factory {
    public Product createProduct() {
        return new ProductA();
    }
}

//B工廠負責生產B產品
public class ProductBFactory implements Factory {

    public Product createProduct() {
        return new ProductB();
    }
}


public class Main {
    public static void main(String[] args) {
        //工廠模式須要先建立相應產品工廠，再建立相應產品
        ProductAFactory pa = new ProductAFactory();
        pa.createProduct().hasFeature();

        ProductBFactory pb = new ProductBFactory();
        pb.createProduct().hasFeature();
    }
}
結果：
A產品的特色：好看！
B產品的特色：實用！
複製代碼

在上面的代碼中，若是須要生產產品C,咱們只須要實現工廠接口，建立C工廠類便可，這遵循了開閉原則：
對擴展開放，對修改關閉

3、抽象工廠模式

定義： 提供一個建立一系列相關或者相互依賴對象的接口，而無需指定他們具體的類.當一系列對象變成一種，這時就是工廠模式，能夠看出工廠模式是抽象工廠模式的特例。

工廠模式中，在工廠中生產產品，產品是須要人使用的，因此能夠在工廠中不只指定生產產品，還能夠指定產品使用者,咱們還能夠指定產品品牌，產品發貨地等一系列特性。

//抽象工廠，用於指定生成產品和產品使用者
public interface AbstractFactory {
    //沒必要指定具體的產品類型，這裏符合里氏替換原則，全部接受父類型的地方也須要接受子類型
    Product createProduct();

    Person createPerson();
}

//A產品工廠：生成A產品 使用者爲A
public class ProductAFactory implements AbstractFactory {
    public Product createProduct() {
        return new ProductA();
    }

    public Person createPerson() {
        return new PersonA();
    }
}

//B產品工廠：生成B產品 使用者爲B
public class ProductBFactory implements AbstractFactory {
    public Product createProduct() {
        return new ProductB();
    }

    public Person createPerson() {
        return new PersonB();
    }
}

//使用者接口
public interface Person {
    void say();
}

//A使用者
public class PersonA implements Person {
    public void say() {
        System.out.println("使用者A");
    }
}

//B使用者
public class PersonB implements Person {
    public void say() {
        System.out.println("使用者B");
    }
}
複製代碼

接下來開始加工生產：

public class Main {
    public static void main(String[] args) {
        ProductAFactory pa = new ProductAFactory();
        pa.createProduct().hasFeature();
        pa.createPerson().say();
        ProductBFactory pb = new ProductBFactory();
        pb.createProduct().hasFeature();
        pb.createPerson().say();
    }
}

結果：
A產品的特色：好看！
使用者A
B產品的特色：實用！
使用者B
複製代碼