HowTo: Interfaces/Schnittstellen verstehen – mal auf simple Art und Weise
In dem HowTo geht es um ein sehr simples Thema, womit aber besonders Einsteiger in der Programmierung Probleme haben: Wozu sind Schnittstellen/Interfaces gut? Man kann doch auch genauso gut von einer Klasse erben – also wozu der Spaß und wo kann man das sinnvoll einsetzen?
Wir machen das sehr kurz und schmerzlos an einem “praktischen” Beispiel aus der Natur 
In unserem sehr einfachen Beispiel wollen wir bestimmte Klasse (Train, Car, Human) erstellen welche beweglich sind (IMovable) – jedoch bewegt sich ja alles auf eine unterschiedliche Art und Weise, daher ist das unsere Schnittstelle.
Jetzt gehen wir mal davon aus, dass es einen Gott (God) gibt, dann kann der auch ohne Probleme ein bewegliches Objekt “anstupsen”. Genau das wollen wir jetzt implementieren – wie gesagt, sehr praxisnah .
Konsolenprojekt Struktur:
Das wichtigste ist erstmal unser Interface “IMovable” (Schnittstellen werden in .NET immer mit einem I davor geschrieben):
public interface IMovable { void Move(); }
Die Schnittstelle legt nur fest, welche Methoden, Eigenschaften oder Events etwas hat – wie dies jeweils implementiert ist entscheidet dann die Klasse.
public class Human : IMovable { #region IMovable Member public void Move() { Console.WriteLine("Der Mensch macht einen Schritt vor."); } #endregion }
Unser Mensch kann einen Schritt vor dem anderen machen – unser Zug fährt zum nächsten Bahnhof und unser Auto nur zur nächsten Ampel. In den einzelnen Klassen kann man nun die Methode implementieren wie man mag – wichtig ist nur, dass die Signatur (also Rückgabetyp, Parameter & Name) gleich bleibt.
Jetzt wollen wir unseren Gott implementieren, welcher Objekte “anstupsen” kann. Allerdings wollen wir nicht X Methoden erstellen, die in dieser Form sind “MoveObject(Human human)”, weil wir noch nicht genau wissen, was sonst noch für bewegliche Klassen hinzukommen.
Hier kommt jetzt unser Interface zum Einsatz:
public class God { public static void MoveObject(IMovable item) { Console.WriteLine("Ein bewegliches Objekt wird bewegt..."); item.Move(); } }
Die Methode “MoveObject” nimmt einfach “irgendwas” was “IMovable” impementiert – egal ob es ein Auto, Zug oder Mensch ist.
Allerdings kann man in dieser Version jetzt nur auf die Methoden, Eigenschaften etc. zugreifen, welche in der Schnittstelle definiert sind:
Wenn man jetzt beim Auto noch eine spezial Methode implementiert hat, welche man unbedingt dort aufrufen will, muss man casten und über GetType prüfen, ob das Objekt von Typ “Car” ist – aber das geht zu weit und ist jetzt erstmal kein Thema hier.
Der Hauptvorteil jetzt liegt darin, dass unsere “MoveObject” Methode keine Ahnung haben braucht, was “item” einfach ist – hauptsache es ist beweglich. Was beweglich bei diesem Objekt heisst, ist dieser Methode egal.
Unser kleines Programm testen:
class Program { static void Main(string[] args) { Car BMW = new Car(); Train ICE = new Train(); Human Robert = new Human(); God.MoveObject(BMW); God.MoveObject(ICE); God.MoveObject(Robert); Console.ReadLine(); } }
Wir haben ein BMW, ein ICE und mich – und diese bewegt unser Gott natürlich. Resultat:
So – alle unsere 3 Objekte bewegen sich anders und es wird angezeigt. Jetzt kann man noch weitere Klassen hinzufügen, welche ebenfalls “IMovable” implementieren und wir brauchen die God.MoveObject Methode nicht anpassen.
Olé
PS: Nein, ich bin nicht religös, brauchte aber ein einfaches Beispiel.
Deutsch
Englisch
Thomas sagt
am 28. November 2007 @ 22:49
Schönes Beispiel!
Hans-Peter Schelian sagt
am 29. November 2007 @ 08:00
Sehr schönes und einfaches Beispiel.
Das werde ich sicherlich nutzen, und den Link weitergeben, wenn mich wieder einer fragt was das mit den Schnittstellen auf sich hat.
Gott sei Dank !!
Und dir natürlich
Interfaces/Schnittstellen sehr gut erklärt - Bionic's blOg sagt
am 6. Dezember 2007 @ 21:21
[...] habe ich gerade ein schönen Artikel entdeckt, der sehr anschaulich und sehr gut die Verwendung von Interfaces/Schnittstellen [...]
CC13.com » Blog Archive » Interfaces/Schnittstellen Howto sagt
am 7. Dezember 2007 @ 06:53
[...] Code-Inside.de gibt es ein C# Interfaces/Schnittstellen-Howto. Wie ich finde, sehr gut erklärt. Gefunden bei [...]
Carsten sagt
am 20. Januar 2008 @ 10:38
Cooles HowTo , hat in 2 Minuten alle Fragen beantwortet !
Danke !
Johannes sagt
am 26. März 2008 @ 19:59
Danke fürs Beispiel … kurz und verständlich
Du hast geschafft was unser Lehrer in 2 h nicht geschafft hat
Marc sagt
am 2. Juni 2008 @ 20:57
Sehr gutes Beispiel.
Übrigens, Gott schubst einen nur an, wenn man das möchte. Try it!
michael sagt
am 3. Juni 2008 @ 10:29
guter artikel, sourcecode kann allerdings nicht downgeloaded werden: 404
Robert Mühsig sagt
am 3. Juni 2008 @ 11:21
Vielen Dank für den Hinweis – ist jetzt gefixt
Lukas sagt
am 8. August 2008 @ 09:56
Heyho..danke für die schnelle Erklärung..
Echt gut gelungen das ganze, schnell zu lernen und man kenn sich aus;)
gratz von meiner seite
HowTo: Interfaces/Schnittstellen einsetzen - Gute Gründe für den Einsatz von Schnittstellen | Code-Inside Blog sagt
am 12. August 2008 @ 22:22
[...] einem HowTo ging es darum, was Interface eigentlich sind und wo man sowas einsetzen könnte. In vielen OOP [...]
Christoph sagt
am 18. August 2008 @ 12:24
Ich habe den Sinn von Interfaces über Jahre nicht verstanden (auch nicht weiter nachgeforscht) und sie daher auch nie angewendet. Erst durch dieses Beispiel hier ist mir der praktische Nutzen bewusst geworden.
HowTo: 3-Tier / 3-Schichten Architektur | Code-Inside Blog sagt
am 17. Oktober 2008 @ 23:40
[...] Ordern “DataAccess” liegt unsere Schnittstellen (Einführung zu Schnittstellen) zu den Datenquellen.In diesem Fall haben wir nur die Schnittstelle “IUserRepository” [...]
Thimo sagt
am 21. Oktober 2008 @ 21:31
Hallo!
Also erstmal, großes Lob für diese simple und einleuchtende Erklärung =)
Nun ein ganz kleiner Vergesserungsvorschlag:
Du hattest geschrieben:
[..]Die Methode “MoveObject” nimmt einfach “irgendwas” was von “IMovable” abgeleitet ist – egal ob es ein Auto, Zug oder Mensch ist. [...]
Richtiger wäre wenn du schreiben würdest, dass die Methode MoveObject einfach "irgendwas" nimmt was IMovable implementiert. Nicht was davon abgeleitet ist.
Da kann man Ärger für bekommen
Ansonsten könntest du Movable noch Moveable bennen =)
*klugscheißen off*
Sorry, ist nicht blöd gemeint oder so aber wollen ja nicht dass sich das alle "nicht ganz richtig" merken.
Sooo.. aber wie gesagt, tolle arbeit.
Würde ich jedem empfehlen der mit Interfaces noch auf Kriegsfuß steht bzw. nicht weiß wozu das Ganze =)
Robert Mühsig sagt
am 22. Oktober 2008 @ 12:10
Das mit dem abgeleitet/implementiert habe ich geändert – danke für die Info.
Bei dem "Movable": dict.cc sagt mir das beide Varianten gehen (und ich auch zu Faul bin diese jetzt umzubenennen)
-com- sagt
am 1. Juli 2010 @ 11:15
top!
Mark sagt
am 12. Juli 2010 @ 13:48
Erstmal schönes Beispiel, aber entweder bin ich lernresistent oder ich brauch wirklich mal ein Bsp. aus der Praxis. Weil ich seh den Vorteil immernoch nicht.
Wieso werf ich das Interface und GodKlasse nicht einfach weg und mache in der Main:
BMW.Move();
Human.Move();
etc.
Spart mir Programmieraufwand und auch hier kann ja problemlos ein neues Objekt hinzukommen, zBsp. ein Flugzeug. Ein Objekt davon wird in der Main ja sowieso erstellt:
Plane a380 = new Plane();
und ob ich dann:
a380.Move();
oder
God.MoveObject(a380);
mache ist doch egal ?
Das man die God-Klasse nicht ändern muss hab ich ja verstanden, ich frage mich nur immer, wozu brauch ich sowas überhaupt ? Wenn ich das Flugzeug, Auto, Mensch Objekt ohnehin erzeuge, wieso rufe ich die Methode nicht direkt darauf auf sondern über Umwege ?
Robert Mühsig sagt
am 15. Juli 2010 @ 15:10
Hier hast du mal ein Beispiel aus der Praxis, ist allerdings durch das Thema “Dependency Injection” schon etwas komplexer: http://code-inside.de/blog/2010/06/27/howto-alle-implementationen-vom-interface-x-ber-castle-windsor-per-di-auflsen/