Tight vs Loose Coupling

Tight vs Loose Coupling

In object oriented design, the amount of coupling refers to how much the design of one class depends on the design of another class. In other words, how often do changes in class A force related changes in class B? Tight coupling means the two classes often change together, loose coupling means they are mostly independent. In general, loose coupling is recommended because it's easier to test and maintain.

Tight coupling

Think of your skin. It's stuck to your body. It fits like a glove. But what if you wanted to change your skin colour from say white to black? Can you imagine just how painful it would be to peel off your skin, dye it, and then to paste it back on etc? Changing your skin is difficult because it is tightly coupled to your body. You just can't make changes easily. You would have to fundamentally redesign a human being in order to make this possible. Key Point #1 In other words, if you want to change the skin, you would also HAVE TO change the design of your body as well because the two are joined together - they are tightly coupled. God was not a good object oriented programmer.

Loose coupling

Now think of getting dressed in the morning. You don't like blue? No problems: you can put a red shirt on instead. You can do this easily and effortlessly because the shirt is not really connected to your body the same way as your skin. The shirt doesn't know or care about what body it is going on. In other words, you can change your clothes, without really changing your body. That's key point
#2.If you change your shirt, then you are not forced to change your body - when you can do that, then you have loose coupling. When you can't do that, then you have tight coupling.
That's the basic concept in a nutshell.

Why is all of this important?

It's important because software changes all the time. Generally speaking you want to be able to easily modify your code. If somebody wants their car in black, you shouldn't have to reconfigure the engine in order to make that change. That's why you want things loosely coupled. Because then it's easy to change.

Hope this helps.
Tight coupling is when a group of classes are highly dependent on one another.

This scenario arises when a class assumes too many responsibilities, or when one concern is spread over many classes rather than having its own class.

Loose coupling is achieved by means of a design that promotes single-responsibility and separation of concerns.

A loosely-coupled class can be consumed and tested independently of other (concrete) classes.

Interfaces are a powerful tool to use for decoupling. Classes can communicate through interfaces rather than other concrete classes, and any class can be on the other end of that communication simply by implementing the interface.

Example of tight coupling:

class CustomerRepository
{
    private readonly Database database;

    public CustomerRepository(Database database)
    {
        this.database = database;
    }

    public void Add(string CustomerName)
    {
        database.AddRow("Customer", CustomerName);
    }
}

class Database
{
    public void AddRow(string Table, string Value)
    {
    }
}

Example of loose coupling:

class CustomerRepository
{
    private readonly IDatabase database;

    public CustomerRepository(IDatabase database)
    {
        this.database = database;
    }

    public void Add(string CustomerName)
    {
        database.AddRow("Customer", CustomerName);
    }
}

interface IDatabase
{
    void AddRow(string Table, string Value);
}

class Database : IDatabase
{
    public void AddRow(string Table, string Value)
    {
    }
}


If you still have any question you can reach me any time through email (jigyasu2010@hotmail.com)

Comments

Post a Comment

Popular posts from this blog

How Method Overloading Helping in Java - Part 9

I'm sharing my experience with you as these are the questions which have been asked to me while interviewing on java profile. Where have u observed method overloading helped us in java? Where have you seen in java default classes using method overloading? We need method overloading because if we have multiple arguments for add method and we have to create multiple methods in that case we will be confused which method to call to perform specific addition. Example: class   PrintOverloading1 {      public   void  show( char  c)     {           System . out .println(c);     }      public   void  show( char  c,  int  number)      {           System . out .println(c +  " " + number);     }    public   void  show( char  c,  String s )      {           System . out .println(c +  " " + s);     } } class   demo1 {     public   static   void  main( String  args[])    {         PrintOverloading1 obj  =  new   PrintOv
Read more

Design Patterns -- part 1

Design patterns are the best practices used by Developers while working on project. These give design level solutions for recurring problems that software engineers come across often. This helps developers to tackle these problems and design a solution well using patterns. These patterns help other developers so that they do not need to waste time in those problems which were faced by those developers.  What is   Gang Of Four (GOF)? There is a band called Gang Of Four (band) but here we will not be talking about band. We will talk about the authors of Gang of Four design patterns. In 1994, four authors Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides published a book titled Design Patterns - Elements of Reusable Object-Oriented Software Source:  Wikipedia Patterns are formalized  best practices  that the programmer can use to solve common problems when designing an application or system. Object-oriented  design patterns typically show relationships and  interactions
Read more

Access Modifiers in java

Access Modifiers in Java Access to classes is controlled using Access Modifiers aka ( Access Specifiers, Visibility Specifiers ) in java. These are used to regulate access to classes, fields and methods in java. Using access modifiers you can control the access of variables, methods with in a class. Java provides number of access modifiers to control the access for class as well as the fields, methods and constructors in your classes. We have 4 types of access modifiers in java which are explained below:- Default: Visible to the package, the default. No modifiers are needed, no keyword is required. Private: Visible to the class only. Public: Visible to the world. Protected: Visible to the package and all subclasses. Default: We do not have any default specifier in Java. It provides Default specifier which is used where no access modifier is present. Using this you can access class, methods or fields which belongs to same package, but not from outside
Read more