难以理解通过接口的松耦合

Question

In "Head First Servlets and Jsp" book by Kathy sierra at page 744

it is mentioned that, "A very common approach when class A wants to use methods in class B is to create an interface between the two. Once class B implements this interface, class A can use class B via the interface."

My question is how class A can use class B because they might have same method signatures by implementing the same interface but the implementation of those methods would be different? Can someone please explain this?

Answer 1

I think there is a slight misunderstanding: A and B would not both implement the interface, let's call it C. Only B would implement C. The trick is that now A can eliminate all direct references to B and just use C, provided there's a way A can somehow get hold of an object implementing C, eg via a factory. This way you could replace B with a totally different implementation of C without breaking the code in A.

Answer 2

An interface is a group of related methods with empty bodies.

It is more like a contract. When you have a Television Set, the Buttons act as an interface to switch it on and switch it off. That is a contract between you and the television that you would be using those interfaces to get the maximum benefit of the Television.

For example a bicycle's behavior, if specified as an interface, might appear as follows:

interface Bicycle {

    //  wheel revolutions per minute
    void changeCadence(int newValue);

    void changeGear(int newValue);

    void speedUp(int increment);

    void applyBrakes(int decrement);
}

To implement this interface, the name of your class would change (to a particular brand of bicycle, for example, such as ACMEBicycle), and you'd use the implements keyword in the class declaration:

class ACMEBicycle implements Bicycle {

    // remainder of this class 
    // implemented as before
}

Hope this helps.

Answer 3

Loose coupling indicates a dependency, but not an explicit reference. Interface is a mechanism to enable loose coupling by providing member declarations independently of a) implementation and b) inheritance tree.

Take ClassA for example. ClassA implements interface IService . MyMethod(ClassA input) has a dependency on ClassA .

MyMethod(IService input) is dependent on IService but not on ClassA . MyMethod(IService) will compile without ClassA - it is loosely coupled.

In conclusion. Loose coupling allows two components to participate in a mechanism but it does not make an explicit reference between them.

Answer 4

Some sample code (C# but should be understandable if you know Java):

// this interface defines what A should be able to do with B
interface SomeInterface
{
    int GetSomeValue();
}


// B needs to implement this interface
class B : SomeInterface
{
    int GetSomeValue()
    {
        return 42;
    }

    void SomeOtherMethod()
    {

    }
}

// A has access to B via the interface. Pass it in the constructor and save it for later use
class A
{
    A(SomeInterface si)
    {
        this.si = si;
    }
    SomeInterface si;

    // or pass it per call
    void SomeMethodInA(SomeInterface passedIF)
    {
        int c = passedIF.GetSomeValue();
    }

    // may even have the same name but doesn't have to!
    int GetSomeValue()
    {
        // access "B" (or some other class implementing this interface) via the interface
        return si.GetSomeValue() + 1;
    }


    // The interface can of course be also a property of A.
    // but this is left as an exercise to the reader

}


int main()
{
    B b = new B();
    A a = new A(b);
    a.GetSomeValue();
    a.SomeMethodInA(b);
}