What does “implementing an interface” exactly mean

问题:

Last days I meet the term "implementing an interface" really often...I have an idea what is it about but I would like more information and some resources about it. When does a class implement an interface?

回答1:

An interface is a contract that specifies a required set of methods that a class MUST create.

For example:

public interface ITest
{
   public void DoSomething(int someInt);
}

public class MyClass : ITest
{
   public void DoSomething(int someInt)
   {
      ... Do some stuff
   }
}

If you did not include the DoSomething method, the compiler would throw an error.

回答2:

What is meant by implementing an interface?

Perhaps it's best if we start with what an interface is, and then work towards what implementing one means.

Example #1:

Every single McDonald's in the world has certain commonalities. In fact, if you want to run a McDonald's franchise, you must follow their franchisee rules:

1. Must sell Big Macs.
2. Restaurants must have a Big M
3. Must pay franchisee fees.
4. Restaurants must be clean (sic!?) at all times.

These are their rules. It's in the contract. Every restaurant is bound to follow that contract. Each restaurant is slightly different, but they are the same when it comes to the above rules.

This is also a very good thing for a customer. If you walk into any McDonald's restaurant in the world, you know for certain that you can purchase a Big Mac.

What does McDonald's have to do with interfaces?

An "interface" is nothing more than a contract. Any restaurant that "implements" or signs the contract, is bound to follow it. Or in other words, any restaurant that implements the McDonald's franchisee interface, is bound to follow it.

Why is it called IMcDonald's interface instead of McDonald's interface?

When ever you name an interface, it is common practice for the name to begin with an "I".

Example #2

All planes in the world have certain commonalities, no matter what type. In other words, they all implement the Iplane interface.

The IPlane interface stipulates that any plane which implements it must have:

1. Two wings
2. an engine
3. and it must fly

Therefore, if a Boeing 737 follows these rules, as a customer, you a guaranteed that your purchase will have wings and will fly. Here is an example of a Boeing 737 implementing the above interface:

 public interface IPlane
{
    void Fly();
    void HasTWoWings();
    void Engine();
}

class Boeing737 : IPlane //  <-------------- the Boeing 737 implements the interface
{
    // this means that the Boeing737 MUST have a fly, hastwowings and an engine method.
    // the interface doesn't specify HOW the plane must fly. So long as it does fly
    // the compiler doesn't care.


    public void Fly()
    {
        Console.WriteLine("Come fly with me, let's fly, let's fly awaaaaaaaay");
    }

    public void HasTWoWings()
    {
        Console.WriteLine("I've got two wings");

    }

    public void Engine()
    {
        Console.WriteLine("BRrrrrrrrooooooooooooooooooooooooooooooooom!");
    }
}

I hope that helps you folks.

So what's the use of this?

This becomes very handy if you're a passenger wanting to book a plane for example. You're not sure what planes will be available for you. And you don't exactly care, so long as they are planes, and so long as they fly, and have two wings and an engine. When you're at the airport, you might get a Boeing, or you might get an airbus, or you might get a Stig - but you know that no matter what actual plane you get, that they will do a certain job. They might fly in different ways, but they all fly.

This allows you to write your code in such a way so as to minimise maintenance costs and to make it significantly easier to modify without causing bugs.

回答3:

An Interface is a specification of functionality that a class MUST implement. When you implement an interface, you are specifying to any consumers of your class that you supply the functionality defined in the given Interface. For example (in C#):

public interface ISearchable
{
    List<object> Search(string query);
}

ISearchable is an interface that specifies a single method which, in theory, should provide some search functionality for a class. Now, any class that wants to implement search functionality can implement the ISearchable interface:

public class ConcreteSearchable : ISearchable
{
    public List<object> Search(string query)
    {
        // Implementation
    }
}

You now have a class that implements your ISearchable interface. This provides several benefits. For one, you've explicitly declared a certain part of the behavior of your class. Second, you are now able to treat your class (and other implementations of the interface) polymorphicaly.

For example, if there were many types implementing the ISearchable interface, you could create a SearchableFactory which would construct a concrete type based on certain parameters. The consumer of the factory wouldn't care about the concrete type...as long as they could search it:

public class SearchableFactory
{
    public static ISearchable CreateInstance(string query)
    {
        if(query.Contains("SELECT"))
            return new SqlSearchable();
        else
            return new ConcreteSearchable();
    }
}

回答4:

An interface is a list of methods that a class needs to implement. It's a way to decouple how a class works from what services the class provides.

You can imagine a Stack data structure. It might have the following in its interface:

push(Node);
Node pop();
Node peek();

Now if you use an array to implement the Stack you'll keep indexes into an array and use that to do the operations. If you have a linked list you'll just keep a pointer to the head. The point of the interface is that a user of your implementation doesn't need to know how your implementation class does the work as long as your implementation provides the required methods.

Some languages like Java and C# provide explicit interfaces. Others, like ruby or python, let you use the same technique but don't enforce it with a keyword. You may hear the term Duck Typing. That's a way to say, if something implements the right interface it can be used, regardless of the implementation.

回答5:

Interfaces adds transparency to your code. An interface defines a contract which is implemented by the class. Let's say that I tell you that you can become part of my gang but you need to wear green shirt all the time. If you say YES then you are implementing a contract and now you must wear a green SHIRT all the TIME.

回答6:

An interface is generally a description of functions, what they require as arguments and what they will return. A description how functions are used and what you can expect to be returned from them.

Implementing an interface means to actually write some code to fulfill the description of the interface, in terms of function names, attributes and return values.