圖解Java設計模式之設計模式七大原則

来源:https://www.cnblogs.com/haizai/archive/2020/01/29/12240090.html
-Advertisement-
Play Games

圖解Java設計模式之設計模式七大原則 2.1 設計模式的目的 2.2 設計模式七大原則 2.3 單一職責原則 2.3.1 基本介紹 2.3.2 應用實例 2.4 介面隔離原則(Interface Segregation Principle) 2.4.1 基本介紹 2.4.2 應用實例 2.5 依賴 ...


圖解Java設計模式之設計模式七大原則

 

2.1 設計模式的目的

編寫軟體過程中,程式員面臨著來自耦合性,內聚性以及可維護性,可擴展性,重用性,靈活性等多方面的挑戰,設計模式是為了讓程式(軟體)。具有更好
1)代碼重用性(即:相同功能的代碼,不用多次編寫)
2)可讀性(即:編程規範性,便於其他程式員的閱讀和理解)
3)可擴展性(即:當需要增加新的功能時,非常的方便,稱為可維護)
4)可靠性(即:當我們增加新的功能後,對原來的功能沒有影響)
5)使程式呈現高內聚,低耦合的特性
6)設計模式包含了面向對象的精髓,“懂了設計模式,你就懂了面向對象分析和設計(OOA/D)的精要“
7)Scott Mayers 在其巨著《Effective C++》就曾經說過 :C++老手和C++新手的區別就是前者手背上有很多傷疤

2.2 設計模式七大原則

設計模式原則,其實就是程式員在編程時,應當遵守的原則,也是各種設計模式的基礎(即:設計模式為什麼這樣設計的依據)
設計模式常用的七大原則有 :
1)單一職責原則
2)介面隔離原則
3)依賴倒轉(倒置)原則
4)里氏替換原則
5)開閉原則
6)迪米特法則
7)合成復用原則

2.3 單一職責原則

2.3.1 基本介紹

對類來說的,即一個類應該只負責一項職責。如類A負責兩個不同職責 :職責1,職責2。當職責1需求變更而改變A時,可能造成職責2執行錯誤,所以需要將類A的粒度分解為A1,A2

2.3.2 應用實例

以交通工具案例講解

package com.example.testdemo.mode.principle;

public class SingleResponsibility1 {

    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("摩托車");
        vehicle.run("汽車");
        vehicle.run("飛機");
    }

}

// 交通工具類

/**
 * 方式1 :
 * 1 。 在方式1的run方法中,違反了單一職責原則
 * 2 。 解決的方案非常第二季簡單,根據交通工具運行方法不同,分解成不同類即可
 */
class Vehicle {

    public void run(String vehicle) {
        System.out.println(vehicle + " 在公路上運行。。。。。");
    }
}
package com.example.testdemo.mode.principle;

public class SingleResponsibility2 {

    public static void main(String[] args) {
        ReadVehicle readVehicle = new ReadVehicle();
        readVehicle.run("摩托車");
        readVehicle.run("汽車");
        AirVehicle airVehicle = new AirVehicle();
        airVehicle.run("飛機");
        WaterVehicle waterVehicle = new WaterVehicle();
        waterVehicle.run("輪船");
    }

}

/**
 * 方案2分析 :
 * 1 :遵守單一職責原則
 * 2 :但是這樣改動大,即將類分解,同時修改客戶端
 * 3 :改進 :直接修改Vehicle類,改動的代碼會比較少 =》方案3
 *
 */
class ReadVehicle {
    public void run(String vehicle) {
        System.out.println(vehicle + "公路運行");
    }
}

class AirVehicle {
    public void run(String vehicle) {
        System.out.println(vehicle + "天空運行");
    }
}

class WaterVehicle {
    public void run(String vehicle) {
        System.out.println(vehicle + "水中運行");
    }
}
package com.example.testdemo.mode.principle;

public class SingleResponsibility3 {

    public static void main(String[] args) {
        Vehicle2 vehicle2 = new Vehicle2();
        vehicle2.run("汽車");
        vehicle2.runAir("飛機");
        vehicle2.runWater("輪船");
    }

}

/**
 * 方案3的分析 :
 * 1 :這種修改方法沒有對原來的類做大的修改,只是增加方法
 * 2 :這裡雖然沒有在類這個級別上遵守單一職責原則,但是在方法級別上,仍然是遵守單一職責
 */
class Vehicle2 {

    public void run(String vehicle) {
        System.out.println(vehicle + " 在公路上運行。。。。。");
    }

    public void runAir(String vehicle) {
        System.out.println(vehicle + " 在天空上運行。。。。。");
    }

    public void runWater(String vehicle) {
        System.out.println(vehicle + " 在水中運行。。。。。");
    }
}

單一職責原則註意事項和細節
(1) 降低類的複雜度,一個類只負責一項職責。
(2)提高類的可讀性,可維護性。
(3)降低變更引起的風險。
(4)通常情況下,我們應當遵守單一職責原則,只有邏輯足夠簡單,才可以在代碼級違反單一職責原則 :只有類中方法數量足夠少,可以在方法級別保存單一職責原則。

2.4 介面隔離原則(Interface Segregation Principle)

2.4.1 基本介紹

(1)客戶端不應該依賴它不需要的介面,即一個類對另一個類的依賴應該建立在最小的介面上
(2)先看一張圖
在這裡插入圖片描述
(3)類A通過介面Interface1依賴類B,類C通過介面Interface1依賴類D,如果介面Interface1對於類A和類C來說不是最小介面,那麼類B和類C必須去實現他們不需要的方法。
(4)按隔離原則應當這樣處理 :
將介面Interface1拆分為獨立的幾個介面(這裡我們拆分3個介面),類A和類C分別與他們需要的介面建立依賴關係,也就是採用介面隔離原則

2.4.2 應用實例

1)類A通過介面Interface1依賴類B,類C通過介面Interface1依賴類D。
2)沒有使用介面隔離原則的代碼

package com.example.testdemo.mode.principle.segregation;

import io.swagger.models.auth.In;

public class Segregation1 {

    public static void main(String[] args) {

    }

}

/**
 * 介面
 */
interface Interface1 {
    void operation1();
    void operation2();
    void operation3();
    void operation4();
    void operation5();
}

class B implements Interface1 {

    @Override
    public void operation1() {
        System.out.println(" B 實現了 operation1");
    }

    @Override
    public void operation2() {
        System.out.println(" B 實現了 operation2");
    }

    @Override
    public void operation3() {
        System.out.println(" B 實現了 operation3");
    }

    @Override
    public void operation4() {
        System.out.println(" B 實現了 operation4");
    }

    @Override
    public void operation5() {
        System.out.println(" B 實現了 operation5");
    }
}

class D implements Interface1 {

    @Override
    public void operation1() {
        System.out.println(" D 實現了 operation1");
    }

    @Override
    public void operation2() {
        System.out.println(" D 實現了 operation2");
    }

    @Override
    public void operation3() {
        System.out.println(" D 實現了 operation3");
    }

    @Override
    public void operation4() {
        System.out.println(" D 實現了 operation4");
    }

    @Override
    public void operation5() {
        System.out.println(" D 實現了 operation5");
    }
}

/**
 * A 類通過介面Interface1 依賴(使用)B類,但是只會用到1,2,3方法
 */
class A {
    public void depend1(Interface1 interface1) {
        interface1.operation1();
    }

    public void depend2(Interface1 interface1) {
        interface1.operation2();
    }

    public void depend3(Interface1 interface1) {
        interface1.operation3();
    }
}

/**
 * C 類通過介面Interface1 依賴(使用)D類,但是只會用到1,4,5方法
 */
class C {
    public void depend1(Interface1 interface1) {
        interface1.operation1();
    }

    public void depend4(Interface1 interface1) {
        interface1.operation4();
    }

    public void depend5(Interface1 interface1) {
        interface1.operation5();
    }
}
  • 應傳統方法的問題和介面隔離原則改進
    (1)類A通過Interface1依賴類B,類C通過介面Interface1依賴類D,如果介面Interface1對於類A和類C來說不是最小介面,那麼類B和類C必須去實現他們不需要的方法。
    (2)將介面Interface1拆分為獨立的幾個介面,類A和類C分別與他們需要的介面建立依賴關係。也就是採用介面隔離原則。
    (3)介面Interface1中出現的方法,根據實際情況拆分為三個介面
    (4)代碼實現
    在這裡插入圖片描述
package com.example.testdemo.mode.principle.segregation1;

public class Segregation2 {

    public static void main(String[] args) {
        // 使用一把
        A a = new A();
        // A 類通過介面去依賴B類
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());

        // C 類通過介面去依賴(使用)D類
        C c = new C();
        c.depend1(new D());
        c.depend4(new D());
        c.depend5(new D());
    }
}

/**
 * 介面
 */
interface Interface1 {
    void operation1();

}

interface Interface2 {
    void operation2();

    void operation3();
}

interface Interface3 {

    void operation4();

    void operation5();
}

class B implements Interface1, Interface2 {

    @Override
    public void operation1() {
        System.out.println(" B 實現了 operation1");
    }

    @Override
    public void operation2() {
        System.out.println(" B 實現了 operation2");
    }

    @Override
    public void operation3() {
        System.out.println(" B 實現了 operation3");
    }

}

class D implements Interface1, Interface3 {

    @Override
    public void operation1() {
        System.out.println(" D 實現了 operation1");
    }

    @Override
    public void operation4() {
        System.out.println(" D 實現了 operation4");
    }

    @Override
    public void operation5() {
        System.out.println(" D 實現了 operation5");
    }
}

/**
 * A 類通過介面Interface1 ,Interface2 依賴(使用)B類,但是只會用到1,2,3方法
 */
class A {
    public void depend1(Interface1 interface1) {
        interface1.operation1();
    }

    public void depend2(Interface2 interface1) {
        interface1.operation2();
    }

    public void depend3(Interface2 interface1) {
        interface1.operation3();
    }
}

/**
 * C 類通過介面Interface1 ,Interface3 依賴(使用)D類,但是只會用到1,4,5方法
 */
class C {
    public void depend1(Interface1 interface1) {
        interface1.operation1();
    }

    public void depend4(Interface3 interface1) {
        interface1.operation4();
    }

    public void depend5(Interface3 interface1) {
        interface1.operation5();
    }
}

2.5 依賴倒轉原則

2.5.1 基本介紹

依賴倒轉原則(Dependence Inversion Principle)是指 :
(1)高層模塊不應該依賴底層模塊,二者都應該依賴其抽象
(2)抽象不應該依賴細節,細節應該依賴抽象
(3)依賴倒轉(倒置)的中心思想是面向介面編程
(4)依賴倒轉原則是基於這樣的設計理念 :相對於細節的多變性,抽象的東西要穩定的多。以抽象為基礎搭建的架構比以細節為基礎的架構要穩定的多。在java中,抽象指的是介面或抽象類,細節就是具體的實現類。
(5)使用介面或抽象類的目的是制定好規範,而不涉及任何具體的操作,把展示細節的任務交給他們的實現類去完成。

2.5.2 應用實例

1)方案1 + 分析說明

package com.example.testdemo.mode.principle.inversion;

public class DependecyInversion {

    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
    }

}

class Email {
    public String getInfo() {
        return "電子郵件信息 :hello,world";
    }
}

/**
 * 完成Person接收消息的功能
 * 方式1分析
 * 1。簡單,比較容易想到
 * 2。如果我們獲取的對象是微信,簡訊等等,則新增類,同時Persons也要增加相應的接收方法
 * 3。解決思路 :引入一個抽象的介面IReceiver,表示接收者,這樣Person類與介面IReceiver發生依賴
 * 因為Email,微信等等屬於接收的範圍,他們各自實現IReceiver介面就ok,這樣我們就符合依賴倒轉原則
 */
class Person {
    public void receive(Email email) {
        System.out.println(email.getInfo());
    }
}

2)方案2(依賴倒轉)+ 分析說明

package com.example.testdemo.mode.principle.inversion.inprove;

public class DependecyInversion {

    public static void main(String[] args) {
        // 客戶端無需改變
        Person person = new Person();
        person.receive(new Email());

        person.receive(new WeiXin());
    }

}

/**
 * 定義介面
 */
interface IReceiver {
    String getInfo();
}

class Email implements IReceiver{

    @Override
    public String getInfo() {
        return "電子郵件信息 :hello,world";
    }
}

/**
 * 增加微信
 */
class WeiXin implements IReceiver {

    @Override
    public String getInfo() {
        return "微信消息 :hello ok";
    }
}

/**
 * 方式2
 */
class Person {
    /**
     * 這裡是我們對介面的依賴
     * @param iReceiver
     */
    public void receive(IReceiver iReceiver) {
        System.out.println(iReceiver.getInfo());
    }
}

依賴關係傳遞的三種方式 :
1)介面傳遞
2)構造方法傳遞
3)setter方法傳遞

package com.example.testdemo.mode.principle.inversion.inprove;

public class Dependecy {
    public static void main(String[] args) {
        IOpenAndClose iOpenAndClose = new OpenAndClose();
        iOpenAndClose.open(new ChangHong());

        IOpenAndClose2 iOpenAndClose2 = new OpenAndClose2(new XiaoMi());
        iOpenAndClose2.open();

        IOpenAndClose3 iOpenAndClose3 = new OpenAndClose3();
        iOpenAndClose3.setTv(new SanXing());
        iOpenAndClose3.open();
    }
}

/**
 * 方式1 :通過介面傳遞實現依賴
 */
interface IOpenAndClose {
    /**
     * 抽象方法,接收介面
     * @param tv
     */
    void open(ITV tv);
}

/**
 * ITV介面
 */
interface ITV {
    void play();
}

class ChangHong implements ITV {

    @Override
    public void play() {
        System.out.println("長虹電視機打開");
    }
}

/**
 * 實現介面
 */
class OpenAndClose implements IOpenAndClose {

    @Override
    public void open(ITV tv) {
        tv.play();
    }
}

/**
 * 方式2 :通過構造方法依賴傳遞
 */
interface IOpenAndClose2 {
    /**
     * 抽象方法
     */
    void 	   

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 一、過渡模塊的基本使用 1.*:hover;這個偽類選擇器除了可以用在a標簽上,還可以用在其他任何標簽上。 2.過渡三要素: (1)必須要有屬性發生變化;(2)必須告訴系統哪個屬性需要執行過渡效果;(3)必須告訴系統過渡效果持續的時長。 3.註意點: 當多個屬性需要同時執行過渡效果的時候,可以使用英 ...
  • 1.新建js文件 utils.js,自定義方法 let local = { say() { console.log('我是插件裡面自定義的方法') } } export default { install: function(vm) { vm.prototype.$local = local } } ...
  • v-for: v-for 指令需要以 site in sites 形式的特殊語法, sites 是源數據數組並且 site 是數組元素迭代的別名。 demo1. <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title></title> ...
  • 一、故事背景: 1. 今天公司有個項目需求 2. 在前端頁面實現一個倒計時功能 3. 初步設想:後端根據需求規定一個未來的時間,前端根據當前時間進行計算 4. 然後將時間格式化,時分秒的格式 5. 時間倒計時完成,刷新頁面獲取最新的頁面 6. 最後在前端展示;大致是這樣 二、上代碼 <!DOCTYP ...
  • node 的`fs`文檔密密麻麻的 api 非常多,畢竟全面支持對文件系統的操作。文檔組織的很好,操作基本分為文件操作、目錄操作、文件信息、流這個大方面,編程方式也支持同步、非同步和 Promise。 本文記錄了幾個文檔中沒詳細描寫的問題,可以更好地串聯`fs`文檔思路: - 文件描述符 - ... ...
  • 其他設計模式 JavaScript 中不常用 對應不到經典場景 原型模式 行為型 clone 自己,生成一個新對象 java 預設有 clone 介面,不用自己實現 對比 js 中的原型 prototype prototype 可以理解為 es6 class 的一種底層原理 而 class 是實現面 ...
  • 狀態模式 一個對象有狀態變化 每次狀態變化都會觸發一個邏輯 不能總是用 if...else 來控制 示例:交通信號燈的不同顏色變化 傳統的 UML 類圖 javascript 中的 UML 類圖 javascript class State { constructor(color) { this.c ...
  • 迭代器模式 順序訪問一個集合 使用者無需知道集合內部結構(封裝) jQuery 示例 傳統 UML 類圖 javascript 中的 UML 類圖 使用場景 jQuery each 上面的 jQuery 代碼就是 ES6 Iterator ES6 Iterator 為何存在? es6 語法中,有序集 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發(一):使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說,近來想嘗試開發一款安卓APP,考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP,畢竟是使用Visual Studio開發工具,使用起來也比較的順手,結合微軟官方的教程進行了安卓 ...
  • 前言 QuestPDF 是一個開源 .NET 庫,用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫,它徹底改變了我們生成 PDF 文檔的方 ...
  • 項目地址 項目後端地址: https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址: ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址: http://tree ...
  • 話不多說,直接開乾 一.下載 1.官方鏈接下載: https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe,運行開始下載SQL server; 二. ...
  • 前言 隨著物聯網(IoT)技術的迅猛發展,MQTT(消息隊列遙測傳輸)協議憑藉其輕量級和高效性,已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫,為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog支持多種接收器用於日誌存儲,增強器用於添加屬性,LogContext管理動態屬性,支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項,適用於不同需求。 ...
  • 目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據,爬取信息時需要模擬瀏覽器行為,否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下: 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • 1.前言 什麼是熱更新 游戲或者軟體更新時,無需重新下載客戶端進行安裝,而是在應用程式啟動的情況下,在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR,Xlua,ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles,Addressable, ...
  • 本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺,其實像阿裡雲,騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後,它會送 ...
  • 通過以下方式可以高效,並保證數據同步的可靠性 1.API設計 使用RESTful設計,確保API端點明確,並使用適當的HTTP方法(如POST用於創建,PUT用於更新)。 設計清晰的請求和響應模型,以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證,確保接收到的數據符合預期格 ...