Polymorphismus

Mariexshhx

Bekanntes Mitglied
Wenn ich zwei klasse habe a und b die das Interface i implementieren dann kann ich ja nix im Interface ändern, ohne auch die Klasse a und b zu ändern. Ist irgendwie trotzdem eine Änderung der Schnittstelle möglich, ohne a und b zu ändern

Mir fällt wirklich nix ein… ohne a und b zu ändern
 

Robert Zenz

Top Contributor
Natuerlich muss man auch die ableitenden Klassen aendern, deswegen gibt es ja die gemeinsame Schnittstelle. Ich meine das Extrembeispiel waere wenn man die Methode von doSomething() auf doSomething(BigDecimal) aendert. Wie sollen dann die ableitenden Klassen unveraendert bleiben koennen, es macht ja auch keinen Sinn dass man diese dann nicht aendern muss.

Auf der anderen Seite, wenn man zum Beispiel das hinzufuegen von Methoden in der Schnittstelle fangen will, werden dafuer oft abstrakte Klassen verwendet von denen sich alle anderen ableiten sollen.

Java:
public interface Base {
    public abstract void doSomething();
}

public abstract class AbstractBase implements Base {
    public void doSomething() {
        // Do nothing;
    }
}

Jetzt koennen sich konkrete Implementierungen von AbstractBase ableiten. Wenn eine Methode in Base hinzukommt, kann AbstractBase diese mit einem Standard- oder Platzhalterverhalten implementieren und die konkreten Implementierungen bleiben von der Aenderung komplett unbeeinflusst.
 

Arrive5784

Aktives Mitglied
InterfaceMitUnbedingtZuImplementierendenMethoden
|
v
AbstracteKlasseMit"Defaults"
|
v
DeineImplementierendenKonkretenKlassen

Die abstract Klasse kannst du jetzt fast beliebig ändern.
 

httpdigest

Top Contributor
Wenn ich zwei klasse habe a und b die das Interface i implementieren dann kann ich ja nix im Interface ändern, ohne auch die Klasse a und b zu ändern.
Das kommt auf die "Änderung" an. Zum Beispiel wurden in der Class Library von Java 8 mit der Stream API ja auch viele Interfaces, die es schon gab, um weitere Methoden erweitert, ohne, dass man die implementierenden Klassen auch anpassen musste, weil die Implementierung dieser neuen Methoden nur auf bereits existierenden Schnittstellen-Methoden aufsetzte - also auf Methoden/Features, die das jeweilige Interface selbst bereits mitbrachte. Und die Art, wie es umgesetzt wurde (ohne die implementierenden Klassen anzufassen) wurde ermöglicht durch die bereits genannten "Default Methoden" in Interfaces.

Ein Beispiel hier ist etwa das java.lang.Iterable Interface. Dies hatte bis vor Java 8 nur eine Methode, nämlich iterator() und war Teil der Java Language Specification, um enhanced for-loops (auch "for-each loops" genannte) zu ermöglichen.

Mit Java 8 wurde das Interface um eine Methode erweitert, nämlich forEach(Consumer) und das geschah folgendermaßen:
Java:
public interface Iterable<T> {
  Iterator<T> iterator(); // <-- existierte bereits

  // NEU:
  default void forEach(Consumer<? super T> action) {
    for (T t : this)
      action.accept(t);
  }
}
Die neue forEach-Methode wurde also mit Hilfe der bereits existierenden Methode iterator() implementiert. Natürlich können implementierende Klassen die Methode "noch besser"/effizienter umsetzen. Aber eine "default"-Möglichkeit, die immer geht, ist es eben, forEach über den Iterator zu implementieren.
 

Ähnliche Java Themen

Neue Themen


Oben