oop - software - types of method cohesion




面向對象範式中的松耦合和緊耦合有什麼區別? (10)

任何人都可以描述面向對象範式中松耦合和緊耦合之間的確切區別嗎?


緊耦合與松耦合之間的程序明智差異?

Java對象之間的緊耦合

class Traveler
{
    Car c=new Car();
    void startJourney()
    {
       c.move();
    }
}

class Car
{
  void move()
  {
     // logic...
  }
}

Java對象之間的鬆散耦合

class Traveler
{
    Vehicle v;
    public void setV(Vehicle v)
    {
      this.v = v;
    }      

    void startJourney()
    {
       v.move();
    }
}

// =========================接口====================== ==============

 Interface Vehicle
    {
       void move();
    }

// ====================多類工具車輛界面。 第一課====

class Car implements Vehicle
{
    public void move()
    {
         // logic
    }
}

// ===================第二課================

class Bike implements Vehicle
{
    public void move()
    {
         // logic
    }
}

無代碼概念的解釋

(代碼請參考上面的答案。)

摘要示例:

帽子與身體“鬆散耦合”。 這意味著你可以輕鬆脫帽而不對人物/身體做任何改變。 當你可以做到這一點,那麼你有“松耦合”。 詳見下文。

緊耦合(詳細示例)

想想你的皮膚。 它粘在你的身上。 它適合像手套一樣。 但是如果你想改變膚色從白色變成黑色呢? 你能想像剝下你的皮膚,染上它,然後將它重新粘貼在上面會有多痛苦嗎? 改變你的皮膚很困難,因為它與你的身體緊密相連。 您無法輕鬆進行更改。 你將不得不從根本上重新設計一個人,以使之成為可能。

  • 要點#1 :換句話說, 如果你想改變皮膚,你也必須改變你的身體設計,因為兩者聯合在一起 - 它們緊密結合在一起。

上帝不是一個好的面向對象的程序員。

松耦合(詳細示例)

現在想想早上穿衣服。 你不喜歡藍色? 沒問題:你可以換一件紅色的襯衫。 你可以輕鬆而輕鬆地做到這一點,因為襯衫並不像你的皮膚那樣真正地連接到你的身體。 襯衫不知道或關心它正在發生什麼樣的身體 。 換句話說,你可以改變你的衣服,而不會改變你的身體。

  • 這是關鍵點#2。 如果你換了襯衫,那麼你不會被迫改變你的身體 - 當你這樣做的時候,那麼你會有鬆散的聯結。 當你無法做到這一點,那麼你有緊密的聯繫。

簡而言之,這就是基本概念。

為什麼這一切很重要?

這一點很重要,因為軟件一直在變化。 一般而言,您希望能夠輕鬆修改您的代碼。

例如實際例子

  • 如果有人希望以CSV文件而非JSON等方式輸出它們,或者如果您想從MySQL切換到PostGreSQL,則應該能夠在代碼中非常輕鬆地進行這些更改,而無需重寫整個班級並花費10小時調試。
  • 如果有人希望他們的汽車black ,那麼你不應該重新設計整部車來做到這一點。

概要

簡而言之,松耦合使代碼更易於更改。

圖片歸因


來自我的博客帖子關於耦合的摘錄:

什麼是緊耦合 : -

正如上面定義的那樣,緊密耦合對像是需要了解其他對象的對象,通常高度依賴於對方的接口。

當我們通常在一個緊密耦合的應用程序中更改一個對象時,它需要對其他一些對象進行更改。 在小應用程序中,我們可以輕鬆識別變化,這沒有問題。 但是在大型應用程序中,這些相互依賴性並不總是為每個消費者或其他開發人員所知,或者將來有很多變化的機會。

讓我們拿一個購物車演示代碼來了解緊密耦合:

namespace DNSLooseCoupling
{
    public class ShoppingCart
    {
        public float Price;
        public int Quantity;

        public float GetRowItemTotal()
        {
            return Price * Quantity;
        }
    }

    public class ShoppingCartContents
    {
        public ShoppingCart[] items;

        public float GetCartItemsTotal()
        {
            float cartTotal = 0;
            foreach (ShoppingCart item in items)
            {
                cartTotal += item.GetRowItemTotal();
            }
            return cartTotal;
        }
    }

    public class Order
    {
        private ShoppingCartContents cart;
        private float salesTax;

        public Order(ShoppingCartContents cart, float salesTax)
        {
            this.cart = cart;
            this.salesTax = salesTax;
        }

        public float OrderTotal()
        {
            return cart.GetCartItemsTotal() * (2.0f + salesTax);
        }
    }
}

上述例子的問題

緊耦合創造了一些困難。

這裡, OrderTotal()方法為我們提供了當前購物車的完整金額。 如果我們想在此購物車系統中添加折扣功能。 在上面的代碼中很難做到,因為我們必須在每個類上進行更改,因為它非常緊密地耦合在一起。


在面向對象設計中,耦合量指的是一個類的設計依賴於另一個類的設計。 換句話說,A班中的變化多久會推動B班的變化? 緊耦合意味著兩個類經常一起變化,松耦合意味著它們大多是獨立的。 一般來說,建議使用松耦合,因為它更容易測試和維護。

您可能會發現Martin Fowler撰寫的這篇論文(PDF)很有幫助。


有些工具通過它們的庫提供依賴注入,例如在.net中我們有ninject庫

如果你在java中進一步學習, Spring會提供這種功能。

鬆散耦合的對象可以通過在代碼中引入接口來完成,這就是這些源代碼所做的事情。

在你寫的代碼中說

Myclass m = new Myclass();

現在,您的方法中的這個聲明表示您依賴於myclass這稱為緊耦合。 現在你提供了一些構造函數注入,或者屬性注入和實例化對象,然後它將變得鬆散耦合。


松耦合意味著兩個組件之間的依賴程度非常低Ex.GSM SIM緊耦合意味著兩個組件之間的依賴程度非常高。 恩。 CDMA移動


松耦合是舊式硬編碼依賴關係和相關問題的答案,如在任何更改和代碼重用時頻繁重新編譯。 它強調在組件中實現工作者邏輯並避免解決方案特定的代碼。

松耦合= IoC為便於說明,請參閱此處。


當兩個對象鬆散耦合時,它們可以相互作用,但對彼此知之甚少。

松耦合設計使我們能夠構建可處理變化的靈活OO系統。

觀察者設計模式是使類松耦合的一個很好的例子,你可以在en.wikipedia.org/wiki/Observer_pattern上看看它。


緊耦合意味著一個類依賴於另一個類。 松耦合意味著一個類依賴於類比接口。

在緊耦合中,在方法中聲明了硬編碼的依賴關係。 在鬆散耦合中,我們必須在運行時在外部傳遞依賴關係而不是硬編碼(松耦合系統是用於減少與類的依賴關係的使用接口)

例如,我們有一個系統可以通過兩種或多種方式發送輸出,如JSON-Output,CSV-Output等。

緊密耦合

public interface OutputGenerator {
    public void generateOutput();
}

public class CSVOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("CSV Output Generator");
    }
}

public class JSONOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("JSON Output Generator");
    }
}

// In Other Code, we write Output Generator like...
public class Class1 {
    public void generateOutput() {
        // Here Output will be in CSV-Format, because of hard-coded code.
        // This method tightly coupled with CSVOutputGenerator class, if we want another Output, we must change this method.
        // Any method, that calls Class1's generateOutput will return CSVOutput, because Class1 is tight couple with CSVOutputGenerator.
        OutputGenerator outputGenerator = new CSVOutputGenerator();
        output.generateOutput();
    }
}

在上面的例子中,如果我們想要在JSON中更改輸出,那麼我們需要在整個代碼中查找和更改,因為Class1與CSVOutputGenerator類緊密耦合。

鬆散耦合

public interface OutputGenerator {
    public void generateOutput();
}

public class CSVOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("CSV Output Generator");
    }
}

public class JSONOutputGenerator implements OutputGenerator {
    public void generateOutput() {
        System.out.println("JSON Output Generator");
    }
}

// In Other Code, we write Output Generator like...
public class Class1 {
    public void generateOutput(OutputGenerator outputGenerator) {
        // if you want to write JSON, pass object of JSONOutputGenerator (Dependency will be passed externally to this method)
        // if you want to write CSV, pass object of CSVOutputGenerator (Dependency will be passed externally to this method)

        // Due to loose couple with class, we don't need to change code of Class1, because Class1 is loose coupled with CSVOutputGenerator or JSONOutputGenerator class
        // Any method, that calls Class1's generateOutput will desired output, because Class1 does not tight couple with CSVOutputGenerator or JSONOutputGenerator class
        OutputGenerator outputGenerator = outputGenerator;
        output.generateOutput();
    }
}

這是關於類依賴率與其他松耦合如此低而緊密耦合如此之高的另一類依賴率 。 為了在服務導向體系結構中清楚地表明,服務彼此鬆散耦合,以防止單一的相互依賴的類是有目的的







coupling