i've been doing some research on interfaces and a simple layman's explanation for what it truly is. when searching through seas of books For some reason people love using overly plex explanations and jargon to explain truly simple concepts (guess it makes them feel big) and i have a gut feeling it's the same in this case.

so from what i could grasp, it seems like interfaces are nothing more than a way to reserve method names, their return type if any, and the type and amount of arguments they accept. so when a class implements an interface (or interfaces) it is forced to define the body of each method from the interface(s). Am i on the nose with this one or do i need to keep digging?

p.s. i know javascript doesn't have support for interfaces, but i still need to understand the concept because there are quite a few places where it's shown how to emulate to an extent.

i've been doing some research on interfaces and a simple layman's explanation for what it truly is. when searching through seas of books For some reason people love using overly plex explanations and jargon to explain truly simple concepts (guess it makes them feel big) and i have a gut feeling it's the same in this case.

so from what i could grasp, it seems like interfaces are nothing more than a way to reserve method names, their return type if any, and the type and amount of arguments they accept. so when a class implements an interface (or interfaces) it is forced to define the body of each method from the interface(s). Am i on the nose with this one or do i need to keep digging?

p.s. i know javascript doesn't have support for interfaces, but i still need to understand the concept because there are quite a few places where it's shown how to emulate to an extent.

• c#
• java
• javascript
• c++
• interface

• 2 Probably the most important aspect of interfaces is that the programmer can code in terms of interfaces. For example, a programmer can code her Q&A website, StackUnderflow, to parse user submitted content with a Parser interface without having to care if it's a MarkdownParser, LatexParser, AsciidocParser, etc. If she changes her mind about what format the content should be in, she can just switch out a single line of code. As long as the class she chooses implements the Parser interface, everything will work fine. – Joseph Mansfield Commented Mar 21, 2012 at 17:35
• 1 Aside ("makes them feel big"): whenever I fail to explain something because the explanation is overly plex, I feel smaller, not bigger. – phoog Commented Mar 21, 2012 at 21:09

9 Answers 9

For some reason people love using overly plex explanations and jargon to explain truly simple concepts (guess it makes them feel big)

Consider eschewing the editorial ments that impute bad motives to people who are trying to help you. That's a really bad way to try to get people to help you.

It seems like interfaces are nothing more than a way to reserve method names, their return type if any, and the type and number of arguments they require. So when a class implements an interface (or interfaces) it is forced to define the body of each method from the interface(s). Am i on the nose with this one or do i need to keep digging?

You are on the right track but you err in the details. In C#, for example, an implementing class is not required to provide a body. The method which corresponds to the interface method could, for example, be an abstract method in an abstract class, which would then not have a body. And in C# an interface can require members other than methods; properties, events and indexers, for example.

A more concise and typical way to express the idea that interfaces impose a requirement that a type supply members that match certain signatures is to say that the interface represents a contract that must be fulfilled by its implementer. But that might be too plex and jargonish for your gut to stomach.

I explain the concept to lay people using an analogy that most people understand - plastic molding.

The interface defines the shape of an object in the exact same way a mold will provide the shape of the finished product.

You could inject a mold with White plastic, blue plastic, something exotic like an Epoxy or clay.

What matters is, no matter what they are actually made of, they all have the same exact consistent shape to the purchaser of the product.

For code, this means no matter what code is used to implement the interface, they all follow the same consistent contract/shape to the end user.

I hope that might help a little.

Edit -

To extend the analogy to Abstract classes, imagine the next step in the molding process. You run a White, blue, and red plastic production run, but then each item needs to be painted at a separate factory, we just ship them out.

The item is not finished, but it does have its shape defined. Someone later will e and fill out the details that our factory left blank.

These items cannot be sold until they get that last painting step.

In code, the abstract implementation of the interface provides some (or none) of the implementation, but leaves another descendant class to plete the contract, and in the same way no one can create an instance of the class until the contract has been pleted.

In the same way though, you can still refer to an abstract class in code, just like you can refer to the unpainted mold item as a "White molded thing" wither or not it is painted!

Edit 2

Here's a short example

void Main()
{
    //IMold mold = new IMold(); // error - can't create instance of an interface
    //Fruit fruit = new Fruit(); // error - can't create instance of an abstract class

    Apple apple1 = new Apple(); // good
    Orange orange1 = new Orange(); // good

    Fruit apple2 = (Fruit)apple1; // good - Apples are fruit
    Fruit orange2 = (Fruit)orange1; // good - oranges are fruit

    IFruitMold apple3 = (IFruitMold)apple2; // good - Apples fit the Mold
    IFruitMold orange3 = (IFruitMold)orange2; // good - Oranges also fit the mold


    //now I can do this:
    //Notice that `fruits` is of type IList<T> but the new is List<T>
    //This is the exact concept we are talking about
    //IList<T> is some kind of set of items that can be added or subtracted from
    //but we don't have to care about the implementation details of *HOW* this is done
    IList<IFruitMold> fruits = new List<IFruitMold>();
    fruits.add(apple3);
    fruits.add(orange3);

    foreach( var fruit in fruits )
    {
        fruit.PlasticColor.Dump(); // ok I can read
        fruit.PlasticColor = ""; // error - no Set defined in the interface

        // depending on the **implementation details** of what type of fruit this is true or false
        // we don't care in the slightest, we just care that we have some IFruitMold instances
        fruit.RequiresPainting.Dump(); 
    }
}

interface IFruitMold
{
    string PlasticColor { get; }
    bool RequiresPainting { get; }
}

abstract class Fruit : IFruitMold
{
    private string m_PlasticColor = string.Empty;
    public string PlasticColor { get; private set; }
    public abstract bool RequiresPainting { get; }
}

//notice that we only define the abstract portion of the base class
//it defined PlasticColor for us already!
//the keyword `override` is required  - it is to make it clear that 
//this member is overriding a member from it's parent.
class Apple : Fruit
{
    public override bool RequiresPainting { get { return true; } }
}

class Orange : Fruit
{
    public override bool RequiresPainting { get { return false; } }
}

Yes, in a nutshell interfaces are there to declare and promise everyone else that a class will have certain methods.

This is good when you create generalized methods and function, where you want a more abstract design. All you want to know is that your function can receive an object that had methods A B and C.

Interface is just a simple empty class, that show the contract on how you real class should look. I think you have the concept ok.

They don't reserve anything (I don't understand what you mean by that), is just a way so when you build your class around the interface, you have a prior knowledge of how will your class look like. And also you can know before which methods will it have.

when a class implements an interface (or interfaces) it is forced to define the body of each method from the interface(s).

Yes. Interfaces are contracts. They let others know that your class implements certain functionality.

I would say its more than reserving the method name it is a way of making a contract that the method will exist and the caller will not need to know what it does but it will still be available to be called

A good example would be a pen and pencil both can implement an Iwriter interface with a write method but whoever calls the write method doesn't need to know that one uses ink and one uses lead the caller will just know that it is going to write words on the paper.

Interfaces provide a uniform way of interaction with a set of objects.

No matter what the object is, if it implements the interface we know that it will respond to a method defined in the interface. In this way, we can create objects that represent different things in a project and still interact with them in the same way. The actual implementation of the methods defined in the interface can be pletely different, but they will take the same inputs and provide the same type of output.

Basically an interface is a contract which can define properties (getters and setters) or methods (with whatever parameters you require). If an object 'implements' the interface it needs to define a concrete implementation for ALL the properties and methods defined in the interface.

For unit testing or Inversion of Control containers interfaces really e into there own as you can call methods/properties on the interface without knowing anything about the object which actually implements it.

Interface is used to provide mon functionality among a set of pletely unrelated objects.

Lets say we have a bunch of animal objects and we need to separate pets from that bunch. The task of separation bees really simple if we enforce a contract such that all the animals which are pets needs to implement IPet interface.