Interfaces... What's the deal?

adam_gartee

This is a newbie question. I do not understand the whole idea of the interface thing. It is my understanding that an interface is basically just an abstract class with abstract methods that all have to be implemented in the class that implements them. So, if you have to implement all of these properties and methods on the class implementing the interface anyway, what is the point of having an interface, other that the fact that the new properties and methods will show up in your auto-complete in Visual Studios. If this is all an interface is, how does that replace multiple inheritance? Any insight would be appreciated. -agartee

7 Replies

Know the answer? Post it — somebody with the same question will find it here.

Mykonine22y ago
jshepler said it pretty well. Condensed into one sentence: Inheritance defines characteristics and traits, whereas interfaces define functionality.
adam_gartee22y ago
Thanks, jshelper. I think I get it now.
jshepler22y ago
Sorry, small typo: but the developers that will use your class library will have no easy way to determine if any particular CLASS of animal CAN speak should be but the developers that will use your class library will have no easy way to determine if any particular INSTANCE of animal CAN speak.
jshepler22y ago
Interfaces do not replace multiple inheritance. It may appear that way, but it doesn't. Apples to oranges. Interfaces are mostly used when you are designing a class library to be used by someone else. Interfaces define behaviors that can be expected by a class that implements it. Take for example the interface IEnumerable. Any class that implements this interface is expected to work as a datasource for any list control (listbox, datalist, etc.). So you, as a programmer, know that if you use an ArrayList, you can bind it to a DataList control. Granted, the code that actually implements IEnumerable is part of the ArrayList class, but you would not easily know that if not for the interface definition. In addition, you can cast an instance to an interface. Which also means that you can use polymorphism to work with that aspect (the interface) of an instance without knowing the class of the object. For example: ... ArrayList items = new ArrayList(); // some code that populates the list foobar(items); ... void foobar(IEnumerable list) { // code that works with the list as an IEnumerable object } foobar() doesn't care what class of object is passed to it - you can pass it an Array object, an ArrayList object, a Cache object, ControlCollection object, etc. Any object that implements IEnumerable can be passed to foobar(). A hypothetical example: You have been givin the project of writing a class library to deal with animal behaviors. One of the behaviors is Speak(). Each animal that can actually speak will implement that method in a different way (dogs bark, lions roar, etc). Granted, you can just define the method for each class that can speak and not include it for any that don't, but the developers that will use your class library will have no easy way to determine if any particular class of animal CAN speak. If you create an interface that defines the Speak() behavior, not only will your developers be able to determine if a class can speak, they can expect all classes that implement the ISpeakable interface to implement the Speak() method specifically.
bilnaad22y ago
Yes interfaces are designed to replace (some of) multiple inheritance. But they are in fact important. And more important when you want you class to inherit multiply behavior. You can see an interface as a contract between interface and class. The interface provides the methods ,indexers and properties. The class implements them. This is very usefull when each class that implements an interface has a somewhat different behavior. interface IVehicle { void Start(); void Stop(); void Move(); } Let's say you an interface called IVehicle. And you have several classes that inherit from IVehicle. As we all know , not all vehicles have the same behavior. We could even say that not all vehicles have the same onboard equipment (which could be another interface). interfaces have no behavior at all. So it's all up to the class how to behave. abstract classes do have a behavior which is inherited by the sub-classes. This could be solved with some virtual methods. But this could not be solved if the sub-class needs more behavior then just the behavior from the abstract class. Also when you have a car with a radio. You could implement some radio functionality in a abstract class. But what if a future radio has a new feature? Write a new abstract class? If you adjust the abstarct class all sub-classes inherit the altered radio. Wich is not "REAL". Very old cars are not build in factories with future radios. that's not possible. But if you created a new interface which defines the new features of the new radio. You can inherit from that interface in the new car classes. And this doesn't effect any old cars. only the new ones. Think about it and you think a lot it all makes sense. I hope I explained it right this time. Good luck :)
adam_gartee22y ago
I understand how to use interfaces, but I don't understand why you would need to or want to. In you example above, you'd get the same result by removing the interfaces and doing: class Car { public void Brake() { Console.WriteLine("Brake!"); } void HandBrake() { Console.WriteLine("HandBrake!"); } } class Interfaces { public static void Main() { Car car = new Car(); car.Brake(); car.HandBrake(); Console.Read(); } } Other that being able to name the methods the same thing and referring to them by the interface, the same thing is done. I suppose a more complicated, real-world example would help me understand a bit better. Every tutorial I have read says basically the same thing you did, nobrainer, but I still don't understand why you would want to use an interface, and more importantly, how this replace multiple inheritance. I have no programming training (I'm just figuring it out as I go), so maybe I'm just missing some fundamental concept that you all learned in college. Interfaces just look to me like a "don't forget to put this method in, mr. programmer" helper in Visual Studios. I highly doubt this is true, but I just can't seem to wrap my head around this concept.
bilnaad22y ago
nterfaces can be very important. For example you have some object and you want to check wich one can communicate(with something ^_^). You can check each object if it implements the interface for communication. For example ICommunicate. ----------------------------------------------- foreach(object obj in objects) { if (obj is ICommunicate) { //Call the functions to communicate } } ----------------------------------------------- As you can see it gives some flexibility to the language. Also when two interfaces have identical methods you can call them seperate using it's interface. This example shows how. ----------------------------------------------- namespace csConsole { using System; public interface IBrake { void Brake(); } public interface IHandBrake { void Brake(); } class Car : IBrake ,IHandBrake { public void Brake() { Console.WriteLine("Brake!"); } void IHandBrake.Brake() { Console.WriteLine("HandBrake!"); } } class Interfaces { public static void Main() { Car car = new Car(); ((IBrake)car).Brake(); ((IHandBrake)car).Brake(); Console.Read(); } } } ----------------------------------------------- I hope this basic usage satisfy you :)