工廠模式Factory

定義：

定義一個用於建立對象的接口，讓子類決定實例化哪一個類。

工廠模式類圖：

類圖說明：

• Product：抽象產品類
  • 負責定義產品的共性，實現對事物最抽象的定義。
• ConcreteProduct：具體產品類
  • 實現抽象產品的某個具體產品的對象。
• Factory：抽象工廠類
  • 工廠方法模式的核心
• ConcreteFactory：具體工廠類
  • 實現具體的業務邏輯

使用場景：

任何須要生成複雜對象的地方，均可以使用工廠方法模式。複雜對象適合使用工廠模式，用new就能夠完成建立的對象無需使用工廠模式。（即須要經過較複雜或動態的方式生成一個對象的時候）

工廠模式的實現方式

/**
 * 抽象產品類
 */
public abstract class Product {
    /**
     * 產品類的抽象方法
     * 由具體的產品類去實現
     */
    public abstract void method();
}

/**
 * 具體產品類A
 */
public class ConcreteProductA extends Product {
    @Override
    public void method() {
        System.out.println("我是具體的產品A");
    }
}

/**
 * 具體產品類B
 */
public class ConcreteProductB extends Product {
    @Override
    public void method() {
        System.out.println("我是具體的產品B");
    }
}

/**
 * 抽象工廠類
 */
public abstract class Factory {
    /**
     * 抽象工廠方法
     * 具體產生什麼由子類去實現
     * 
     * @return 具體的產品對象
     */
    public abstract Product createProduct();
}

/**
 * 具體工廠類
 */
public class ConcreteFactory extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

/**
 * 客戶類
 */
public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Product p = factory.createProduct();
        p.method();
    }
}

其餘實現方式

1. 在具體工廠類中寫死生成的產品類，如前面的例子，若是須要生成ConcreteProductB，更改ConcreteFactory中的邏輯便可：

/**
 * 具體工廠類
 */
public class ConcreteFactory extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
//      return new ConcreteProductA();
    }
}

2. 利用反射的方式在客戶類中決定生成哪一個產品類：

/**
 * 抽象工廠類
 */
public abstract class Factory {
    /**
     * 抽象工廠方法
     * 具體產生什麼由子類去實現
     *
     * @param clz 產品對象類類型
     * 
     * @return 具體的產品對象
     */
    public abstract <T extends Product> T createProduct(Class<T> clz);
}

/**
 * 具體工廠類
 */
public class ConcreteFactory extends Factory {
    @Override
    public <T extends Product> T createProduct(Class<T> clz) {
        Product p = null;
        try {
            p = (Product) Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        } 
        return (T)p;
    }
}

/**
 * 客戶類
 */
public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory();
        Product p = factory.createProduct(ConcreteProductA.class);
        p.method();
    }
}

3. 多工廠方法模式，爲每個產品都定義一個具體的工廠，各司其職：

/**
 * 具體工廠類A
 */
public class ConcreteFactoryA extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

/**
 * 具體工廠類B
 */
public class ConcreteFactoryB extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

/**
 * 客戶類
 */
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.method();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.method();
    }
}

4. 簡單工廠模式（靜態工廠模式），若是肯定咱們的工廠類只有一個，那麼能夠簡化掉抽象類：

/**
 * 簡單工廠類(靜態工廠類)
 */
public class Factory {
    /**
     * 抽象工廠方法
     * 具體產生什麼由子類去實現
     *
     * @return 具體的產品對象
     */
    public static Product createProduct() {
        return new ConcreteProductA();
    }
}