Warum kann ich keine statischen Methoden in einer Schnittstelle deklarieren?

Das Thema sagt das meiste aus - was ist der Grund dafür, dass statische Methoden in einer Schnittstelle nicht deklariert werden können?

public interface ITest {
    public static String test();
}

Der obige Code gibt mir den folgenden Fehler (zumindest in Eclipse): "Unzulässiger Modifikator für die Schnittstellenmethode ITest.test (); nur public & abstract sind zulässig".

Hier spielen einige Probleme eine Rolle. Das erste ist das Problem, eine statische Methode zu deklarieren, ohne sie zu definieren. Das ist der Unterschied zwischen

public interface Foo {
  public static int bar();
}

und

public interface Foo {
  public static int bar() {
    ...
  }
}

Das erste ist aus den von Espo genannten Gründen unmöglich : Sie wissen nicht, welche implementierende Klasse die richtige Definition ist.

Java könnte Letzteres zulassen; und in der Tat, ab Java 8, tut es!

Der Grund, warum Sie keine statische Methode in einer Schnittstelle haben können, liegt in der Art und Weise, wie Java statische Referenzen auflöst. Java wird sich nicht die Mühe machen, nach einer Instanz einer Klasse zu suchen, wenn versucht wird, eine statische Methode auszuführen. Dies liegt daran, dass statische Methoden nicht instanzabhängig sind und daher direkt aus der Klassendatei ausgeführt werden können. Da alle Methoden in einer Schnittstelle abstrakt sind, müsste die VM nach einer bestimmten Implementierung der Schnittstelle suchen, um den Code hinter der statischen Methode zu finden, damit sie ausgeführt werden kann. Dies widerspricht dann der Funktionsweise der statischen Methodenauflösung und würde zu einer Inkonsistenz in der Sprache führen.

Ich werde Ihre Frage mit einem Beispiel beantworten. Angenommen, wir hätten eine Matheklasse mit einer statischen Methode hinzufügen. Sie würden diese Methode folgendermaßen aufrufen:

Math.add(2, 3);

Wenn Math eine Schnittstelle anstelle einer Klasse wäre, könnte es keine definierten Funktionen haben. Daher macht es keinen Sinn, etwas wie Math.add (2, 3) zu sagen.

Der Grund liegt im Design-Prinzip, dass Java keine Mehrfachvererbung zulässt. Das Problem der Mehrfachvererbung kann anhand des folgenden Beispiels veranschaulicht werden:

public class A {
   public method x() {...}
}
public class B {
   public method x() {...}
}
public class C extends A, B { ... }

Was passiert nun, wenn Sie Cx () aufrufen? Wird Ax () oder Bx () ausgeführt? Jede Sprache mit Mehrfachvererbung muss dieses Problem lösen.

Schnittstellen ermöglichen in Java eine Art eingeschränkte Mehrfachvererbung. Um das oben genannte Problem zu vermeiden, dürfen sie keine Methoden haben. Wenn wir das gleiche Problem mit Schnittstellen und statischen Methoden betrachten:

public interface A {
   public static method x() {...}
}
public interface B {
   public static method x() {...}
}
public class C implements A, B { ... }

Gleiches Problem hier, was passiert, wenn Sie Cx () aufrufen?

Statische Methoden sind keine Instanzmethoden. Es gibt keinen Instanzkontext, daher ist es wenig sinnvoll, ihn über die Schnittstelle zu implementieren.

Mit Java8 können wir jetzt sogar statische Methoden in Interface definieren.

interface X {
    static void foo() {
       System.out.println("foo");
    }
}

class Y implements X {
    //...
}

public class Z {
   public static void main(String[] args) {
      X.foo();
      // Y.foo(); // won't compile because foo() is a Static Method of X and not Y
   }
}

Hinweis: Methoden in der Schnittstelle sind standardmäßig immer noch öffentlich abstrakt, wenn wir die Schlüsselwörter default / static nicht explizit verwenden, um sie zu Standardmethoden bzw. statischen Methoden zu machen.

Es ist eine sehr schöne und prägnante Antwort auf Ihre Frage hier . (Es kam mir so einfach vor, es zu erklären, dass ich es von hier aus verlinken möchte.)

Es scheint, dass die statische Methode in der Schnittstelle in Java 8 unterstützt wird. Meine Lösung besteht darin, sie nur in der inneren Klasse zu definieren.

interface Foo {
    // ...
    class fn {
        public static void func1(...) {
            // ...
        }
    }
}

Dieselbe Technik kann auch in Anmerkungen verwendet werden:

public @interface Foo {
    String value();

    class fn {
        public static String getValue(Object obj) {
            Foo foo = obj.getClass().getAnnotation(Foo.class);
            return foo == null ? null : foo.value();
        }
    }
}

Auf die innere Klasse sollte immer in Form von zugegriffen werden, Interface.fn...anstatt dass Class.fn...Sie dann mehrdeutige Probleme beseitigen können.

Für den Polymorphismus wird eine Schnittstelle verwendet, die für Objekte und nicht für Typen gilt. Daher ist es (wie bereits erwähnt) nicht sinnvoll, ein statisches Schnittstellenmitglied zu haben.

Java 8 hat die Welt verändert. Sie können statische Methoden in der Schnittstelle haben, aber es zwingt Sie, die Implementierung dafür bereitzustellen.

public interface StaticMethodInterface {
public static int testStaticMethod() {
    return 0;
}

/**
 * Illegal combination of modifiers for the interface method
 * testStaticMethod; only one of abstract, default, or static permitted
 * 
 * @param i
 * @return
 */
// public static abstract int testStaticMethod(float i);

default int testNonStaticMethod() {
    return 1;
}

/**
 * Without implementation.
 * 
 * @param i
 * @return
 */
int testNonStaticMethod(float i);

}}

Illegale Kombination von Modifikatoren: statisch und abstrakt

Wenn ein Mitglied einer Klasse als statisch deklariert ist, kann es mit seinem auf diese Klasse beschränkten Klassennamen verwendet werden, ohne ein Objekt zu erstellen.

Wenn ein Mitglied einer Klasse als abstrakt deklariert ist, müssen Sie die Klasse als abstrakt deklarieren und die Implementierung des abstrakten Mitglieds in seiner geerbten Klasse (Unterklasse) bereitstellen.

Sie müssen dem abstrakten Element einer Klasse in einer Unterklasse eine Implementierung bereitstellen, in der Sie das Verhalten der statischen Methode ändern, die ebenfalls als abstrakt deklariert ist und auf die Basisklasse beschränkt ist, was nicht korrekt ist

Da statische Methoden nicht vererbt werden können. Es macht also keinen Sinn, es in die Benutzeroberfläche zu stellen. Interface ist im Grunde ein Vertrag, dem alle Abonnenten folgen müssen. Wenn Sie eine statische Methode in die Schnittstelle einfügen, werden die Abonnenten gezwungen, sie zu implementieren. Dies widerspricht nun der Tatsache, dass statische Methoden nicht vererbt werden können.

Mit Java 8 können Schnittstellen jetzt statische Methoden haben.

Zum Beispiel hat Comparator eine statische naturalOrder () -Methode.

Die Anforderung, dass Schnittstellen keine Implementierungen haben dürfen, wurde ebenfalls gelockert. Schnittstellen können jetzt "Standard" -Methodenimplementierungen deklarieren, die mit einer Ausnahme wie normale Implementierungen sind: Wenn Sie sowohl eine Standardimplementierung von einer Schnittstelle als auch eine normale Implementierung von einer Oberklasse erben, hat die Implementierung der Oberklasse immer Vorrang.

Vielleicht würde ein Codebeispiel helfen, ich werde C # verwenden, aber Sie sollten in der Lage sein, mitzumachen.

Stellen wir uns vor, wir hätten eine Schnittstelle namens IPayable

public interface IPayable
{
    public Pay(double amount);
}

Jetzt haben wir zwei konkrete Klassen, die diese Schnittstelle implementieren:

public class BusinessAccount : IPayable
{
    public void Pay(double amount)
    {
        //Logic
    }
}

public class CustomerAccount : IPayable
{
    public void Pay(double amount)
    {
        //Logic
    }
}

Stellen wir uns nun vor, wir hätten eine Sammlung verschiedener Konten. Dazu verwenden wir eine generische Liste vom Typ IPayable

List<IPayable> accountsToPay = new List<IPayable>();
accountsToPay.add(new CustomerAccount());
accountsToPay.add(new BusinessAccount());

Jetzt möchten wir 50,00 USD auf alle diese Konten zahlen:

foreach (IPayable account in accountsToPay)
{
    account.Pay(50.00);
}

Jetzt sehen Sie, wie unglaublich nützlich Schnittstellen sind.

Sie werden nur für instanziierte Objekte verwendet. Nicht für statische Klassen.

Wenn Sie die Zahlung statisch gemacht hätten, wäre es beim Durchlaufen der IPayable-Konten in AccountsToPay nicht möglich, herauszufinden, ob Pay on BusinessAcount oder CustomerAccount aufgerufen werden sollte.