java設計模式的七大設計原則說明

本篇內容介紹了“java設計模式的七大設計原則說明”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

概述

簡單介紹一下七大設計原則：

1. 開閉原則：是所有面向對象設計的核心，對擴展開放，對修改關閉

2. 依賴倒置原則：針對接口編程，依賴于抽象而不依賴于具體

3. 單一職責原則：一個接口只負責一件事情，只能有一個原因導致類變化

4. 接口隔離原則：使用多個專門的接口，而不是使用一個總接口

5. 迪米特法則（最少知道原則）：只和朋友交流（成員變量、方法輸入輸出參數），不和陌生人說話，控制好訪問修飾符

6. 里氏替換原則：子類可以擴展父類的功能，但不能改變父類原有的功能

7. 合成復用原則：盡量使用對象組合(has-a)/聚合(contanis-a)，而不是繼承關系達到軟件復用的目的

開閉原則

定義

指一個軟件實體如類、模塊和函數應該對擴展開放，對修改關閉。<br />所謂的開閉，也正是對擴展和修改兩個行為的一個原則。強調的是用抽象構建框架，用實現擴展細節。可以提高軟件系統的可復用性及可維護性。開閉原則，是面向對象設計中最基礎的設計原則。它指導我們如何建立穩定靈活的系統，例如：我們版本更新，我盡可能不修改源代碼，但是可以增加新功能。

在現實生活中對于開閉原則也有體現。比如，很多互聯網公司都實行彈性制作息時間，規定每天工作 8 小時。意思就是說，對于每天工作 8 小時這個規定是關閉的，但是你什么時候來，什么時候走是開放的。早來早走，晚來晚走。

實例

實現開閉原則的核心思想就是面向抽象編程，接下來我們來看一段代碼：

以書店銷售書籍為例，創建書籍接口：

/**
 * @author eamon.zhang
 * @date 2019-09-25 上午10:26
 */
public interface IBook {
    // 書籍名稱
    public String getName();
    // 價格
    public int getPrice();
    // 作者
    public String getAuthor();
}

書籍分為很多類，比如有小說類等，創建小說類書籍：

/**
 * @author eamon.zhang
 * @date 2019-09-25 上午10:30
 */
public class NovelBook implements IBook {
    // 書名
    private String name;
    // 售價
    private int price;
    // 作者
    private String author;
    // 通過構造函數傳遞數據數據
    public NovelBook(String name, int price, String author) {
        this.name = name;
        this.price = price;
        this.author = author;
    }
    // 獲取書名
    public String getName() {
        return this.name;
    }
    // 獲取價格
    public int getPrice() {
        return this.price;
    }
    // 獲取作者
    public String getAuthor() {
        return this.author;
    }
}

現在我們要給小說類書籍做一個活動，價格優惠。如果修改 NovelBook 中的 getPrice()方法，則會存在一定的風險，可能影響其他地方的調用結果。我們如何在不修改原有代碼前提前下，實現價格優惠這個功能呢？現在，我們再寫一個處理優惠邏輯的類，NovelDiscountBook 類（思考一下為什么要叫 NovelDiscountBook，而不叫 DiscountBook）：

/**
 * @author eamon.zhang
 * @date 2019-09-25 上午10:36
 */
public class NovelDiscountBook extends NovelBook {
    public NovelDiscountBook(String name, int price, String author) {
        super(name, price, author);
    }

    public double getOriginPrice(){
        return super.getPrice();
    }

    public double getPrice(){
        return super.getPrice() * 0.85;
    }
}

類結構圖

cdn.nlark.com/yuque/0/2019/png/239945/1569379306123-5eb0d472-aa9f-425e-9908-000af06a0c9e.png">

依賴倒置原則

定義

依賴倒置原則（DependenceInversionPrinciple,DIP）是指設計代碼結構時，高層模塊不應該依賴底層模塊，二者都應該依賴其抽象。抽象不應該依賴細節；細節應該依賴抽象。通過依賴倒置，可以減少類與類之間的耦合性，提高系統的穩定性，提高代碼的可讀性和可維護性，并能夠降低修改程序所造成的風險。

實例

我們以閱讀書籍為例，先創建一個 Eamon 類：

/**
 * @author eamon.zhang
 * @date 2019-09-25 上午11:09
 */
public class Eamon {
    public void readNotreDame(){
        System.out.println("Eamon 在閱讀 《巴黎圣MU院》");
    }

    public void readTheOldManAndTheSea(){
        System.out.println("Eamon 在閱讀 《老人與海》");
    }
}

寫個測試類調用一下：

public static void main(String[] args) {
    Eamon eamon = new Eamon();
    eamon.readNotreDame();
    eamon.readTheOldManAndTheSea();
}

Eamon 目前正在閱讀者兩本書。但是學習是無止境的，Eamon 讀完這些書之后還想讀《天龍八部》。這個時候，業務擴展，我們的代碼要從底層到高層（調用層）一次修改代碼。在 Eamon 類中添加 readTianLongBaBu()的方法，在高層也要追加調用。如此一來，系統發布以后，實際上是非常不穩定的，在修改代碼的同時也會帶來意想不到的風險。接下來我們優化代碼，創建一個課程的抽象 IBook 接口：

/**
 * @author eamon.zhang
 * @date 2019-09-25 上午11:20
 */
public interface IBook {
    void read();
}

然后寫NotreDameBook類：

/**
 * @author eamon.zhang
 * @date 2019-09-25 上午11:22
 */
public class NotreDameBook implements IBook {
    public void read() {
        System.out.println("Eamon 在閱讀 《巴黎圣MU院》");
    }
}

再寫  TheOldManAndTheSeaBook  類：

/**
 * @author eamon.zhang
 * @date 2019-09-25 上午11:23
 */
public class TheOldManAndTheSeaBook implements IBook{
    public void read() {
        System.out.println("Eamon 在閱讀 《老人與海》");
    }
}

修改Eamon類

/**
 * @author eamon.zhang
 * @date 2019-09-25 上午11:09
 */
public class Eamon {
    public void read(IBook iBook){
        iBook.read();
    }
}

來看調用：

public static void main(String[] args) {
    Eamon eamon = new Eamon();
    eamon.read(new NotreDameBook());
    eamon.read(new TheOldManAndTheSeaBook());
}

我們這時候再看來代碼，Eamon 再想讀任何書，對于新書，我只需要新建一個類，通過傳參的方式告訴 Eamon，而不需要修改底層代碼。實際上這是一種大家非常熟悉的方式，叫依賴注入。注入的方式還有構造器方式和 setter 方式。我們來看構造器注入方式：

/**
 * @author eamon.zhang
 * @date 2019-09-25 上午11:09
 */
public class Eamon {

    public Eamon(IBook iBook) {
        this.iBook = iBook;
    }

    private IBook iBook;

     public void read(){
        iBook.read();
    }
}

看調用代碼：

public static void main(String[] args) {
    Eamon eamon = new Eamon(new NotreDameBook());
    eamon.read();
}

根據構造器方式注入，在調用時，每次都要創建實例。那么，如果 Eamon 是全局單例，則我們就只能選擇用 Setter 方式來注入，繼續修改 Eamon 類的代碼：

/**
 * @author eamon.zhang
 * @date 2019-09-25 上午11:09
 */
public class Eamon {
    private IBook iBook;
    public void setBook(IBook iBook) {
        this.iBook = iBook;
    }
    public void read(){
        iBook.read();
    }
}

看調用代碼：

public static void main(String[] args) {
    Eamon eamon = new Eamon();
    eamon.setBook(new NotreDameBook());
    eamon.read();

    eamon.setBook(new TheOldManAndTheSeaBook());
    eamon.read();
}

最終類圖

切記：以抽象為基準比以細節為基準搭建起來的架構要穩定得多，因此大家在拿到需求之后，要面向接口編程，先頂層再細節來設計代碼結構。

“java設計模式的七大設計原則說明”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！