Java進階篇設計模式之二 ----- 工廠模式

時間 2019-11-10

標籤 java 進階設計模式之二工廠欄目 Java 简体版

原文原文鏈接

前言

在上一篇中咱們學習了單例模式，介紹了單例模式建立的幾種方法以及最優的方法。本篇則介紹設計模式中的工廠模式，主要分爲簡單工廠模式、工廠方法和抽象工廠模式。html

簡單工廠模式

簡單工廠模式是屬於建立型模式，又叫作靜態工廠方法模式。簡單工廠模式是由一個工廠對象決定建立出哪種產品類的實例。調用只須要告訴工廠類所須要的類型，工廠類就會返回須要的產品類工廠的子類。能夠說是工廠模式中最簡單的一種。數據庫

打個比方，咱們在電腦常常玩遊戲，咱們只須要告訴電腦咱們要玩什麼遊戲，電腦就會打開這個遊戲，咱們並不須要關心遊戲是怎麼運做的。
咱們能夠在如下的代碼中進行相應的說明。設計模式

咱們首先建立一個遊戲總類接口，包含一個玩遊戲的方法；而後再由各自的遊戲類繼承該類並實現該類的方法，最後在建立一個工程類根據不一樣的遊戲進行建立對象。
那麼實現的代碼以下：框架

代碼示例：ide

private static final String LOL="LOL"; 
    private static final String DNF="DNF"; 
    
    public static void main(String[] args) {
        Game game= ComputerFactory.playGame(LOL);
        Game game2= ComputerFactory.playGame(DNF);
        game.play();
        game2.play();
    }
}

interface Game{
    void play();
}

class LOL implements Game{
    @Override
    public void play() {
        System.out.println("正在玩LOL...");
    }   
}

class DNF implements Game{
    @Override
    public void play() {
        System.out.println("正在玩DNF...");
    }   
}


class ComputerFactory{
    private static final String LOL="LOL"; 
    private static final String DNF="DNF"; 
     public static Game playGame(String game){
         if(LOL.equalsIgnoreCase(game)){
             return new LOL();
         }else if(DNF.equalsIgnoreCase(game)){
             return new DNF();
         }
         return null;
     }

輸出結果：學習

正在玩LOL...
正在玩DNF...

咱們在使用簡單工廠模式進行實現該功能以後，會發現咱們將遊戲類的實例化放到了工廠類中實現，隱藏了對象建立的細節，而且不須要知道是怎麼玩的，只須要知道調用該工廠類就好了。並且方便切換，由於只需更改工廠類傳遞的類型值就好了。
可是咱們也發現一個問題，若是咱們須要新增一個遊戲類，那麼須要新定義一個接口，而後還要在工廠類中添加一個判斷分支，若是少許的話還好，可是大量的話就比較麻煩了，而且這也違背了開放-封閉原則。.net

工廠方法模式

工廠方法模式是 Java 中最經常使用的設計模式之一，屬於建立型模式。定義一個建立對象的接口，讓其子類本身決定實例化哪個工廠類，工廠模式使其建立過程延遲到子類進行。hibernate

在簡單工廠模式中，咱們發如今添加子類的時候，相應的也須要在工廠類中添加一個判斷分支，是違背了開放-封閉原則的。而工廠方法模式就是主要解決這個問題的。設計

這裏仍是用上述的玩遊戲示例，只不過這裏每一個遊戲都是由各自的遊戲工廠類實現。主要區別就是由一個工廠類變成了多個了，下降了耦合度。若是新增一個遊戲類，相應的也只需在新增一個工廠類而已，而且完美的遵循了開放-封閉原則。code

將上述代碼更改以後，相應的代碼實現以下：

代碼示例：

private static final String LOL="LOL"; 
    private static final String DNF="DNF"; 
    private static final String WOW="WOW"; 

    public static void main(String[] args) {

        Game game3=new LOLFactory().playGame();
        Game game4=new DNFFactory().playGame();
        Game game5=new WOWFactory().playGame();
        game3.play();
        game4.play();
        game5.play();       
    }
    
interface Game{
    void play();
}


class LOL implements Game{
    @Override
    public void play() {
        System.out.println("正在玩LOL...");
    }   
}

class DNF implements Game{
    @Override
    public void play() {
        System.out.println("正在玩DNF...");
    }   
}

class WOW  implements Game{
    @Override
    public void play() {
        System.out.println("正在玩WOW...");
    }   
}


interface ComputerFactory2{
    Game playGame(String game);
}

class LOLFactory implements ComputerFactory2{
    @Override
    public Game playGame() {
        return new LOL();
    }
}

class DNFFactory implements ComputerFactory2{
    @Override
    public Game playGame() {
        return new DNF();
    }
}

class WOWFactory implements ComputerFactory2{
    @Override
    public Game playGame() {
        return new WOW();
    }
}

輸出結果：

正在玩LOL...
正在玩DNF...
正在玩WOW...

能夠看到使用工廠方法模式以後，咱們的代碼更加清晰了，擴展性也變高了，若是想增長一個產品，只要擴展一個工廠類就能夠。可是隨之而來的是在系統中增長了複雜度，每增長一個產品時，都須要增長一個具體類和對象實現工廠類。
因此在是否使用該模式需注意。
使用該模式比較經典的使用案例是大名鼎鼎的hibernate框架在選擇數據庫方言這塊。可是若是直接簡單的new一個對象的話，則沒必要使用了，若使用反而會增長系統的複雜度。

抽象工廠模式

抽象工廠模式是圍繞一個超級工廠建立其餘工廠。該超級工廠又稱爲其餘工廠的工廠。這種類型的設計模式屬於建立型模式，它提供了一種建立對象的最佳方式。也就是提供一個建立一系列相關或相互依賴對象的接口，而無需指定它們具體的類。

抽象工廠模式相比工廠方法模式來講更加複雜，也更難理解，可是更容易擴展。
抽象工廠模式就將同一類的產品子類歸爲一類，讓他們繼承同一個抽象子類，而後把它們看成一組，而後再把多個組組成一個族。
打個比方，仍是上述的玩遊戲，咱們能夠把LOL和WOW看成PVP類型的遊戲，也能夠把DNF和WOW看成PVE類型的遊戲。

那麼相應更改的代碼以下：

代碼示例：

private static final String LOL="LOL"; 
    private static final String DNF="DNF"; 
    private static final String WOW="WOW"; 
    
    public static void main(String[] args) {

        ComputerFactory3 cf3=new PVPFactory();
        cf3.playGame().play();
        cf3.playGame2().play();
        ComputerFactory3 cf4=new PVEFactory();
        cf4.playGame().play();
        cf4.playGame2().play();         
    }       
}


interface Game{
    void play();
}


class LOL implements Game{
    @Override
    public void play() {
        System.out.println("正在玩LOL...");
    }   
}

class DNF implements Game{
    @Override
    public void play() {
        System.out.println("正在玩DNF...");
    }   
}

class WOW  implements Game{
    @Override
    public void play() {
        System.out.println("正在玩WOW...");
    }   
}


interface ComputerFactory3{
     Game playGame();
     Game playGame2();
}

class PVPFactory implements ComputerFactory3{

    @Override
    public Game playGame() {
        return new LOL();
    }

    @Override
    public Game playGame2() {
        return new WOW();
    }   
}

class PVEFactory implements ComputerFactory3{

    @Override
    public Game playGame() {
        return new DNF();
    }

    @Override
    public Game playGame2() {
        return new WOW();
    }
    
}

輸出結果：

正在玩LOL...
正在玩WOW...
正在玩DNF...
正在玩WOW...

在抽象工廠模式中，能夠在不須要知道產品是怎麼樣的，只需知道是哪一個工廠類就好了。咱們也能夠根據子類的共同的特性而將它們設計在一塊兒，組成一個相同類型組，能夠很方便的直接調用。可是相對的，產品族比較難以擴展，增長一個產品，須要增長相應的接口和實現類。例如某個品牌的手機，有不一樣系列，每一個系列有不一樣的型號，若是隻是增長型號的話，比較容易，可是相對的，增長某個系列就比較麻煩了。
因此咱們在使用抽象工廠模式，也須要相應的結合實際場景來使用。