Definieren Sie eine statische Methode in der Java-Schnittstelle

1. Statische Methode in der Java-Schnittstelle
2. Bedeutung der Verwendung statischer Methoden in einer Schnittstelle
3. Regeln für statische Methoden in einer Schnittstelle
4. Gründe für das Fehlen statischer Methoden in Schnittstellen vor Java 8
5. Gründe dafür, dass eine statische Methode nicht überschrieben werden kann

Dieses Tutorial listet die Regeln für statische Methoden in der Java-Schnittstelle auf und zeigt, wie man sie definiert und warum man sie nicht überschreiben kann. Wir werden auch die Gründe untersuchen, warum es vor Java 8 keine statischen Methoden in Schnittstellen gibt.

Statische Methode in der Java-Schnittstelle

Bevor wir auf die statischen Methoden in Java-Schnittstellen eingehen, ist es wichtig, etwas über eine Schnittstelle zu wissen, die eine oder mehrere abstrakte Methoden (die Methoden ohne Körper) enthält, die in der Klasse definiert sind, die diese Schnittstelle implementiert. .

Beachten Sie, dass diese abstrakten Methoden öffentliche Methoden sind, unabhängig davon, ob wir den Modifikator öffentlich schreiben oder nicht.

Beispielcode:

public interface Messages {
  // public & abstract
  public void display();
}

public class Test implements Messages {
  // implementation of abstract method
  public void display() {
    System.out.println("Hi! Welcome to the DelftStack");
  }

  public static void main(String[] args) {
    Test test = new Test();
    test.display();
  }
}

Ausgang:

Hi! Welcome to the DelftStack

Denken Sie daran, dass die abstrakte Methode mit dem Namen display() eine öffentliche Methode ist, wir müssen die Test-Klasse instanziieren, um die display()-Methode auszuführen.

Andererseits ist die statische Methode der Klasse selbst zugeordnet, in der sie definiert sind, und wir müssen die Klasse nicht instanziieren, um diese statischen Methoden zu verwenden. Ab Java 8 können wir nun statische Schnittstellenmethoden haben.

Jetzt haben wir einen vollständigen Körper und alle erforderlichen Anweisungen für diese spezifische statische Methode in der Schnittstelle. Denken Sie daran, dass auf die statischen Methoden nur auf Klassenebene zugegriffen werden kann, nicht auf Instanzebene.

Wir können also wie folgt auf die statischen Methoden zugreifen.

Beispielcode:

public interface Messages {
  // static method
  static void display() {
    System.out.println("Hello! Nice to meet you");
  }
}

public class Test {
  public static void main(String[] args) {
    Messages.display();
  }
}

Ausgang:

Hello! Nice to meet you

Die Frage ist, können wir eine statische Methode überschreiben? Nein, wir können eine statische Methode nicht überschreiben. Andernfalls erhalten wir einen Kompilierungsfehler.

Außerdem können wir sie nicht über eine Instanz einer implementierenden Klasse aufrufen, da die statischen Methoden versteckt sind. Sehen Sie sich das folgende Beispiel an, das einen Kompilierungsfehler erzeugt.

Beispielcode:

public interface Messages {
  static void display() {
    System.out.println("Hello! Nice to meet you");
  }
}

public class Test implements Messages {
  @Override
  public void display() {
    System.out.println("Override");
  }
  public static void main(String[] args) {
    Test test = new Test();
    test.display();
  }
}

Es folgt die Fehlerbeschreibung, die durch den obigen Codezaun erzeugt wird.

Ausgang:

Test.java:25: error: method does not override or implement a method from a supertype
  @Override
  ^
1 error

Bedeutung der Verwendung statischer Methoden in einer Schnittstelle

Wir können die folgenden Vorteile aus der Verwendung von statischen Methoden in Java-Schnittstellen ziehen.

1. Eine statische Methode einer Schnittstelle kapselt das Verhalten, das Unterklassen oder Unterschnittstellen nicht erben oder überschreiben sollen.
2. Diese statischen Methoden einer Java-Schnittstelle sind nützlich, um wiederverwendbare Dienstprogramme zu entwickeln, die nicht auf bestimmte Implementierungstypen von Klassen beschränkt sind.

Regeln für statische Methoden in einer Schnittstelle

Der folgende Abschnitt zeigt die Regeln für die oben genannten Vorteile bei der Verwendung von statischen Methoden.

Die Standardmethoden einer Schnittstelle enthalten die Anweisung für das Standardverhalten, und die implementierende Klasse kann auswählen, konkretere Anweisungen bereitzustellen, indem sie sie überschreibt oder unverändert erbt. Ähnlich wie Standardmethoden enthalten die statischen Methoden einen Hauptteil (eine Reihe von Anweisungen) für ihr Verhalten, aber eine implementierende Klasse darf eine statische Methode ihrer Schnittstelle nicht erben oder überschreiben, wie wir zuvor gelernt haben.

Jemand mit einer statischen Methode in einer Java-Schnittstelle sollte sich an die folgenden Regeln erinnern.

1. Diese Methoden müssen einen Körper haben.
2. Wir können diese statischen Methoden nur mit einem interface-Namen ausführen.
3. Diese Methoden müssen einen statischen Modifikator in der Deklaration der Methode haben. Wenn Sie nichts angeben, wäre es standardmäßig öffentlich. Denken Sie daran, wir können sie auch privat machen, wenn wir wollen.
4. Sie können keine anderen abstrakten oder Standardmethoden aufrufen.
5. Unterklassen oder Unterschnittstellen dürfen diese statischen Methoden nicht überschreiben oder erben.

Nun, an diesem Punkt haben Sie vielleicht zwei Fragen im Kopf.

1. Warum konnten wir früher (vor der Veröffentlichung von Java 8) keine statischen Methoden haben?
2. Warum können wir statische Methoden nicht überschreiben?

Lassen Sie uns die Antworten auf diese beiden Fragen herausfinden.

Gründe für das Fehlen statischer Methoden in Schnittstellen vor Java 8

Es gab keinen starken und primären technischen Grund, warum Java-Schnittstellen vor der Veröffentlichung von Java 8 keine statischen Methoden hatten. Diese statischen Methoden wurden als kleine Sprachaktualisierungen oder -änderungen betrachtet, und dann gab es einen offiziellen Vorschlag, sie in Java hinzuzufügen 7, aber später wurde es aufgrund einiger Komplikationen fallen gelassen.

Schließlich wurden wir in Java 8 mit statischen Methoden in Schnittstellen vertraut gemacht. Ab Java 8 haben wir auch etwas über überschreibbare Instanzfunktionen/-methoden mit Standardimplementierungen gelernt.

Denken Sie daran, dass sie immer noch keine Instanzfelder enthielten. Diese Funktionen sind Teil der lambda-Ausdrucksunterstützung, die Sie hier lesen können (JSR 335 Teil H).

Gründe dafür, dass eine statische Methode nicht überschrieben werden kann

Die statischen Methoden werden zur Kompilierzeit aufgelöst. Die dynamischen Dispatches sind bei Instanzmethoden sinnvoll, bei denen ein Compiler den konkreten Typ des Objekts nicht bestimmen kann; Daher können wir eine aufzurufende Methode nicht auflösen.

Aber wir brauchen eine Klasse, um eine statische Methode auszuführen; Da diese bestimmte Klasse statisch bekannt ist – zur Kompilierzeit – ist ein dynamischer Versand unnötig.

Angenommen, jede Klasse hat eine HashTable, die die Signatur einer Methode (Name und Parametertypen) dem eigentlichen Codeteil zuordnet, um die Methode zu implementieren. Wenn die VM versucht, eine Methode auf einer Instanz auszuführen, fragt sie ein Objekt nach seiner Klasse ab und sucht in einer Klassentabelle nach der angeforderten Signatur.

Es wird aufgerufen, wenn der Methodenkörper gefunden wird; andernfalls wird die Elternklasse der Klasse dort abgerufen, wo die Suche wiederholt wird. Dieser Prozess wird fortgesetzt, bis eine Methode gefunden wird oder keine übergeordneten Klassen mehr übrig sind (was zu NoSuchMethodError führt).

Wenn die entsprechenden Tabellen einen Eintrag für eine Unterklasse und eine Oberklasse für dieselbe Methodensignatur haben, würde die Version der Unterklasse zuerst angetroffen werden, und die Version der Oberklasse wird niemals verwendet – dies ist ein override.

Angenommen, wir überspringen eine Objektinstanz und beginnen mit der Unterklasse, könnte die Auflösung wie oben beschrieben ablaufen und Ihnen eine Art überschreibbare statische Methode zur Verfügung stellen. Beachten Sie, dass diese Auflösung nur zur Kompilierzeit erfolgen kann.

Wir wissen jedoch, dass ein Compiler von der bekannten Klasse aus startet, anstatt bis zur Laufzeit zu warten, um das Objekt eines nicht spezifizierten Typs nach seiner Klasse abzufragen. Es hätte also keinen Sinn, eine statische Methode zu überschreiben.