java軟件設計七大原則的定義

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

1、開閉原則

1.1、定義

一個軟件實體如類、模塊和函數應該`對擴展開放,對修改關閉`。用抽象構建框架,用實現擴展細節。
優點：提高軟件系統的可復用性以及可維護性

1.2、代碼演示

public interface ICourse {
    Integer getId();
    String getName();
    Double getPrice();
}

public class JavaCourse implements ICourse{
    private Integer Id;
    private String name;
    private Double price;
    public JavaCourse(Integer id, String name, Double price) {
        this.Id = id;
        this.name = name;
        this.price = price;
    }

    public Integer getId() {
        return this.Id;
    }

    public String getName() {
        return this.name;
    }

    public Double getPrice() {
        return this.price;
    }
}

// 如果需要在原有功能基礎上添加一個獲取打折價格的功能,開閉原則建議不要修改原有接口,這里可以繼承原有JavaCourse類,
// 在原有功能之上擴展
public class JavaDiscountCourse extends JavaCourse {

    public JavaDiscountCourse(Integer id, String name, Double price) {
        super(id, name, price);
    }

    public Double getDiscountPrice(){
        return super.getPrice()*0.8;
    }
}

2、依賴倒置原則

2.1、定義

`高層模塊不應該依賴低層模塊`,二者都應該依賴其抽象。抽象不應該依賴細節，細節應該依賴抽象。
針對接口編程，不要針對實現編程。
優點：可以減少類之間的耦合性,提高系統的穩定性,提高代碼可讀性和可維護性,可降低修改程序所造成的風險。

2.2、代碼演示

public interface ICourse {
    void studyCourse();
}

public class JavaCourse implements ICourse {

    @Override
    public void studyCourse() {
        System.out.println("Geely在學習Java課程");
    }
}

public class PythonCourse implements ICourse {
    @Override
    public void studyCourse() {
        System.out.println("Geely在學習Python課程");
    }
}

public class Geely {

    public void setiCourse(ICourse iCourse) {
        this.iCourse = iCourse;
    }

    private ICourse iCourse;

    public void studyImoocCourse() {
        iCourse.studyCourse();
    }

}

public class Test {

    public static void main(String[] args) {
        Geely geely = new Geely();
        geely.setiCourse(new JavaCourse());
        geely.studyImoocCourse();

        geely.setiCourse(new FECourse());
        geely.studyImoocCourse();
    }
}

3、單一職責原則

3.1、定義

不要存在多于一個導致類變更的原因。一個類/接口/方法只負責一項職責。
優點：降低類的復雜度、提高類的可讀性、提高系統的可維護性、降低變更引起的風險。

3.2、代碼演示

// 不推薦的寫法
public class Bird {
    public void mainMoveMode(String birdName){
        
        if("鴕鳥".equals(birdName)){
            System.out.println(birdName+"用腳走");
        }else{
            System.out.println(birdName+"用翅膀飛");
        }
    }
}

public class FlyBird {
    public void mainMoveMode(String birdName){
        System.out.println(birdName+"用翅膀飛");
    }
}

public class WalkBird {
    public void mainMoveMode(String birdName){
        System.out.println(birdName+"用腳走");
    }
}

public class Test {
    public static void main(String[] args) {
        // 不推薦寫法
        Bird bird = new Bird();
        bird.mainMoveMode("大雁");
        bird.mainMoveMode("鴕鳥");

        // 推薦寫法,功能單一
        FlyBird flyBird = new FlyBird();
        flyBird.mainMoveMode("大雁");

        WalkBird walkBird = new WalkBird();
        walkBird.mainMoveMode("鴕鳥");
    }
}

4、接口隔離原則

4.1、定義

用多個專門的接口，而不使用單一的總接口。客戶端不應該依賴它不需要的接口。
一個類對另一個類的依賴應該建立在最小的接口上。
建立單一接口，不要建立龐大臃腫的接口。
`盡量細化接口，接口中的方法盡量少`。
適度原則，一定要適度。
優點：符合我們常說的高內聚低耦合的設計思想,從而使得類具有很好的可讀性、可擴展性和可維護性。

4.2、代碼演示

public interface IAnimalAction {
    void eat();
    void fly();
    void swim();
}

// 將一個接口拆分成3個接口
public interface IEatAnimalAction {
    void eat();
}

public interface IFlyAnimalAction {
    void fly();
}

public interface ISwimAnimalAction {
    void swim();
}

public class Dog implements ISwimAnimalAction,IEatAnimalAction {

    @Override
    public void eat() {

    }

    @Override
    public void swim() {

    }
}

5、迪米特原則

5.1、定義

一個對象應該對其他對象保持最少的了解,又叫最少知道原則。
`盡量降低類與類之間的耦合`。
優點:降低類之間的耦合。

5.2、代碼演示

public class Boss {

    public void commandCheckNumber(TeamLeader teamLeader){
        teamLeader.checkNumberOfCourses();
    }

}

public class Course {
}

public class TeamLeader {
    public void checkNumberOfCourses() {
        List<Course> courseList = new ArrayList<Course>();
        for (int i = 0; i < 20; i++) {
            courseList.add(new Course());
        }
        System.out.println("在線課程的數量是：" + courseList.size());
    }
}

public class Test {
    public static void main(String[] args) {
        Boss boss = new Boss();
        TeamLeader teamLeader = new TeamLeader();
        boss.commandCheckNumber(teamLeader);
    }
}

6、里氏替換原則

6.1、定義

所有引用基類(父類)的地方必須能透明地使用其子類的對象。通俗地講,子類可以擴展父類的功能,但不能改變父類原有的功能。
里氏替換原則意思說，在軟件中將一個基類對象(父類)替換成它的子類對象，程序將不會產生任何錯誤和異常,反過來則不成立,
如果一個軟件實體使用的是一個子類對象的話,那么它不一定能夠使用基類對象。里氏代換原則是實現開閉原則的重要方式之一,
由于使用基類對象的地方都可以使用子類對象,因此在程序中盡量使用基類類型來對對象進行定義,而在程序運行時再確定其子類
類型,用子類對象來替換父類對象。
例如：我喜歡動物,那我一定喜歡狗,因為狗是動物的子類。但是我喜歡狗,不能據此斷定我喜歡動物,因為我并不喜歡老鼠,雖然
它也是動物。

6.2、實現原則

1) `子類可以實現父類的抽象方法,但是不能覆蓋/重寫父類的非抽象方法`。
2) 子類中可以增加自己特有的方法。
3) 當子類覆蓋或實現父類的方法時,方法的前置條件(即方法的形參)要比父類方法的輸入參數更寬松。
4) 當子類的方法實現父類的抽象方法時,方法的后置條件(即方法的返回值)要比父類更嚴格。

參考: Java七大設計原則

7、組合/聚合復用原則

7.1、定義

盡量使用合成和聚合,而不是集成來達到復用的目的。該原則就是在一個新的對象里面使用一些已有的對象,使之成為新對象的
一部分,新的對象通過向這些對象的委派達到復用已有功能的目的。

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