EventLoop事件輪詢巨集任務和微任務

阿新 • • 發佈：2021-06-24

設計模式常用的七大原則有:

1) 單一職責原則

2) 介面隔離原則

3) 依賴倒轉(倒置)原則

4) 里氏替換原則

5) 開閉原則

6) 迪米特法則

7) 合成複用原則

1.單一職責原則

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

不遵循單一職責

程式碼演示

package com.wang.principle.singleresponsibility;
public class SingleResponsibility {
    public static void 
 main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("汽車");
        vehicle.run("火車");
        vehicle.run("飛機");
    }
}
class Vehicle{
    public void  run(String s)
    {
        System.out.println(s+"正在公路上跑。。。");
    }
}

結果：

汽車正在公路上跑。。。
火車正在公路上跑。。。
飛機正在公路上跑。。。

顯然飛機在公路上跑不符合

解決辦法，一個類只負責一項職責

package com.wang.principle.singleresponsibility;

public class SingleResponsibility2 {
    public static void main(String[] args) {

        RoadVehicle roadVehicle = new RoadVehicle();
        roadVehicle.run("汽車");

        WaterVehicle waterVehicle = new WaterVehicle();
        waterVehicle.run( 
"輪船");

        AirVehicle airVehicle = new AirVehicle();
        airVehicle.run("飛機");
    }
}
class RoadVehicle{
    public void  run(String s)
    {
        System.out.println(s+"正在公路上跑。。。");
    }

}
class WaterVehicle{
    public void  run(String s)
    {
        System.out.println(s+"正在水裡跑。。。");
    }

}
class AirVehicle{
    public void  run(String s)
    {
        System.out.println(s+"正在天空上跑。。。");
    }
}

或者一個方法負責一個職責

package com.wang.principle.singleresponsibility;

public class SingleResponsibility3 {

    public static void main(String[] args) {

        Vehicle2 vehicle2 = new Vehicle2();
        vehicle2.runRoad("汽車");
        vehicle2.runAir("飛機");
        vehicle2.runWater("輪船");

    }
}


class Vehicle2{
    public void  runRoad(String s)
    {
        System.out.println(s+"正在公路上跑。。。");
    }

    public void  runAir(String s)
    {
        System.out.println(s+"正在天空跑。。。");
    }

    public void  runWater(String s)
    {
        System.out.println(s+"正在水上跑。。。");
    }


}

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

2) 介面隔離原則

客戶端不應該依賴它不需要的接口，即一個類對另一個類的依賴應該建立在最小的介面上

上圖類A通過介面Interface1依賴類B，類C通過介面Interface1依賴類D，如果介面 Interface1對於類A和類C來說不是最小介面，那麼類B和類D必須去實現他們不需要的方法。

例項程式碼

package com.wang.principle.segregation;

public class Segregation1 {

    public static void main(String[] args) {

        A a = new A();
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());




    }
}

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

class B implements Interface1 {
    public void operation1() {
        System.out.println("B 實現了 operation1");
    }

    public void operation2() {
        System.out.println("B 實現了 operation2");
    }
    public void operation3() {
        System.out.println("B 實現了 operation3");
    }
    public void operation4() {
        System.out.println("B 實現了 operation4");
    }
    public void operation5() {
        System.out.println("B 實現了 operation5");
    }
}

class D implements Interface1 {
    public void operation1() {
        System.out.println("D 實現了 operation1");
    }

    public void operation2() {
        System.out.println("D 實現了 operation2");
    }
    public void operation3() {
        System.out.println("D 實現了 operation3");
    }
    public void operation4() {
        System.out.println("D 實現了 operation4");
    }
    public void operation5() {
        System.out.println("D 實現了 operation5");
    }
}


class A { //A 類通過介面Interface1 依賴(使用) B類，但是隻會用到1,2,3方法
    public void depend1(Interface1 i) {
        i.operation1();
    }
    public void depend2(Interface1 i) {
        i.operation2();
    }
    public void depend3(Interface1 i)
    {
        i.operation3();

    }

}


class C { //C 類通過介面Interface1 依賴(使用) D類，但是隻會用到1,4,5方法
    public void depend1(Interface1 i) {
        i.operation1();
    }
    public void depend4(Interface1 i) {
        i.operation4();
    }
    public void depend5(Interface1 i) {
        i.operation5();
    }
}

解決方法

將介面Interface1拆分為獨立的幾個介面，類A和類C分別與他們需要的介面建立依賴關係。也就是採用介面隔離

1) 類A通過介面Interface1依賴類B，類C通過介面Interface1依賴類D，如果介面 Interface1對於類A和類C來說不是最小介面，那麼類B和類D必須去實現他們不需要的方法

2) 將介面Interface1拆分為獨立的幾個介面，類A和類C分別與他們需要的介面建立依賴關係。也就是採用介面隔離原則

3) 介面Interface1中出現的方法，根據實際情況拆分為三個介面

4) 程式碼實現

package com.wang.principle.segregation.improve;

public class Segregation1 {

    public static void main(String[] args) {

        A a = new A();
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());

        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 {
    public void operation1() {
        System.out.println("B 實現了 operation1");
    }

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

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

}

class D implements Interface1, Interface3 {
    public void operation1() {
        System.out.println("D 實現了 operation1");
    }

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

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


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

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

    public void depend3(Interface2 i) {
        i.operation3();

    }

}

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

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

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