0-前言

　　簡單工廠、工廠方法、抽象工廠都是建立型的設計模式，三個設計模式都是工廠的變種，不復雜，下面我們來快速學習這三種；

1-簡單工廠模式

　　太簡單，UML圖就不畫了，直接上程式碼：

//-----------------1、簡單工廠------------
//1-1、生產者父類
class PhoneMaker
{
    public void  getPhone(){}
}
//1-2、具體生產者
class IphoneMaker extends PhoneMaker
{
    @Override
    public void getPhone()
    {
        System.out.println("生產出了蘋果手機");
    }
}
class HuaweiMaker extends PhoneMaker
{
    @Override
    public void getPhone()
    {
        System.out.println("生產出了華為手機");
    }
}

//1-3 工廠
class PhoneFactory
{
    public  PhoneMaker makePhone(int phoneType)
    {
        PhoneMaker pm = null;
        switch (phoneType)
        {
            case 1:
                pm=new IphoneMaker();
                break;
            case 2:
                pm=new HuaweiMaker();
                break;
            default :
                    break;

        }
        return pm;
    }
}

客戶端：

        //1、簡單工廠模式
        PhoneFactory pf=new PhoneFactory();
        PhoneMaker pm = pf.makePhone(1);
        pm.getPhone();

優缺點：

優點
（1）簡單工廠包含必要的判斷邏輯，簡單工廠實現了物件的建立和使用的分離。
（2）客戶端無需知道所建立的具體產品類的類名，只需要具體產品類對應的引數即可！
（3）在不修改任何客戶端程式碼的情況下更換和增加新的具體產品類，在一定程度上提高了系統的靈活性

缺點
（1）工廠類的職責過重，包含邏輯判斷語句，它一旦有問題，整個系統都要出問題（2）在新增新的類的時候，簡單工廠類就要修改，違反了開放——封閉原則！
 

2-工廠方法模式

同樣，直接上程式碼：

//----------------2、工廠方法模式---------------------
//生產者介面
interface ITVMaker
{
    void getTV();
}
//工廠介面
interface ITVFactory
{
    ITVMaker getTVMaker();
}

//----------------
//具體生產者
class AppleTVMaker implements ITVMaker
{
    @Override
    public void getTV()
    {
        System.out.println("生產出了蘋果電視");
    }
}
class  HuaweiTVMaker implements ITVMaker
{
    @Override
    public void getTV()
    {
        System.out.println("生產出了華為電視");
    }
}
//具體工廠
class AppleTVFactory implements  ITVFactory
{
    @Override
    public ITVMaker getTVMaker()
    {
        return new AppleTVMaker();
    }
}
class HuaweiTVFactory implements ITVFactory
{
    @Override
    public ITVMaker getTVMaker()
    {
        return new HuaweiTVMaker();
    }
}

客戶端：

        //2、工廠方法模式
        //如果要蘋果電視
        ITVFactory  tvf = new AppleTVFactory();
        ITVMaker tvm = tvf.getTVMaker();
        tvm.getTV();
        //如果要華為電視
        // ITVFactory  tvf = new HuaweiTVFactory();

優缺點：

優點：
（1）工廠方法用來建立客戶所需要的產品，同時隱藏了哪種具體產品類將被例項化的細節，使用者只需要要關注工廠，不需要關注建立的細節！
(2)在增加修改新的產品的時候不用修改程式碼，只需要增加對應的工廠就好，完全符合開放——封閉性原則！
（3）建立物件的細節完全封裝在具體的工廠內部，而且有了抽象的工廠類，所有的具體工廠都繼承了自己的父類！完美的體現了多型性！

缺點：
（1）在增加新的產品時，也必須增加新的工廠類，會帶來額外的開銷

3-抽象工廠模式

同樣，直接上程式碼：

//--------------------3、抽象工廠模式--------------
//產品介面
class BookMaker //產品1
{
    public void makeBook()
    {}
}
class  PenMaker //產品2
{
    public void makePen()
    {}
}
//工廠介面
interface IstudentFactory
{
    BookMaker CreateBookmaker();
    PenMaker CreatPenkmaker();
}
//------實現具體產品
class MinBookMaker extends BookMaker
{
    @Override
    public void makeBook()
    {
        System.out.println("生產了小學課本");
    }
}
class  MinPenMaker extends PenMaker
{
    @Override
    public void makePen()
    {
        System.out.println("生產了小學生用的筆");
    }
}
//  。。。。。產品1234...
//具體工廠
class  MinStudentFactory implements IstudentFactory
{
    @Override
    public BookMaker CreateBookmaker()
    {
        return  new MinBookMaker();
    }

    @Override
    public PenMaker CreatPenkmaker()
    {
        return  new MinPenMaker();
    }
}
//......工廠1234.....

客戶端：

//3、抽象工廠
        IstudentFactory factory = new MinStudentFactory(); //生產小學生的產品系列
        BookMaker bookMaker = factory.CreateBookmaker();
        PenMaker penMaker =factory.CreatPenkmaker();
        bookMaker.makeBook();
        penMaker.makePen();
　　　　　//...生產中學生的系列產品.....
　　　　　// IstudentFactory factory = new MiddleStudentFactory();

//----- 3.1 以下是配合反射的抽象工廠------
        String studentType="Min";
        try
        {
           // Class<?> c =Class.forName(this.getClass().getPackage().getName() + studentType + "StudentFactory");
            Class<?> c =Class.forName("com.anson.designpattern.designPattern.MinStudentFactory");
            IstudentFactory studentFactory = (IstudentFactory)c.newInstance();
            BookMaker bookMaker1 = studentFactory.CreateBookmaker();
            PenMaker penMaker1 =studentFactory.CreatPenkmaker();
            bookMaker1.makeBook();
            penMaker1.makePen();
        }
        catch (Exception e)
        {
            System.out.println(e);
        }

優缺點：

增加一個產品族很簡單，而增加一個新的產品就會非常複雜！

4-一句話總結

簡單工廠 ： 用來生產同一等級結構中的任意產品。（對於增加新的產品，無能為力）
工廠方法 ： 用來生產同一等級結構中的固定產品。（支援增加任意產品）
抽象工廠 ： 用來生產不同產品族的全部產品。（對於增加新的產品，無能為力；支援增加產品族）