一、基本定義

/*
 *簡單工廠設計模式：
 *文字描述理解：
 * 簡單工廠模式屬於類的創建型模式，又叫做靜態工廠方法模式。
 * 通過專門定義一個類來負責創建其它類的實例，被創建的實例通常
 * 都具有共同的父類。
 * */

二、首先創建Apple、Banana實體類

public class Apple {

    public void eat(){
        System.out.println("吃蘋果");
    }
}

public class Banana {
    public void eat(){
        System.out.println(
 
"吃香蕉");
    }
}

編寫測試類：

public class MainClass {

    public static void main(String[] args) {
        //實例Apple
        Apple apple = new Apple();
        //實例Banana
        Banana banana = new Banana();

        apple.eat();
        banana.eat();

        //可以發現Apple、Banana可以共同抽象出一個接口eat
 


    }

}

在運行中，我們發現Apple、Banana類都有共同的方法。那麽我們就可以抽象出來一個接口來實現。修改代碼如下：

public interface Fruit {
    void eat();
}

public class Apple implements Fruit {

    @Override
    public void eat() {
        System.out.println("吃蘋果");
    }
}

public class Banana implements Fruit{
    @Override
    
 
public void eat() {
        System.out.println("吃香蕉");
    }
}

public class MainClass {

    public static void main(String[] args) {
        /*
        //實例Apple
        Apple apple = new Apple();
        //實例Banana
        Banana banana = new Banana();

        apple.eat();
        banana.eat();
        **/

        //可以發現Apple、Banana可以共同抽象出一個接口eat,多態實例化
        Fruit apple = new Apple();
        Fruit banana = new Banana();
        apple.eat();
        banana.eat();
        //按照定義：通過專門定義一個類來負責創建其他類的實例，那麽我們就需要創建FruitFactory實例，具體代碼如下。


    }

}

創建FruitFactory工廠類：

public class FruitFactory {
    /*
     *獲得Apple類的實例
     * */
    public Fruit getApple(){
        return new Apple();
    }

    /*
     *獲得Banana類的實例
     * */
    public Fruit getBanana(){
        return new Banana();
    }
}

MainClass測試類；

public class MainClass {

    public static void main(String[] args) {
        /*
        //實例Apple
        Apple apple = new Apple();
        //實例Banana
        Banana banana = new Banana();

        apple.eat();
        banana.eat();
        **/

        //可以發現Apple、Banana可以共同抽象出一個接口eat,多態實例化
//        Fruit apple = new Apple();
//        Fruit banana = new Banana();
//        apple.eat();
//        banana.eat();
        //按照定義：通過專門定義一個類來負責創建其他類的實例FruitFactory
        Fruit apple = new FruitFactory().getApple();
        Fruit banana = new  FruitFactory().getBanana();
        apple.eat();
        banana.eat();
    }

}

那麽我們有沒有具體什麽需要改進的地方？FruitFactory表明靜態方法。這樣就不用再新建實例化了。

public class FruitFactory {
    /*
     *獲得Apple類的實例
     * */
    public static Fruit getApple(){
        return new Apple();
    }

    /*
     *獲得Banana類的實例
     * */
    public static Fruit getBanana(){
        return new Banana();
    }
}

　　　　　//直接類名調用即可。 
       Fruit apple = FruitFactory.getApple();
        Fruit banana = FruitFactory.getBanana();
        apple.eat();
        banana.eat();

三、模式中包含的角色和職責

1.工廠（Creator）角色簡單工廠模式的核心，它負責實現創建所有實例的內部邏輯。工廠類可以被外界直接調用，創建所需的產品對象。

　　比如：我們本次創建的FruitFactory

2.抽象（Product）角色，簡單工廠模式所創建的所有對象的父類，它負責描述所有實例所共有的公共接口。
3.具體產品（Concrete Product）角色簡單工廠模式所創建的具體實例對象

FruitFactory我們需要抽象一個具體方法，get所有的對象實例化。

public class FruitFactory {
//    /*
//     *獲得Apple類的實例
//     * */
//    public static Fruit getApple(){
//        return new Apple();
//    }
//
//    /*
//     *獲得Banana類的實例
//     * */
//    public static Fruit getBanana(){
//        return new Banana();
//    }

    //get所有的對象
    public static Fruit getFruit(String name) throws IllegalAccessException, InstantiationException {
        if (name.equalsIgnoreCase("apple")){
            return Apple.class.newInstance();
        }else if (name.equalsIgnoreCase("banana")){
            return Banana.class.newInstance();
        }else {
            return null;
        }
    }
}

           //測試類
        Fruit apple = FruitFactory.getFruit("apple");
        Fruit banana = FruitFactory.getFruit("banana");
        apple.eat();
        banana.eat();    

FruitFactory裏面的get實例，我們可以繼續優化。

public class FruitFactory {
//    /*
//     *獲得Apple類的實例
//     * */
//    public static Fruit getApple(){
//        return new Apple();
//    }
//
//    /*
//     *獲得Banana類的實例
//     * */
//    public static Fruit getBanana(){
//        return new Banana();
//    }

    //get所有的對象
    public static Fruit getFruit(String name) throws IllegalAccessException, InstantiationException, ClassNotFoundException {
//        if (name.equalsIgnoreCase("apple")){
//            return Apple.class.newInstance();
//        }else if (name.equalsIgnoreCase("banana")){
//            return Banana.class.newInstance();
//        }else {
//            return null;
//        }
        
        Class<?> aClass = Class.forName(name);
        return (Fruit) aClass.newInstance();

    }
}

註意：測試類測試傳入的String類型；

        Fruit apple = FruitFactory.getFruit("Apple");
        Fruit banana = FruitFactory.getFruit("Banana");
        apple.eat();
        banana.eat();

Class<?> aClass = Class.forName(name);
這部分代碼的調用，比之前相比比較靈活了。

在這個模式中，工廠類是整個模式的關鍵所在。它包含必要的判斷
邏輯，能夠根據外界給定的信息，決定究竟應該創建哪個具體類的
對象。用戶在使用時可以直接根據工廠類去創建所需的實例，而無
需了解這些對象是如何創建以及如何組織的。有利於整個軟件體系
結構的優化。
不難發現，簡單工廠模式的缺點也正體現在其工廠類上，由於工廠類集中
了所有實例的創建邏輯，所以“高內聚”方面做的並不好。另外，當系統中的
具體產品類不斷增多時，可能會出現要求工廠類也要做相應的修改，擴展
性並不很好。在具體調用比較麻煩。

一般推薦第二種比較好。

那麽，這種模式具體會在哪些方面應用比較多。

比如：在JDBC不同數據庫實現方面。

java簡單工廠設計模式