什麼是工廠模式？

顧名思義，就是專門用來建立物件的工廠，這裡的物件指的是具有相同介面的類的物件。工廠模式可以決定將哪一個類進行例項化，不必事先知道每次要例項化的是哪一個類。

工廠模式有以下三種形態:
1、簡單工廠模式：又稱為靜態工廠方法模式。
2、工廠方法模式：又稱為多型性工廠模式或虛擬構造子模式。
3、抽象工廠模式：又稱為工具箱模式。

一、簡單工廠模式

角色分析：
工廠類角色：工廠類在客戶端的直接呼叫下建立產品物件。
抽象產品角色：代表工廠類所要建立物件的父類或者共同擁有的介面。
具體產品角色：工廠類所要建立的角色例項。

/*
 * Abstract Product
 * */
 

public interface Fruit {
    void grow();
    void harvest();
    void plant();
}

/*
 * Concrete product
 * */
public class Apple implements Fruit{

    @Override
    public void grow() {
        System.out.println("Apple is growing...");

    }

    @Override
    public void harvest() {
        System.out.println("Apple has been harvested"
 
);

    }

    @Override
    public void plant() {
        System.out.println("Apple has been planted");

    }

}

/*
 * Concrete product
 * */
public class Grape implements Fruit {

    @Override
    public void grow() {
        System.out.println("Grape is growing...");

    }

    @Override
    public
 
 void harvest() {
        System.out.println("Grape has been harvested");

    }

    @Override
    public void plant() {
        System.out.println("Grape has been planted");

    }

}

/*
 * simple factory
 * */
public class Factory {
    public static Fruit factory(String name) {
        Fruit fruit = null;
        if (name.equals("Apple")) {
            fruit = new Apple();
        } else if (name.equals("Grape")) {
            fruit = new Grape();
        }
        return fruit;
    }
}

/*
 * client
 * */
public class Client {

    public static void main(String[] args) {
        Apple apple = (Apple) Factory.factory("Apple");
        Grape grape = (Grape) Factory.factory("Grape");

        apple.grow();
        apple.harvest();
        apple.plant();

        grape.grow();
        grape.harvest();
        grape.plant();
    }

}

優點：允許客戶端相對獨立於產品建立的過程，並且在系統中引入新產品的時候無需修改客戶端。
缺點：對”開-閉”原則的支援不夠，很明顯，如果有新產品加入，就需要修改工廠類，將必要的邏輯加入到工廠類。例如，如果我們需要加入Orange這個產品類。很明顯，我們需要修改Factory中的factory方法，將Orange這個產品的建立加入進去。

修改它的方法有兩種：
1、使用反射進行處理

/*
 * simple factory
 * */
public class Factory {
    public static Fruit factory(Class clz) {
        Fruit fruit = null;
        try {
            fruit = (Fruit) Class.forName(clz.getName()).newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return fruit;
    }
}

2、使用工廠方法模式

工廠方法模式主要是對工廠類進行了抽象，具體的建立工作由其子類來進行操作，這樣進一步抽象使得在引入新產品的時候父工廠類不被修改，只需要建立對應的工廠子類就可以了。

抽象工廠角色：具體的建立物件的工廠類必須實現這個介面，它不負責建立工作。
具體工廠角色：實現抽象工廠類，會被客戶端呼叫來建立物件。
抽象產品角色：工廠方法模式所建立的物件的超型別。
具體產品角色：實現了抽象產品角色，工廠方法模式所建立的具體物件。

public interface AbstractFactory {
    public AbstractProduct factory();
}

public interface AbstractProduct {

}

public class ConcreteFactory implements AbstractFactory {

    @Override
    public AbstractProduct factory() {
        return new ConcreteProduct();
    }

}

public class ConcreteProduct implements AbstractProduct {
    public ConcreteProduct() {
        System.out.println("create ConcreteProduct");
    }
}

public class Client {

    public static void main(String[] args) {
        AbstractFactory factory = (AbstractFactory) new ConcreteFactory();
        factory.factory();
    }

}

從上面可以看到工廠方法模式的一個明顯的缺點：工廠方法模式中的每個工廠只能生產一類產品，這樣有多少個產品類就會對應多少這個工廠類，明顯這樣會給系統帶來大量的工廠類。

上面的問題可以考慮將一些相關的產品組成一個“產品族”，由同一個工廠來統一生產，這就是抽象工廠模式。抽象工廠模式用來建立一組相關或者相互依賴的物件。與工廠方法模式的區別在於工廠方法模式針對的是一個產品等級結構；抽象工廠模式則是針對的多個產品等級結構。工廠方法模式提供的所有產品都是實現同一個介面，而抽象工廠模式所提供的產品是實現自不同的介面。

抽象工廠:宣告一組用於建立一族產品的方法，每一個方法對應一種產品。
具體工廠:實現了在抽象工廠中宣告的建立產品的方法，生成一組具體產品，這些產品構成了一個產品族.
抽象產品:它為每種產品宣告介面，在抽象產品中聲明瞭產品所具有的業務方法。
具體產品:定義具體工廠生產的具體產品物件，實現抽象產品介面中宣告的業務方法。

public interface AbstractFactory {
    public AbstractProductA factoryA();

    public AbstractProductB factoryB();
}

public class ConcreteFactory implements AbstractFactory {

    @Override
    public AbstractProductA factoryA() {
        return new ConcreteProductA();
    }

    @Override
    public AbstractProductB factoryB() {
        return new ConcreteProductB();
    }

}

public interface AbstractProductA {

}

public interface AbstractProductB {

}

public class ConcreteProductA implements AbstractProductA {
    public ConcreteProductA() {
        System.out.println("create ConcreteProductA");
    }
}

public class ConcreteProductB implements AbstractProductB {
    public ConcreteProductB() {
        System.out.println("create ConcreteProductB");
    }
}

public class Client {
    public static void main(String[] args) {
        ConcreteFactory factory = new ConcreteFactory();
        factory.factoryA();
        factory.factoryB();
    }
}