What is coupling in OOP

Loki H

5y1.5kVisual Basic .NET

7 Replies

Know the answer? Post it — somebody with the same question will find it here.

Rajanikant Hawaldar5y ago
Accepted answer
Coupling is the degree to which one class knows about another class. Let us consider two classes class A and class B. If class A knows class B through its interface only i.e it interacts with class B through its API then class A and class B are said to be loosely coupled.

If on the other hand class, A apart from interacting class B by means of its interface also interacts through the non-interface stuff of class B then they are said to be tightly coupled. Suppose the developer changes the class B ‘s non-interface part i.e non-API stuff then in case of loose coupling class A does not breakdown but tight coupling causes the class A to break.

So, its always a good OO design principle to use loose coupling between the classes i.e all interactions between the objects in OO system should use the APIs. An aspect of good class and API design is that classes should be well encapsulated.
Brahma Prakash Shukla3y ago
https://www.geeksforgeeks.org/coupling-in-java/#:~:text=In%20object%20oriented%20design%2C%20Coupling,two%20classes%20often%20change%20together.
Naresh Beniwal3y ago
https://www.geeksforgeeks.org/coupling-in-java/#:~:text=In%20object%20oriented%20design%2C%20Coupling,two%20classes%20often%20change%20together.
Mukesh Nailwal4y ago
Hello Loki H,

Coupling is the principle of separation of concerns. This means that one object doesn't directly change or modify the state or behavior of another object.

The best example of coupling is HTML and CSS. Before CSS, HTML was used for both markup and presentation. This created bloated code that was hard to change and difficult to maintain. With the advent of CSS, HTML became used just for markup, and CSS took over for presentation. This made the code fairly clean and easily changeable. The concerns of presentation and markup were separated.
satheesh d4y ago
Coupling is a degree of dependency of one class on another class.And there are two types of coupling are available(Loose Coupling and Tight Coupling).

In the tight coupling, one class is heavily coupled on another class. Two classes are often change together. That means, If you make changes in one class, then changes are also made on another class which coupled to it.In Loose coupling ther is less dependency between the classes.

public class Bus
{
public void start()
{
Console.WriteLine("Bus----");
}
}
public class Car
{
public void start()
{
Console.WriteLine("Car----");
}
}
public class Travel
{
public void start()
{
Bus bus = new Bus();
bus.start();
}
}
public class traveller
{
public static void main(String[] args)
{
Travel travel = new Travel();
travel.start();
}
}

In this Example, the traveller class is tightle coupled with travel class. If I need to change my travel mode then I need to change in my travel class. Also the bus and car class is also tightly coupled with travel class. If I changed my method in bus class then I also need to change in my travel class.

public Interface Transport
{
void start();
}
public class Bus:Transport
{
public override void start()
{
Console.WriteLine("---bus");
}
}
public class car:Transport
{
public override void start()
{
Console.WriteLine("---car");
}
}
public interface ITravel
{
void start();
}
public class travel
{
private Transport transport;

public override void start()
{
Console.WriteLine("---car");
}
}
public class traveller
{
public static void main(String[] args)
{
Transport transport1 = new Bus();
ITravel travel = new Travel(transport1);
}
}

This is the example for the loosely coupled class. Here the dependency is less between the classes and testing will be easy in these types of applications.
Sachin Singh5y ago
See,
Architecture is said to be good when changing in one place doesn't affect other places and a developer is called smart when he writes code keeping this statement in mind.

Now, come to the point,
suppose you have a class called Employee and there is a huge chance that we are not God so exception may occur at any moment of time so we do an exception handling using try-catch block and log the error either to the Database or File or Event viewer etc.
public class SomeClass
{
public void Method()
{
try{
// to do
}
catch(Exception ex)
{
  ExceptionHandler obj= new ExceptionHandler();
  obj.HandleError(ex.ToString());
}
}
}
public class ExceptionHandler
{
  public void HandleError(string ExceptionMessage)
{

  System.File.IO.WriteAllLines(@"D:/error.txt",ExceptionMessage);
}

}
Now, how the above code is bad??
It is completely bad because the SomeClass is creating an object of ExceptionHandler class, so if you change the code of the HandleError method of ExceptionHadler class then you will need to recompile the SomeClass class.
This is called Tight Coupling, it is like Mr. Michael has a fever then go check Mr. Smith, why to check MR. Smith when the problem is just with Michael?

This is the reason we create Interface and never create the object of Concrete class inside another class, we use Dependency Injection to inject the dependency (injecting object of dependent class) which is called as Loose coupling.
public class SomeClass
{
IExceptionHandler   _handler;
public SomeClass (IExceptionHandler   handler) // Dependency Injection
{
_handler=handler;
}

public void Method()
{
try{
// to do
}
catch(Exception ex)
{

  obj.HandleError(ex.ToString());
}
}
}

public Interface IExceptionHandler
{
void HandleError(string ExceptionMessage)  ;

}
public class ExceptionHandler:IExceptionHandler
{
  public void HandleError(string ExceptionMessage)
{

  System.File.IO.WriteAllLines(@"D:/error.txt",ExceptionMessage);
}

}
public class ExceptionHandler: IExceptionHandler
{
  public void HandleError(string ExceptionMessage)
{

  // Log to Database
}

}
now, the DI Container will inject concrete objects at runtime, in this way we invert the control to the third person, this is termed as the Dependency inversion principle.
Farhan Ahmed5y ago
Coupling in C# describes the relationship between modules in C#, how the classes and objects are connected, and also how dependent they are on each other. This also describes the flexibility and reusability part of the code. There are two types of coupling

Tightly coupled: Think of it this way - your fingers are tightly coupled with the hand, which makes it hard to change the position of the fingers and their location. This means that changing the position of fingers is close to impossible and requires redesigning of the hand. This is an example of being tightly coupled.

Loosely coupled: Loosely coupled can be explained with the help of the head as an example. Take any type of hat, you will be able to fit it on your head. For example, a cowboy hat can fit on top of it, so can a chef's hat. Here, the head and the cap are loosely coupled as both are not interdependent. This makes it much less complex and ensures code reusability.