Java Verstehe in dem Beispiel hier das sinn eine Schnittstelle(interface) nicht...

[Zeboo]

Hallo,

es geht um Schnittstellen. Eigentlich weiß ich jetzt das ganze theorie Zeug über die Schnittstellen:
- enthält keine Implementierung
- sie haben keinen Konstruktor
- statische Methoden nicht erlaubt
- möchte eine Klasse die Schnittstelle benutzen muss man es mit "implements name" erweitern

Das habe ich so gemerkt, aber nicht wirklich verstanden wozu man das braucht. Darauf stand im Buch ein Beispiel:

interface Unterhalted {

   int unterhalungswert();
}

public class Kirche extends Gebaeude implements Unterhaltend {

   int anzahlBeichstühle;
   int verfügbarerMesswein;

   /* Liefert den Unterhalungswert der Kirch. */
   /* @return Unterhaltungswert */

   public int unterhalungswert() {

      return anzahlBeichstühle * verfügbarerMesswein * verfügbarerMesswein;
   }
}

(also genau so stand es da) Ich habe mich über den code Beispiele gefreut, aber leider hat mir das kein bisschen geholfen. Ich verstehe den Sinn nicht.

Warum muss ich irgendwie auf die Schnittstelle zugreifen (unterhalungswert)? Man kann das ganze auch ohne die Schnittstelle machen. Da steht doch @return Unterhaltungswert... ich returne einfach von meine eigene Methode aus der Kirche Klasse. Warum, wie... leider ging es mit dem Code nicht weiter. Und so sehe ich das irgendwie nicht viel sinn bzw. wurde das mit der Schnittstelle schlecht erklärt.

Kann jemand dieses Code so erweitern, dass ich da ein Sinn sehe? Oder von mir aus ein Eigenes mit implements machen?

Würde mich sehr freuen!

Danke,
Gruss

Edit: Es stand danach kurz auch noch, dass es auch "Markierungsschnittstellen" gibt. Diese seien ohne Methoden. Soll gut sein, damit man leicht mit 'instanceof' prüfen kann ob sie einen gewollten Typ einnehmen oder nicht. Wenn ich das eine nicht verstehe, verstehe ich auch das andere nicht... hierzu gibt es aber nicht mal ein Codebeispiel :/

 

[Rossibaer]

Hallo Zeboo,
betrachte mal Schnittstellen als eine Art "Vertrag" wo alle Klassen die diese Schnittstelle implementieren von sich aus sicherstellen, das Sie bestimmte Methoden/Eigenschaften haben. Angenommen du erstellst 2 Klassen die eine ist deine "Kirche", die andere ein "Konzertsaal". Beide implementieren das Interface "Unterhaltend". Jetzt kannst du in deinem Programm Objekte von beiden Klassen verwenden ohne deren Klasse genau zu kennen um den Unterhaltungswert abzufragen, weil beide den Vertrag unterschrieben haben. Dazu erstellst du eine Variable vom Typ "Unterhaltend":

public void main()
{
  Kirche kirche1 = new Kirche(); // Objekt von Kircher erstellen
  Konzertsaal saal1 = new Konzertsaal(); // Objekt von Konzertsaal erstellen

  Kirche kirche2 = kirche1; // Zuweisung möglich weil beides die Klasse Kirche
  kirche2 = saal1; // Fehler weil nicht die gleiche Klasse

  Konzertsaal saal2 = saal1; // Zuweisung möglich weil beides die Klasse Konzertsaal
  saal2 = kirche1; // Fehler weil nicht die gleiche Klasse

  Unterhaltend unterhaltung1 = kirche1; // Zuweisung möglich weil Kirche das Interface Unterhaltend implementiert
  Unterhaltend unterhaltung2 = saal1; // Zuweisung möglich weil Konzertsaal das Interface Unterhaltend implementiert

  if (unterhaltung1.unterhalungswert==unterhaltung2.unterhalungswert)
  {
     // mach was ...
  }
}

In dem obigen Beispiel zeigen sich 2 Dinge:
1. du kannst nicht Kirche einem Konzertsaal zuweisen, weil es unterschiedliche Klassen sind
2. du kannst aber sowohl Kirche als auch Konzertsaal einer Variablen vom Typ Unterhaltend zuweisen, weil sie beide das Interface implementieren

Grüße
Rossibaer

 

[Eritsch]

der sinn von interfaces ist, dass man eine oder mehrere methoden in verschiedenen klassen unterschiedlich implementieren kann. um das beispiel von rossibaer weiter zu benutzen kannst du dann zum beispiel folgendes machen:

public class Konzertsaal extends Gebäude implements Unterhaltend {

int anzahlZuhörerplätze
int anzahlCateringstände

public int unterhaltungswert() {
return anzahlZuhörerplätze*anzahlCateringstände;
}
}

der konzertsaal hat also auch einen unterhaltungswert, der sich aber logischerweise aus anderen variablen berechnet als bei der kirche. durch das interface ist aber sichergestellt, das der unterhaltungswert von kirche und konzertsaal zueinander "kompatibel" sind.

 

[Zeboo]

Hallo,

vielen dank für die Antworten. Verstehe es etwas besser... aber den Sinn immer noch nicht wirklich. Nehmen wir an ich erweiter mein Beispiel. Dann kann ich eigentlich alle genaus so auch ohne Interface machen. Sagen wir:

public class Kirche implements Unterhaltend {

   int anzahlBeichstühle;
   int verfügbarerMesswein;

   public int unterhaltungswert() {

      return anzahlBeichstühle * verfügbarerMesswein * verfügbarerMesswein;
   }
   
   
   public void setverfügbarerMesswein(int verfügbarerMesswein) {
	   
	   this.verfügbarerMesswein = verfügbarerMesswein;
   }
   
   public void setanzahlBeichstühle(int anzahlBeichstühle) {
	   
	   this.anzahlBeichstühle = anzahlBeichstühle;
   }
   
   public static void main(String[] args) {
	   
	   Kirche k1 = new Kirche();
	   k1.setanzahlBeichstühle(3);
	   k1.setverfügbarerMesswein(10);
	   
	   Unterhaltend u1 = k1; //funktioniert, aber warum sollte man das machen?
	   
	   System.out.println(k1.unterhaltungswert()); //man kann k1.unterhaltungswert auch ohne den Interface machen. Ausgabe 300
	   System.out.println(u1.unterhaltungswert()); //unnötig? Ausgabe 300
	   
	   if(k1.unterhaltungswert()==s1.unterhaltungswert()) {
		   //s1 wurde jetzt nicht erstellt, aber um sowas zu machen braucht man auch keine implementierung
	   }
   }
}

Ich brauche kein interface. Auch wenn ich jetzt noch ein anderes Objekt machen würde, vom Saal oder sonstwas. Um die zu vergleichen oder irgendwelche unterhaltungswerte aus zu geben brauche ich kein interface

Verstehe ich nicht

Gruß

 

[Rossibaer]

Hallo Zeboo,

kein Problem, es lassen sich auch Programme schreiben ohne die Verwendung von Interfaces. Je umfangreicher aber deine Programme werden umso nützlicher werden Interfaces, weil du dann im Code nicht mehr die genauen Klassen kennen musst um auf die Interface Methoden bzw. Eigenschaften zugreifen zu können. Du musst nur wissen das die Klassen dieses Interface implementiert. Du kannst 2 Objekte von unterschiedlichen Klassen über das gleiche Interface ansprechen, d.h. deren Methoden/Eigenschaften verwenden.

Ein anderer Anwendungsfall für Interfaces wäre folgender: Soweit ich weis unterstützt Java nicht die Mehrfachvererbung. Hier ein konkretes Beispiel: Du selbst hast Eigenschaften von deiner Mutter und deinem Vater geerbt. Das geht nicht bei Java zu implementieren, wenn du eine Klasse "Mutter" und eine Klasse "Vater" erstellst, dann kannst du nicht die Klasse "Zeboo" erstellen, die aus beiden Klassen "Mutter" und "Vater" erbt. Wenn du aber die Eigenschaften/Methoden von "Mutter" und "Vater" als Interfaces implementierst, dann kannst du in der Klasse "Zeboo" sehr wohl beide Interfaces implementieren. Das ist zwar nicht das gleiche wie eine Vererbung, jedoch macht es bei der späteren Verwendung deiner Objekte keinen Unterschied, weil du jetzt Vater und Zeboo über das Interface gleich verwenden kannst, genauso wie Mutter und Zeboo. Es spielt dann keine Rolle ob dein Objekt aus der Klasse Zeboo oder Vater erstellt wurde, da es das gleiche Interface hat. siehe OOP mit Java: Mehrfachvererbung und Schnittstellen

Und noch ein Beispiel: Das USB Interface: In das USB Interface kannst du deinen MP3Player, deine Tastatur, deine Maus, deine Kamera und noch viele andere schöne Dinge, die USB Stecker haben, reinstecken. Es spielt keine Rolle was es für ein Gerät (Objekt einer Klasse) ist, dein PC kann damit etwas anfangen, weil es eben ein USB Interface hat. Kleiner Tip: Stell dir die Geräte als Objekte von Klassen und deinen PC als ein Programm das diese Objekte verwendet vor.

 

[Helios co.]

Hmm, kann wirklich überall auf Interfaces verzichten?

Ich bin mir nicht ganz sicher, aber gibt es nicht Patterns, die ohne Interfaces im Grunde keinen Sinn machen würden?

 

[Zeboo]

@Rossibaer: Vielen dank, jetzt geht es langsam

 

[Eritsch]

@ helios co.:

rossibaer hats ja eigentlich schon gesagt. bei einfachen programmen kann man auf interfaces verzichten, meist gehts dann sogar schneller vom programmieraufwand her. bei komplexeren programmen hingegen, dienen interfaces vor allem zur strukturierung. und wie schon erwähnt ist gerade bei mehrfachvererbung, die es so ja in java nicht gibt, die verwendung von interfaces unerlässlich.

 

[Elioth]

darüber hinaus dienen Interfaces auch der gemeinschaftlichen Programmierung. Programmierer XYZ kann eine "Blackbox" programmieren, die genau wie die "Blackbox2" von ABC zu "bedienen" ist. Ein dritter Anwender kann also ganz nach Wunsch und Einsatzbedarf Box1 oder 2 verwenden, ohne die Bedienung/Aufrufe ändern zu müssen.

Klassische Erklärung aus einem alten OO-Ansatz:

Du bist Autofahrer (Hauptptogramm) und sollst als Unterprogramm einen Sportwagen bedienen. Nun stell Dir vor, der hätte eine Fußlenkung, den Blinker, rechts und die Hupe unter dem Po.... Du erwartest aber (zu Recht) eine Bedienung, genau wie in einem BMW oder Golf oder einem Trabbi. Das ist Interfacing... In OO-Programmen wird dies dann auch verwendet, um mittels Objekten Fallunterscheidung zu betreiben, statt wie herkömmlich mit komplexen if, case oder ähnlichen Konstrukten. Ich bediene einfach ein Objekt "Auto", dem ich eine konkrete Instanz von zb Sportwagen, Kombi, Bus etc mit dem Interface "Auto" zugewiesen habe. Ich spare mir jedoch, bei jedem Bus, Kombi etc. diese Elemente neu zu bauen, sondern setze mittels Interface einfach die "Bedienelemente" ein.

In der Praxis ist es zb öfter so, daß ich in Anwendungen Erweiterungs-Punkte zur Verfügung stelle. Deren INTERFACE definiere ich, da mein Programm diese Erweiterung ja nutzen soll, ohne umgeschrieben zu werden. Nun implementiert ein anderer Entwickler eine konkrete Lösung, die vom Standard abweicht und im Hauptprogramm selbst ist kein Eingriff nötig. Plugins arbeiten im Grunde nach dem selben Modell.

Elioth