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

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.