How is loose coupling achieved using interfaces in Java when an implementation class is mandatory and bound to interface contract?

Question

How is loose coupling associated with interfaces when we are bound to create an implementation class regardless? The implementation class is forced to implement all those methods defined in the interface. I don't understand how this allows for lose coupling? I'm new to object oriented programming and software design so if you could shed some light on this topic it would super helpful. An example would totally be icing on the cake.

Answer 1

The key point is that an interface doesn't just allow you to write one class which implements it, it allows you to write several.

When you have code which interacts with a class by using an interface, that code is able to work together with any class which implements said interface, regardless of how it implements it. That allows you to feed different classes to the same code without having to modify it.

Please note that interfaces are not the only way to reach a loose coupling of components. Loose coupling just means that components are able to work together without assuming anything about the internal workings of each other. You do that because the more your components treat each other as black boxes, the easier it becomes to do changes at one component without affecting any others. Interfaces can be one tool to work towards this goal, but neither are they required, nor are they the only tool which is worth mentioning in this regard.

Answer 2

The implementing class is able to choose HOW to implement the functionality.

public interface PersonRepository {
    Person getPerson(String name);
}

Could be implemented by reading through a CSV file or by querying a database. The object which needs the person does not care how the person is found or loaded just that it is.

Hence it is deemed to be loosely coupled.

If it was tightly coupled it would need to know how to construct a SQL query or read a CSV file.

Answer 3

the client code is coupled to the interface. it is not coupled to the implementation. you can change t he implementation without compiling the client code or the interface.

see http://en.wikipedia.org/wiki/Dependency_inversion_principle and http://en.wikipedia.org/wiki/Open/closed_principle

Answer 4

Might below explanation can answer this :

Into class A we need to have Object of class B. If directly exposure of B into A is there means there is Tight coupling. ex: one can add more methods into B or anything. Which means Behavior of A can be changed based on more exposure of B. But if B class is implementing any Interface and we are passing that ref of Interface into A. means whatever changes in B class further user A class is not bother because we use ref of Interface for accessing B and got only required access. Ex : class A { public void add( B b){ // Implementation } } class B{

    }
            this is Tight coupling. Because user can make any changes to class B which are directly exposed to class A and this defines Tight Coupling(Greater the exposure of depending Object , more Tight Coupling).  To resolve this one refer :
    Interface L{

    }
    class B implements L{}
    class A{
        public void add(L  b){
            // Implementation
        }
    }

        Since we are passing the ref of Interface L, adding changes into Implementation of B will not make any difference to class A.