Java Language
Standardmethoden

Einführung

Syntax

• public default void methodName () {/ * Methodenkörper * /}

Bemerkungen

Grundlegende Verwendung von Standardmethoden

/**
 * Interface with default method
 */
public interface Printable {
    default void printString() {
        System.out.println( "default implementation" );
    }
}

/**
 * Class which falls back to default implementation of {@link #printString()}
 */
public class WithDefault
    implements Printable
{
}

/**
 * Custom implementation of {@link #printString()}
 */
public class OverrideDefault
    implements Printable {
    @Override
    public void printString() {
        System.out.println( "overridden implementation" );
    }
}

Die folgenden aussagen

    new WithDefault().printString();
    new OverrideDefault().printString();

Erzeugt diese Ausgabe:

default implementation
overridden implementation

Zugriff auf andere Schnittstellenmethoden innerhalb der Standardmethode

Sie können auch auf andere Schnittstellenmethoden innerhalb Ihrer Standardmethode zugreifen.

public interface Summable {
    int getA();

    int getB();

    default int calculateSum() {
        return getA() + getB();
    }
}

public class Sum implements Summable {
    @Override
    public int getA() {
        return 1;
    }

    @Override
    public int getB() {
        return 2;
    }
}

Die folgende Anweisung wird 3 drucken:

System.out.println(new Sum().calculateSum());

Standardmethoden können auch zusammen mit statischen Methoden der Schnittstelle verwendet werden:

public interface Summable {
    static int getA() {
        return 1;
    }

    static int getB() {
        return 2;
    }

    default int calculateSum() {
        return getA() + getB();
    }
}

public class Sum implements Summable {}

Die folgende Anweisung wird auch 3 drucken:

System.out.println(new Sum().calculateSum());

Zugriff auf überschriebene Standardmethoden aus der implementierenden Klasse

In Klassen wird super.foo() nur in Superklassen super.foo() . Wenn Sie eine Standardimplementierung von einem Superinterface aus aufrufen möchten, müssen Sie sich super mit dem Namen der Schnittstelle qualifizieren: Fooable.super.foo() .

public interface Fooable {
    default int foo() {return 3;}
}

public class A extends Object implements Fooable {
    @Override
    public int foo() {
        //return super.foo() + 1; //error: no method foo() in java.lang.Object
        return Fooable.super.foo() + 1; //okay, returns 4
    }
}

Warum Standardmethoden verwenden?

Die einfache Antwort ist, dass Sie eine vorhandene Schnittstelle weiterentwickeln können, ohne vorhandene Implementierungen zu beschädigen.

Zum Beispiel haben Sie eine Swim , die Sie vor 20 Jahren veröffentlicht haben.

public interface Swim {
    void backStroke();
}

Wir haben großartige Arbeit geleistet, unsere Benutzeroberfläche ist sehr beliebt, es gibt viele Implementierungen auf der ganzen Welt und Sie haben keine Kontrolle über den Quellcode.

public class FooSwimmer implements Swim {
    public void backStroke() {
         System.out.println("Do backstroke");
    }
}

Nach 20 Jahren haben Sie sich entschieden, der Benutzeroberfläche neue Funktionen hinzuzufügen. Es sieht jedoch so aus, als ob unsere Benutzeroberfläche eingefroren ist, da bestehende Implementierungen dadurch beschädigt werden.

Glücklicherweise führt Java 8 eine brandneue Funktion namens Default-Methode ein.

Wir können jetzt der Swim Oberfläche eine neue Methode hinzufügen.

public interface Swim {
    void backStroke();
    default void sideStroke() {
        System.out.println("Default sidestroke implementation. Can be overridden");
    }
}

Jetzt können alle vorhandenen Implementierungen unserer Schnittstelle weiterhin funktionieren. Am wichtigsten ist jedoch, dass sie die neu hinzugefügte Methode zu ihrer eigenen Zeit implementieren können.

Einer der Hauptgründe für diese Änderung und eine ihrer größten Anwendungen liegt im Java Collections-Framework. Oracle konnte der vorhandenen Iterable-Schnittstelle keine foreach Methode hinzufügen, ohne den gesamten vorhandenen Code zu zerstören, der Iterable implementiert hat. Durch das Hinzufügen von Standardmethoden erbt die vorhandene Iterable-Implementierung die Standardimplementierung.

Klasse, abstrakte Klasse und Schnittstellenmethode Vorrang

Implementierungen in Klassen, einschließlich abstrakter Deklarationen, haben Vorrang vor allen Schnittstellenstandardwerten.

• Die abstrakte Klassenmethode hat Vorrang vor der Schnittstellenstandardmethode .

public interface Swim {
    default void backStroke() {
        System.out.println("Swim.backStroke");
    }
}

public abstract class AbstractSwimmer implements Swim {
    public void backStroke() {
        System.out.println("AbstractSwimmer.backStroke");
    }
}

public class FooSwimmer extends AbstractSwimmer {
}

Die folgende Aussage

new FooSwimmer().backStroke();

Wird herstellen

AbstractSwimmer.backStroke

• Klassenmethode hat Vorrang vor Schnittstellenstandardmethode

public interface Swim {
    default void backStroke() {
        System.out.println("Swim.backStroke");
    }
}

public abstract class AbstractSwimmer implements Swim {
}

public class FooSwimmer extends AbstractSwimmer {
    public void backStroke() {
        System.out.println("FooSwimmer.backStroke");
    }
}

Die folgende Aussage

new FooSwimmer().backStroke();

Wird herstellen

FooSwimmer.backStroke

Standardmethode Mehrfachvererbungskollision

Betrachten Sie das nächste Beispiel:

public interface A {
    default void foo() { System.out.println("A.foo"); }
}

public interface B {
    default void foo() { System.out.println("B.foo"); }
}

Hier sind zwei Schnittstellen, die die default foo mit derselben Signatur deklarieren.

Wenn Sie versuchen extend diese beiden Schnittstellen in der neuen Schnittstelle zu erweitern, müssen Sie zwei auswählen, da Java Sie zwingt, diese Kollision explizit aufzulösen.

Zunächst können Sie die Methode foo mit derselben Signatur wie abstract deklarieren, wodurch das Verhalten von A und B außer Kraft gesetzt wird.

public interface ABExtendsAbstract extends A, B {
    @Override
    void foo();
}

Und wenn Sie ABExtendsAbstract in der class implement ABExtendsAbstract Sie eine foo Implementierung bereitstellen:

public class ABExtendsAbstractImpl implements ABExtendsAbstract {
    @Override
    public void foo() { System.out.println("ABImpl.foo"); }
}

Oder zweitens, können Sie eine völlig neue schaffen default Sie können den Code der A und B foo Methoden auch wiederverwenden, indem Sie von der Implementierung der Klasse auf überschriebene Standardmethoden zugreifen .

public interface ABExtends extends A, B {
    @Override
    default void foo() { System.out.println("ABExtends.foo"); }
}

Und wenn Sie ABExtends in der class implement ABExtends Sie not foo Implementierung bereitstellen:

public class ABExtendsImpl implements ABExtends {}