RE|GoF的23種設計模式-2

時間 2019-12-13

標籤 gof 設計模式简体版

原文原文鏈接

工廠模式

1. 簡單工廠模式

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

場景：簡單工廠適用於工廠類負責建立的對象較少的場景，且客戶端只須要傳入工廠類的參數，對於如何創建對象的邏輯不須要關心。設計模式

舉個例子：bash

/** * 圖書的接口類 */
public interface IBook {
    public void see();
}

public static class BookA implements IBook {

    @Override
    public void see() {
        System.out.println("觀看書~~~~ BookA");
    }
}

public static class BookB implements IBook {

    @Override
    public void see() {
        System.out.println("觀看書~~~~ BookB");
    }
}

/** * 簡單工廠 */
public static class SimpleFactory {
    public static IBook create(String name) {
        switch (name) {
            case "A":
                return new BookA();
            case "B":
                return new BookB();
            default:
                throw new NullPointerException();
        }
    }
}

public static void main(String[] args) {
    // 建立IBook對象解耦--不關注如何建立的
    SimpleFactory.create("A").see();
    SimpleFactory.create("B").see();
}

// 上面的簡單工廠在每次新增圖書後都須要手動修改代碼。不符合開閉原則。
// 咱們對上面的代碼進行升級，使用className加載

public static IBook create(String className) {
    try {
        return (IBook) Class.forName(className).newInstance();
    } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
        e.printStackTrace();
    }
    throw new NullPointerException();
}

public static void main(String[] args) {
    // 建立IBook對象解耦--不關注如何建立的
    // 我測試的時候使用的是內部類所以爲 $
    SimpleFactory.create("com.reape.design.pattern.factory.SimpleFactoryPattern$BookA").see();
    SimpleFactory.create("com.reape.design.pattern.factory.SimpleFactoryPattern$BookB").see();
}

// 使用className加載，傳入的字符串很長，且還須要強制轉換還能夠提高
// 使用 Class 加載

public static IBook create(Class<? extends IBook> clazz) {
    try {
        return clazz.newInstance();
    } catch (InstantiationException | IllegalAccessException e) {
        e.printStackTrace();
    }
    throw new NullPointerException();
}

public static void main(String[] args) {
    // 建立IBook對象解耦--不關注如何建立的
    SimpleFactory.create(BookA.class).see();
    SimpleFactory.create(BookB.class).see();
}

複製代碼

簡單工廠的優勢：解耦使用者和對個實例對象。ide

簡單工廠的缺點：工廠類的職責相對太重，不易於擴展過於複雜的產品結構。測試

2. 工廠方法模式

定義：工廠方法模式（Fatory Method Pattern）是指定義一個建立對象的接口，但讓實現這個接口的類來決定實例化哪一個類，工廠方法讓類的實例化推遲到子類中進行。在工廠方法模式中用戶只須要關心所需產品對應的工廠，無須關心建立細節，並且加入新的產品符合開閉原則。ui

場景：工廠方法適用於如下場景：spa

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

/** * 圖書的接口類 */
public interface IBook {
    public void see();
}

public static class BookA implements IBook {

    @Override
    public void see() {
        System.out.println("觀看書~~~~ BookA");
    }
}

public static class BookB implements IBook {

    @Override
    public void see() {
        System.out.println("觀看書~~~~ BookB");
    }
}

public interface IFactory {
    public IBook create();
}

/** * 簡單工廠 */
public static class AFactory implements IFactory {
    @Override
    public IBook create() {
        return new BookA();
    }
}

public static class BFactory implements IFactory {
    @Override
    public IBook create() {
        return new BookB();
    }
}

public static void main(String[] args) {
    // 建立IBook對象解耦--不關注如何建立的
    new AFactory().create().see();
    new BFactory().create().see();
}

複製代碼

工廠方法的優勢：解耦使用者和對個實例對象。設計

工廠方法的缺點：一、類的個數容易過多，增長複雜度。二、增長了系統的抽象性和理解難度。code

3. 抽象工廠模式

定義：抽象工廠模式（Abstract Factory Pattern）是指提供一個建立一系列相關或相互依賴對象的接口，無須指定他們具體的類。客戶端（應用層）不依賴於產品類實例如何被建立、實現等細節，強調的是一系列相關的產品對象（屬於同一產品族）一塊兒使用建立對象須要大量重複的代碼。須要提供一個產品類的庫，全部的產品以一樣的接口出現，從而使客戶端不依賴於具體實現。對象

場景：抽象工廠模式適用於如下場景：建立對象須要同時建立其餘有關的對象。

舉個例子：

public interface IBook {
    public void see();
}

public interface INote {
    public void see();
}

public static class ABook implements IBook {

    @Override
    public void see() {
        System.out.println("閱讀了 A 書");
    }
}

public static class BBook implements IBook {

    @Override
    public void see() {
        System.out.println("閱讀了 B 書");
    }
}

public static class ANote implements INote {

    @Override
    public void see() {
        System.out.println("閱讀了 A 筆記");
    }
}

public static class BNote implements INote {

    @Override
    public void see() {
        System.out.println("閱讀了 B 筆記");
    }
}


public interface IAbstractFactory {
    IBook createBook();
    INote createNote();
}

public static class AAbstractFactory implements IAbstractFactory {

    @Override
    public IBook createBook() {
        return new ABook();
    }

    @Override
    public INote createNote() {
        return new ANote();
    }
}

public static class BAbstractFactory implements IAbstractFactory {

    @Override
    public IBook createBook() {
        return new BBook();
    }

    @Override
    public INote createNote() {
        return new BNote();
    }
}


public static void main(String[] args) {
    // 建立IBook對象解耦--不關注如何建立的
    IAbstractFactory abstractFactory = new AAbstractFactory();
    abstractFactory.createBook().see();
    abstractFactory.createNote().see();
    abstractFactory = new BAbstractFactory();
    abstractFactory.createBook().see();
    abstractFactory.createNote().see();
}
複製代碼