Can explain coupling
Coupling is a measure of the degree of dependence between components, classes, methods, etc. Low coupling indicates that a component is less dependent on other components. High coupling (aka tight coupling or strong coupling) is discouraged due to the following disadvantages:
- Maintenance is harder because a change in one module could cause changes in other modules coupled to it (i.e. a ripple effect).
- Integration is harder because multiple components coupled with each other have to be integrated at the same time.
- Testing and reuse of the module is harder due to its dependence on other modules.
In the example below, design
A appears to have more coupling between the components than design
Can reduce coupling
X is coupled to Y if a change to Y can potentially require a change in X.
Foo class calls the method
Foo is coupled to
Bar because a change to
Bar can potentially (but not always) require a change in the
Foo class e.g. if the signature of
Bar#read() is changed,
Foo needs to change as well, but a change to the
Bar#write() method may not require a change in the
Foo class because
Foo does not call
code for the above example
Some examples of coupling:
A is coupled to
Ahas access to the internal structure of
B(this results in a very high level of coupling)
Bdepend on the same global variable
Areceives an object of
Bas a parameter or a return value
Bare required to follow the same data format or communication protocol
Can identify types of coupling
Some examples of different coupling types:
- Content coupling: one module modifies or relies on the internal workings of another module e.g., accessing local data of another module
- Common/Global coupling: two modules share the same global data
- Control coupling: one module controlling the flow of another, by passing it information on what to do e.g., passing a flag
- Data coupling: one module sharing data with another module e.g. via passing parameters
- External coupling: two modules share an externally imposed convention e.g., data formats, communication protocols, device interfaces.
- Subclass coupling: a class inherits from another class. Note that a child class is coupled to the parent class but not the other way around.
- Temporal coupling: two actions are bundled together just because they happen to occur at the same time e.g. extracting a contiguous block of code as a method although the code block contains statements unrelated to each other