工廠模式

簡單工廠模式（Simple Factory Pattern）是指由一個工廠對象,決定建立出哪種產品類的實例。屬於建立型模式，但它不屬於GOF，23種設計模式。

適用場景: 工廠類負責建立的對象較少。客戶端只須要傳入工廠類的參數，對於如何建立對象的邏輯不須要關心。

優勢: 只需傳入一個正確的參數，就能夠獲取你所須要的對象,無須知道其建立的細節

缺點: 1 工廠類的職責相對太重, 增長新的產品時須要修改工廠類的判斷邏輯, 違背開閉原則

         2 不易於擴展國語複雜的產品結構

Java中的Calendar類就用了簡單工廠模式

LoggerFactory的實現類Log4jLoggerFactory也用了簡單工廠模式

Calendar和LoggerFactory也是一個單例對象，工廠模式和單例模式關係很緊密，一般來講是結合使用

public interface ICourse {
    /**
     * 錄製視頻
     * @return
     */
    void record();
}

public class JavaCourse implements ICourse {

    public void record() {
        System.out.println("錄製Java課程");
    }
}

public class PythonCourse implements ICourse {

    public void record() {
        System.out.println("錄製Python課程");
    }
}

public class CourseFactory {

  /* public ICourse create(String name){
       if("java".equals(name)){
           return new JavaCourse();
       }else if("python".equals(name)){
           return new PythonCourse();
       }else {
           return null;
       }
   }*/

   /*public ICourse create(String className){
       try {
           if (!(null == className || "".equals(className))) {
               return (ICourse) Class.forName(className).newInstance();
           }

       }catch (Exception e){
           e.printStackTrace();
       }
       return null;
   }*/

    public ICourse create(Class<? extends ICourse> clazz){
        try {
            if (null != clazz) {
                return clazz.newInstance();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

}

public class SimpleFactoryTest {

    public static void main(String[] args) {

      /* ICourse course = new JavaCourse();
       course.record();*/

       /*ICourseFactory factory = new ICourseFactory();
       ICourse course = factory.create("com.pattern.factory.JavaCourse");
       course.record();*/

        CourseFactory factory = new CourseFactory();
        ICourse course = factory.create(JavaCourse.class);
        course.record();


    }
}

      工廠方法模式（Fatory Method Pattern）是指定義一個建立對象的接口，但讓實現這個接口的類來決定實例化哪一個類，工廠方法讓類的實例化推遲到子類進行。

適用場景: 1 建立對象須要大量重複的代碼 2 客戶端（應用層）不依賴於產品類實例如何被建立、實現等細節。3 一個類經過其子類來指定建立哪一個對象

優勢: 1 用戶只需關心所需產品對應的工廠，無須關心建立細節

        2 加入新產品符合開閉原則，提升了系統的可擴展性

缺點: 1 類的個數容易過多，增長了代碼結構的複雜度

         2 增長了系統的抽象性和理解難度

public interface ICourse {
    /**
     * 錄製視頻
     * @return
     */
    void record();
}

public class JavaCourse implements ICourse {

    public void record() {
        System.out.println("錄製Java課程");
    }
}

public class PythonCourse implements ICourse {

    public void record() {
        System.out.println("錄製Python課程");
    }
}

public interface ICourseFactory {

    ICourse create();

}

public class JavaCourseFactory implements ICourseFactory {
    public ICourse create() {
        return new JavaCourse();
    }
}

public class PythonCourseFactory implements ICourseFactory {

    public ICourse create() {
        return new PythonCourse();
    }
}

public class FactoryMethodTest {

    public static void main(String[] args) {

        ICourseFactory factory = new PythonCourseFactory();
        ICourse course = factory.create();
        course.record();

        factory = new JavaCourseFactory();
        course = factory.create();
        course.record();

    }

}

抽象工廠模式（Abastract Factory Pattern）是指提供一個建立一系列相關或相互依賴對象的接口，無須指定他們具體的類

適用場景: 1 客戶端（應用層）不依賴於產品類實例如何被建立、實現等細節。

               2 強調一系列相關的產品對象（屬於同一產品族）一塊兒使用建立對象須要大量重複的代碼。
               3  提供一個產品類的庫，全部的產品以一樣的接口出現，從而使客戶端不依賴於具體實現

優勢: 1 具體產品在應用層代碼隔離，無須關心建立細節
         2 將一個系列的產品族統一到一塊兒建立

         3 擴展性很是強

缺點: 1 規定了全部可能被建立的產品集合，產品族中擴展新的產品困難，須要修改抽象工廠的接口

         2 增長了系統的抽象性和理解難度

         3 不符合開閉原則

public interface INote {
    void edit();
}

public interface IVideo {
    void record();
}

public class JavaNote implements INote {

    public void edit() {
        System.out.println("編寫Java筆記");
    }
}

public class JavaVideo implements IVideo {
    public void record() {
        System.out.println("錄製Java視頻");
    }
}

public class PythonNote implements INote {

    public void edit() {
        System.out.println("編寫Python筆記");
    }
}

public class PythonVideo implements IVideo {
    public void record() {
        System.out.println("錄製Python視頻");
    }
}

public interface CourseFactory {

    INote createNote();

    IVideo createVideo();

}

public class JavaCourseFactory implements CourseFactory {

    public INote createNote() {
        return new JavaNote();
    }

    public IVideo createVideo() {
        return new JavaVideo();
    }
}

public class PythonCourseFactory implements CourseFactory {

    public INote createNote() {
        return new PythonNote();
    }


    public IVideo createVideo() {
        return new PythonVideo();
    }
}

public class AbstractFactoryTest {

    public static void main(String[] args) {

        JavaCourseFactory factory = new JavaCourseFactory();

        factory.createNote().edit();
        factory.createVideo().record();

    }

}

在Spring中應用得最爲普遍的一種設計模式