abstract und interface

[Hbx8x]

Ich habe Probleme diese zwei Begriffe richtig anwenden zu können. Ich sehe noch nicht einmal den Unterschied darin. Was ich sehe ist das abstract mit extends im Zusammenhang liegt und analog interface mit implements.

Geht es bei beiden nicht lediglich einfach nur um Vererbung? d.h. das Attribute (Eigenschaften) und Methoden der Vaterklasse für ,,Subklassen" übernommen werden. Außerdem dienen beide Anweisungen um ,,Allgemeine" Attribute/Methoden in ihrem jeweiligen Code aufzustellen. Diese Attribute/methoden kann ich dann in ihren Subklassen aufrufen, so als ob sie in deren Klassen definiert wurden sind. Weiterhin kann man bei abstrakten Klassen und interfaces keine Objekte (Instanzen) erstellen. d.h. das einbinden in andere Subklassen funktioniert etwas anders als bei z.b.

class Beispielklasse {

void beispielmethode(int x){

// Anweisung }

}

class AndereKlasse {

Beispielklasse objektvonbeispielKlasse = new Beispielklasse; //Objekterzeugung (Instanzerzeugung)

objektvonbeispielKlasse.beispielmethode(233); // Dient dies nicht ebenfalls als ,,Schnittstelle" wie bei einem Interface?

Jetzt kann man das ganze ja nocheinmal über Schnittstellen (interface ->implements) bzw abstrakten Klassen (abstract -> extends) realisieren. Unterschied zu oben genannten Beispiel ist jedoch das oben keine Hierarchie vorhanden ist und bei Schnittstellen und abstrakten Klassen sind Hierarchien vorhanden (Vaterklasse - > Subklasse ->SubSubklasse -> usw).

Außerdem braucht man bei abstrakten Klassen und Schnittstellen keine Objekte zu erzeugen, bevor man auf die Attribute/Methoden ,,der anderen Seite" zugreifen kann. Das einbinden funktioniert einfach über extends bzw analog mit implements.

Kurz kann man sagen: Schnittstellen (Interface) und abstrakte Klassen(abstract) nutzen um allgemeine Attribute/Methoden aufzustellen die allgemein etwas beschreibt und dann später spezielle subklassen via implements und extends erstellen.

Kann mir bitte jemand sagen ob man das so sagen kann oder was ich mir noch merken muss ?

Lg

 

[Javinner]

Ich sehe noch nicht einmal den Unterschied darin

Eine abstrakte Klasse kann ein Konstruktor enthalten, Interface nicht. Man kann nur von einer Klasse erben, aber viele Interfaces implementieren. In beiden Fällen ist oft besser, darauf zu programmieren.

 

[stg]

Im interface beschreibst du was passiert, in der abstrakten Klassen kannst du beschreiben wie etwas passiert.

In der abstrakten Klasse kannst du zudem einen inneren Zustand abbilden.

Eine abstrakte Klasse kann ein Konstruktor enthalten

Jede Klass besitzt (mindestens) einen Konstruktor.

 

[temi]

Ein Interface ist, wie der Name schon sagt, eine Schnittstelle. Es ist damit eine Art Vertrag. Eine Klasse, die ein Interface implementiert, garantiert, die von der Schnittstelle geforderten Methoden zur Verfügung zu stellen.

Beispiel:

Das Interface "List<>" legt fest, welche Methoden eine Liste erfüllen muss. Konkrete Implementationen, die intern auch völlig unterschiedlich arbeiten können, sind:

ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector

Der Vorteil des Interface ist dabei, dass du die konkrete Implementation in deinem Programm, je nach Bedarf, wählen und auch ändern kannst:

List<String> liste = new ArrayList<>();

// "liste" ist vom Typ des Interfaces, wenn dir ArrayList später nicht mehr passt,
// kannst du einfach eine andere Klasse instantiieren, die List<> implementiert.
// Das Programm arbeitet nur mit den von List<> garantierten Methoden und funktioniert.

Außerdem kann eine Klasse mehrere Interfaces implementieren.

class Foo implements InterfaceA, InterfaceB {
    // code...
}

Foo foo = new Foo(); // geht
InterfaceA a = new Foo(); // geht auch
InterfaceB b = new Foo(); // geht auch

// nehmen wir eine Methode an, die als Parameter InterfaceA verlangt

void doSomethingWithA(InterfaceA a) {
    // code..
}

doSomethingWithA(foo); // geht

// oder eine, die InterfaceB als Parameter verlangt

void doSomethingWithB(InterfaceB b) {
    // code..
}

doSomethingWithB(foo); // geht auch

 

[temi]

Noch ein paar Worte zu abstract und interface:

Schau dir beispielsweise mal ArrayList an.

Die Vererbungshierarchie ist:

• java.lang.Object
  • java.util.AbstractCollection<E>
    • java.util.AbstractList<E>

Die implementierten Interfaces sind:

Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess

Dabei geht es z.B. darum doppelten Code zu vermeiden (DRY = don't repeat yourself, ist ein wichtiges Prinzip bei der Programmierung). Deshalb werden Interfaces häufig zuerst von abstrakten Klassen implementiert, die grundlegende Funktionen und Strukturen bereitstellen. Die eigentlich genutzten Listenklassen erben wiederum von diesen abstrakten Klassen und ergänzen dort spezialisierte Methoden.