Java EE設計模式（主要簡單介紹工廠模式，適配器模式和模板方法模式）

時間 2019-11-19

標籤 java 設計模式主要簡單介紹工廠適配器模板方法欄目 Java 简体版

原文原文鏈接

Java EE設計模式分爲三種類型，共23種：

建立型模式：單例模式、抽象工廠模式、建造者模式、工廠模式、原型模式。
結構型模式：適配器模式、橋接模式、裝飾模式、組合模式、外觀模式、享元模式、代理模式。
行爲型模式：模版方法模式、命令模式、迭代器模式、觀察者模式、中介者模式、備忘錄模式、解釋器模式、狀態模式、策略模式、職責鏈模式(責任鏈模式)、訪問者模式。

下面簡單介紹工廠模式，適配器模式和模板方法模式：java

一工廠模式git

　　簡單列一下這個模式的家族：一、靜態工廠模式二、簡單工廠模式三、工廠方法模式四、抽象工廠模式程序員

一、靜態工廠模式github

這個最多見了，項目中的輔助類，TextUtil.isEmpty等，類+靜態方法。算法

二、簡單工廠模式設計模式

下面開始談談賣肉夾饃，得有個店：RoujiaMoStoreide

package com.zhy.pattern.factory.a;
public class RoujiaMoStore
{
    /**
     * 根據傳入類型賣不一樣的肉夾饃
     * 
     * @param type
     * @return
     */
    public RouJiaMo sellRouJiaMo(String type)
    {
        RouJiaMo rouJiaMo = null;
        
        if (type.equals("Suan"))
        {
            rouJiaMo = new SuanRouJiaMo();
 
        } else if (type.equals("Tian"))
        {
            rouJiaMo = new TianRouJiaMo();
        } else if (type.equals("La"))
        {
            rouJiaMo = new LaRouJiaMo();
        }
        
        rouJiaMo.prepare();
        rouJiaMo.fire();
        rouJiaMo.pack();
        return rouJiaMo;
    }
}

而後你得有各類風味的饃饃：測試

package com.zhy.pattern.factory.a;
 
public abstract class RouJiaMo
{
    protected String name;
 
    /**
     * 準備工做
     */
    public void prepare()
    {
        System.out.println("揉麪-剁肉-完成準備工做");
    }
 
    /**
     * 使用大家的專用袋-包裝
     */
    public void pack()
    {
        System.out.println("肉夾饃-專用袋-包裝");
    }
    /**
     * 祕製設備-烘烤2分鐘
     */
    public void fire()
    {
        System.out.println("肉夾饃-專用設備-烘烤");
    }
}

package com.zhy.pattern.factory.a;
 
import com.zhy.pattern.factory.a.RouJiaMo;
 
/**
 * 辣味肉夾饃
 * @author jing
 */
public class LaRouJiaMo extends RouJiaMo
{
    public LaRouJiaMo()
    {
        this.name = "辣味肉夾饃";
    }
}

package com.zhy.pattern.factory.a;
/**
 * 酸味肉夾饃
 * 
 * @author jing
 */
public class SuanRouJiaMo extends RouJiaMo
{
    public SuanRouJiaMo()
    {
        this.name = "酸味肉夾饃";
    }
}

如今這樣的設計，雖然能夠支持你賣肉夾饃了，可是有點問題，生產饃的種類和你的RoujiaMoStore耦合度過高了，若是增長几種風味，刪除幾種風味，你得一直修改sellRouJiaMo中的方法，因此咱們須要作必定的修改，此時簡單工廠模式就能派上用場了。

咱們開始寫個簡單工廠，把產生饃的過程拿出來：this

package com.zhy.pattern.factory.a;
 
public class SimpleRouJiaMoFactroy
{
    public RouJiaMo createRouJiaMo(String type)
    {
        RouJiaMo rouJiaMo = null;
        if (type.equals("Suan"))
        {
            rouJiaMo = new SuanRouJiaMo();
 
        } else if (type.equals("Tian"))
        {
            rouJiaMo = new TianRouJiaMo();
        } else if (type.equals("La"))
        {
            rouJiaMo = new LaRouJiaMo();
        }
        return rouJiaMo;
    }
 
}

而後以組合的方式，讓Store來使用：spa

package com.zhy.pattern.factory.a;
 
public class RoujiaMoStore
{
    private SimpleRouJiaMoFactroy factroy;
 
    public RoujiaMoStore(SimpleRouJiaMoFactroy factroy)
    {
        this.factroy = factroy;
    }
 
    /**
     * 根據傳入類型賣不一樣的肉夾饃
     * 
     * @param type
     * @return
     */
    public RouJiaMo sellRouJiaMo(String type)
    {
        RouJiaMo rouJiaMo = factroy.createRouJiaMo(type);
        rouJiaMo.prepare();
        rouJiaMo.fire();
        rouJiaMo.pack();
        return rouJiaMo;
    }
 
}

好了，如今你隨便添加什麼種類的饃，刪除什麼種類的饃就和Store無關了，就是麼~人家只負責賣饃麼~ 這就是簡單工廠模式，固然了，你們也都比較熟悉。

二適配器模式以手機充電器爲例

將一個類的接口轉換成客戶指望的另外一個接口，適配器讓本來接口不兼容的類能夠相互合做。這個定義還好，說適配器的功能就是把一個接口轉成另外一個接口。

代碼解釋哈，如題目，手機充電器通常都是5V左右吧，咱天朝的家用交流電壓220V，因此手機充電須要一個適配器（降壓器）

首先一部手機：Mobile.java

package com.zhy.pattern.adapter;
 
public class Mobile
{
    /**
     * 充電
     * @param power 
     */
    public void inputPower(V5Power power)
    {
        int provideV5Power = power.provideV5Power();
        System.out.println("手機（客戶端）：我須要5V電壓充電，如今是-->" + provideV5Power + "V");
    }
}

能夠看出，手機依賴一個提供5V電壓的接口：

package com.zhy.pattern.adapter;
/**
 * 提供5V電壓的一個接口
 * @author zhy
 *
 */
public interface V5Power
{
    public int provideV5Power();
}

而後咱們擁有的是220V家用交流電：

package com.zhy.pattern.adapter;
 
/**
 * 家用220V交流電
 * @author zhy
 *
 */
public class V220Power
{
    /**
     * 提供220V電壓
     * @return
     */
    public int provideV220Power()
    {
        System.out.println("我提供220V交流電壓。");
        return 220 ; 
    }
}

下面咱們須要一個適配器，完成220V轉5V的做用：

package com.zhy.pattern.adapter;
 
/**
 * 適配器，把220V電壓變成5V
 * @author zhy
 *
 */
public class V5PowerAdapter implements V5Power
{
    /**
     * 組合的方式
     */
    private V220Power v220Power ;
    
    public V5PowerAdapter(V220Power v220Power)
    {
        this.v220Power = v220Power ;
    }
 
    @Override
    public int provideV5Power()
    {
        int power = v220Power.provideV220Power() ;
        //power通過各類操做-->5 
        System.out.println("適配器：我悄悄的適配了電壓。");
        return 5 ; 
    } 
    
}

最後測試，咱們給手機衝個電：

package com.zhy.pattern.adapter;
 
public class Test
{
    public static void main(String[] args)
    {
        Mobile mobile = new Mobile();
        V5Power v5Power = new V5PowerAdapter(new V220Power()) ; 
        mobile.inputPower(v5Power);
    }
}

輸出：

    現有類：我提供220V交流電壓。
    適配器：我悄悄的適配了電壓。
    手機（客戶端）：我須要5V電壓充電，如今是-->5V

能夠看出，咱們使用一個適配器完成了把220V轉化了5V而後提供給手機使用，且咱們使用了組合（OO設計原則），原有的手機，以及200V電壓類都不須要變化，且手機（客戶端）和220V（被適配者）徹底解耦。

三模版方法模式展示程序員的一天

定義了一個算法的骨架，而將一些步驟延遲到子類中，模版方法使得子類能夠在不改變算法結構的狀況下，從新定義算法的步驟。

簡單看下定義，模版方法定義了一個算法的步驟，而且容許子類爲一個或多個步驟提供實現。定義還算清晰，下面來個例子展現下本公司的上班狀況（純屬娛樂，若有雷同，請對號入座）。簡單描述一下：本公司有程序猿、測試、HR、項目經理等人，下面使用模版方法模式，記錄下全部人員的上班狀況：

首先來個超類，超類中定義了一個workOneDay方法，設置爲做爲算法的骨架：

package com.zhy.pattern.template;
 
public abstract class Worker
{
    protected String name;
 
    public Worker(String name)
    {
        this.name = name;
    }
 
    /**
     * 記錄一天的工做
     */
    public final void workOneDay()
    {
 
        System.out.println("-----------------work start ---------------");
        enterCompany();
        computerOn();
        work();
        computerOff();
        exitCompany();
        System.out.println("-----------------work end ---------------");
 
    }
 
    /**
     * 工做
     */
    public abstract void work();
 
    /**
     * 關閉電腦
     */
    private void computerOff()
    {
        System.out.println(name + "關閉電腦");
    }
 
    /**
     * 打開電腦
     */
    private void computerOn()
    {
        System.out.println(name + "打開電腦");
    }
 
    /**
     * 進入公司
     */
    public void enterCompany()
    {
        System.out.println(name + "進入公司");
    }
 
    /**
     * 離開公司
     */
    public void exitCompany()
    {
        System.out.println(name + "離開公司");
    }
 
}

定義了一個上班（算法）的骨架，包含如下步驟：

a、進入公司

b、打開電腦

c、上班狀況

d、關閉電腦

e、離開公司

能夠看到，a、b、d、e咱們在超類中已經實現，子類僅實現work這個抽象方法，記錄天天的上班狀況。下面各種人物入場：

程序猿：

package com.zhy.pattern.template;
 
public class ITWorker extends Worker
{
 
    public ITWorker(String name)
    {
        super(name);
    }
 
    @Override
    public void work()
    {
        System.out.println(name + "寫程序-測bug-fix bug");
    }
 
}

測試人員：

package com.zhy.pattern.template;
 
public class QAWorker extends Worker
{
 
    public QAWorker(String name)
    {
        super(name);
    }
 
    @Override
    public void work()
    {
        System.out.println(name + "寫測試用例-提交bug-寫測試用例");
    }
 
}

項目經理：

package com.zhy.pattern.template;
 
public class ManagerWorker extends Worker
{
 
    public ManagerWorker(String name)
    {
        super(name);
    }
 
    @Override
    public void work()
    {
        System.out.println(name + "打dota...");
    }
 
}

下面咱們測試下：

package com.zhy.pattern.template;
 
public class Test
{
    public static void main(String[] args)
    {
 
        Worker it1 = new ITWorker("鴻洋");
        it1.workOneDay();
        Worker pm = new ManagerWorker("坑貨");
        pm.workOneDay();
 
    }
}

輸出結果：

-----------------work start ---------------
鴻洋進入公司
鴻洋打開電腦
鴻洋寫程序-測bug-fix bug
鴻洋關閉電腦
鴻洋離開公司
-----------------work end ---------------

-----------------work start ---------------
坑貨進入公司
坑貨打開電腦
坑貨打dota...
坑貨關閉電腦
坑貨離開公司
-----------------work end ---------------

原文：https://blog.csdn.net/lmj623565791/article/details/24460585