What is the value of Interfaces?

Question

Sorry to ask sich a generic question, but I've been studying these and, outside of say the head programming conveying what member MUST be in a class, I just don't see any benefits.

Answer 1

Maybe this resource is helpful: When to Use Interfaces

Answer 2

There are two (basic) parts to object oriented programming that give newcomers trouble; the first is inheritance and the second is composition. These are the toughest to 'get'; and once you understand those everything else is just that much easier.

What you're referring to is composition - e.g., what does a class do? If you go the inheritance route, it derives from an abstract class (say Dog IS A Animal) . If you use composition, then you are instituting a contract (A Car HAS A Driver/Loan/Insurance). Anyone that implements your interface must implement the methods of that interface.

This allows for loose coupling; and doesn't tie you down into the inheritance model where it doesn't fit.

Where inheritance fits, use it; but if the relationship between two classes is contractual in nature, or HAS-A vs. IS-A, then use an interface to model that part.

Why Use Interfaces?

For a practical example, let's jump into a business application. If you have a repository; you'll want to make the layer above your repository those of interfaces. That way if you have to change anything in the way the respository works, you won't affect anything since they all obey the same contracts.

Here's our repository:

public interface IUserRepository 
{
    public void Save();
    public void Delete(int id);
    public bool Create(User user);
    public User GetUserById(int id);
}

Now, I can implement that Repository in a class:

public class UserRepository : IRepository
{
    public void Save()
    {
         //Implement
    }

    public void Delete(int id)
    {
         //Implement
    }

    public bool Create(User user)
    {
         //Implement
    }
    public User GetUserById(int id)
    {
         //Implement
    }

}

This separates the Interface from what is calling it. I could change this Class from Linq-To-SQL to inline SQL or Stored procedures, and as long as I implemented the IUserRepository interface, no one would be the wiser; and best of all, there are no classes that derive from my class that could potentially be pissed about my change.

Inheritance and Composition: Best Friends

Inheritance and Composition are meant to tackle different problems. Use each where it fits, and there are entire subsets of problems where you use both.

Answer 3

It allows you to separate the implementation from the definition.

For instance I can define one interface that one section of my code is coded against - as far as it is concerned it is calling members on the interface. Then I can swap implementations in and out as I wish - if I want to create a fake version of the database access component then I can.

Interfaces are the basic building blocks of software components

Answer 4

Speaking from a Java standpoint, you can create an interface, telling any classes that implement said interface, that "you MUST implement these methods" but you don't introduce another class into the hierarchy.

This is desireable because you may want to guarantee that certain mechanisms exist when you want objects of different bases to have the same code semantics (ie same methods that are coded as appropriate in each class) for some purpose, but you don't want to create an abstract class, which would limit you in that now you can't inherit another class.

just a thought... i only tinker with Java. I'm no expert.

Please see my thoughts below. 2 different devices need to receive messages from our computer. one resides across the internet and uses http as a transport protocol. the other sits 10 feet away, connect via USB.

Note, this syntax is pseudo-code.

    interface writeable
    {
       void open();
       void write();
       void close();
    }

    class A : HTTP_CONNECTION implements writeable
    {
        //here, opening means opening an HTTP connection.
        //maybe writing means to assemble our message for a specific protocol on top of 
        //HTTP
        //maybe closing means to terminate the connection
    }

    class B : USB_DEVICE implements writeable
    {
        //open means open a serial connection
        //write means write the same message as above, for a different protocol and device
        //close means to release USB object gracefully.
    }

Answer 5

In Java, interfaces allow you to refer any class that implements the interface. This is similar to subclassing however there are times when you want to refer to classes from completely different hierarchies as if they are the same type.

Answer 6

So that a given class can inherit from multiple sources, while still only inheriting from a single parent class.

Some programming languages (C++ is the classic example) allow a class to inherit from multiple classes; in this case, interfaces aren't needed (and, generally speaking, don't exist.)

However, when you end up in a language like Java or C# where multiple-inheritance isn't allowed, you need a different mechanism to allow a class to inherit from multiple sources - that is, to represent more than one "is-a" relationships. Enter Interfaces.

So, it lets you define, quite literally, interfaces - a class implementing a given interface will implement a given set of methods, without having to specify anything about how those methods are actually written.

Answer 7

Interfaces create a layer insulation between a consumer and a supplier. This layer of insulation can be used for different things. But overall, if used correctly they reduce the dependency density (and the resulting complexity) in the application.

Answer 8

I wish to support Electron's answer as the most valid answer.

Object oriented programming facilitates the declaration of contracts. A class declaration is the contract. The contract is a commitment from the class to provide features according to types/signatures that have been declared by the class. In the common oo languages, each class has a public and a protected contract.

Obviously, we all know that an interface is an empty unfulfilled class template that can be allowed to masquerade as a class. But why have empty unfulfilled class contracts?

An implemented class has all of its contracts spontaneously fulfilled.

An abstract class is a partially fulfilled contract.

A class spontaneously projects a personality thro its implemented features saying it is qualified for a certain job description. However, it also could project more than one personality to qualify itself for more than one job description.

But why should a class Motorcar not present its complete personality honestly rather than hide behind the curtains of multiple-personalities? That is because, a class Bicycle, Boat or Skateboard that wishes to present itself as much as a mode of Transport does not wish to implement all the complexities and constraints of a Motorcar. A boat needs to be capable of water travel which a Motorcar needs not. Then why not give a Motorcar all the features of a Boat too - of course, the response to such a proposal would be - are you kiddin?

Sometimes, we just wish to declare an unfulfilled contract without bothering with the implementation. A totally unfulfilled abstract class is simply an interface. Perhaps, an interface is akin to the blank legal forms you could buy from a stationary shop.

Therefore, in an environment that allows multiple inheritances, interfaces/totally-abstract-classes are useful when we just wish to declare unfulfilled contracts that someone else could fulfill.

In an environment that disallows multiple inheritances, having interfaces is the only way to allow an implementing class to project multiple personalities.

Consider

interface Transportation
{
  takePassengers();
  gotoDestination(Destination d);
}

class Motorcar implements Transportation
{
  cleanWindshiedl();
  getOilChange();
  doMillionsOtherThings();
  ...
  takePassengers();
  gotoDestination(Destination d);
}

class Kayak implements Transportation
{
  paddle();
  getCarriedAcrossRapids();
  ...
  takePassengers();
  gotoDestination(Destination d);
}

An activity requiring Transportation has to be blind to the millions alternatives of transportation. Because it just wants to call

Transportation.takePassengers or
Transportation.gotoDestination

because it is requesting for transportation however it is fulfilled. This is modular thinking and programming, because we don't want to restrict ourselves to a Motorcar or Kayak for transportation. If we restricted to all the transportation we know, we would need to spend a lot of time finding out all the current transportation technologies and see if it fits into our plan of activities.

We also do not know that in the future, a new mode of transport called AntiGravityCar would be developed. And after spending so much time unnecessarily accommodating every mode of transport we possibly know, we find that our routine does not allow us to use AntiGravityCar. But with a specific contract that is blind any technology other than that it requires, not only do we not waste time considering all sorts of behaviours of various transports, but any future transport development that implements the Transport interface can simply include itself into the activity without further ado.

Answer 9

I was going to leave George to point out that you can now consume the interface rather than the concrete class. It seems like everyone here understands what interfaces are and how to define them, but most have failed to explain the key point of them in a way a student will easily grasp - and something that most courses fail to point out instead leaving you to either grasp at straws or figure it out for yourself so I'll attempt to spell it out in a way that doesn't require either. So hopefully you won't be left thinking "so what, it still seems like a waste of time/effort/code."

public interface ICar
{
    public bool EngineIsRunning{ get; }
    public void StartEngine();
    public void StopEngine();
    public int NumberOfWheels{ get; }
    public void Drive(string direction);
}

public class SportsCar : ICar
{
    public SportsCar
    {
        Console.WriteLine("New sports car ready for action!");
    }

    public bool EngineIsRunning{ get; protected set; }

    public void StartEngine()
    {
        if(!EngineIsRunning)
        {
            EngineIsRunning = true;
            Console.WriteLine("Engine is started.");
        }
        else
            Console.WriteLine("Engine is already running.");
    }

    public void StopEngine()
    {
        if(EngineIsRunning)
        {
            EngineIsRunning = false;
            Console.WriteLine("Engine is stopped.");
        }
        else
            Console.WriteLine("Engine is already stopped.");
    }

    public int NumberOfWheels
    {
        get
        {
            return 4;
        }
    }

    public void Drive(string direction)
    {
        if (EngineIsRunning)
            Console.WriteLine("Driving {0}", direction);
        else
            Console.WriteLine("You can only drive when the engine is running.");
    }
}

public class CarFactory
{
    public ICar BuildCar(string car)
    {
        switch case(car)
            case "SportsCar" : 
                return Activator.CreateInstance("SportsCar");
            default :
                /* Return some other concrete class that implements ICar */
    }
}

public class Program
{
    /* Your car type would be defined in your app.config or some other
     * mechanism that is application agnostic - perhaps by implicit
     * reference of an existing DLL or something else.  My point is that
     * while I've hard coded the CarType as "SportsCar" in this example,
     * in a real world application, the CarType would not be known at 
     * design time - only at runtime. */
    string CarType = "SportsCar";

    /* Now we tell the CarFactory to build us a car of whatever type we
     * found from our outside configuration */
    ICar car = CarFactory.BuildCar(CarType);

    /* And without knowing what type of car it was, we work to the 
     * interface.  The CarFactory could have returned any type of car,
     * our application doesn't care.  We know that any class returned 
     * from the CarFactory has the StartEngine(), StopEngine() and Drive()
     * methods as well as the NumberOfWheels and EngineIsRunning 
     * properties. */
    if (car != null)
    {
        car.StartEngine();
        Console.WriteLine("Engine is running: {0}", car.EngineIsRunning);
        if (car.EngineIsRunning)
        {
            car.Drive("Forward");
            car.StopEngine();
        }
    }
}

As you can see, we could define any type of car, and as long as that car implements the interface ICar, it will have the predefined properties and methods that we can call from our main application. We don't need to know what type of car is - or even the type of class that was returned from the CarFactory.BuildCar() method. It could return an instance of type "DragRacer" for all we care, all we need to know is that DragRacer implements ICar and we can carry on life as normal.

In a real world application, imagine instead IDataStore where our concrete data store classes provide access to a data store on disk, or on the network, some database, thumb drive, we don't care what - all we would care is that the concrete class that is returned from our class factory implements the interface IDataStore and we can call the methods and properties without needing to know about the underlying architecture of the class.

Another real world implication (for .NET at least) is that if the person who coded the sports car class makes changes to the library that contains the sports car implementation and recompiles, and you've made a hard reference to their library you will need to recompile - whereas if you've coded your application against ICar, you can just replace the DLL with their new version and you can carry on as normal.