Perché non posso dichiarare metodi statici in un'interfaccia?

L'argomento dice di più: qual è la ragione per cui i metodi statici non possono essere dichiarati in un'interfaccia?

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

Il codice sopra mi dà il seguente errore (almeno in Eclipse): "Modificatore illegale per il metodo di interfaccia ITest.test (); sono ammessi solo pubblici e abstract".

Ci sono alcuni problemi in gioco qui. Il primo è il problema di dichiarare un metodo statico senza definirlo. Questa è la differenza tra

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

e

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

Il primo è impossibile per i motivi menzionati da Espo : non sai quale classe di implementazione sia la definizione corretta.

Java potrebbe consentire a quest'ultimo; e infatti, a partire da Java 8, lo fa!

Il motivo per cui non è possibile avere un metodo statico in un'interfaccia risiede nel modo in cui Java risolve i riferimenti statici. Java non si preoccuperà di cercare un'istanza di una classe quando tenta di eseguire un metodo statico. Questo perché i metodi statici non dipendono dall'istanza e quindi possono essere eseguiti direttamente dal file di classe. Dato che tutti i metodi in un'interfaccia sono astratti, la VM dovrebbe cercare una particolare implementazione dell'interfaccia per trovare il codice dietro il metodo statico in modo che possa essere eseguito. Ciò quindi contraddice il modo in cui funziona la risoluzione del metodo statico e introdurrebbe un'incoerenza nel linguaggio.

Risponderò alla tua domanda con un esempio. Supponiamo di avere una classe di matematica con aggiunta di un metodo statico. Definiresti questo metodo in questo modo:

Math.add(2, 3);

Se la matematica fosse un'interfaccia anziché una classe, non potrebbe avere alcuna funzione definita. Pertanto, dire qualcosa come Math.add (2, 3) non ha senso.

Il motivo risiede nel principio di progettazione, secondo cui Java non consente l'ereditarietà multipla. Il problema con l'ereditarietà multipla può essere illustrato dal seguente esempio:

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

Cosa succede se chiami Cx ()? Verrà eseguito Ax () o Bx ()? Ogni lingua con eredità multipla deve risolvere questo problema.

Le interfacce consentono in Java una sorta di eredità multipla limitata. Per evitare il problema sopra riportato, non sono autorizzati ad avere metodi. Se osserviamo lo stesso problema con interfacce e metodi statici:

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

Lo stesso problema qui, cosa succede se chiami Cx ()?

I metodi statici non sono metodi di istanza. Non esiste un contesto di istanza, quindi implementarlo dall'interfaccia ha poco senso.

Ora Java8 ci consente di definire anche i metodi statici nell'interfaccia.

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
   }
}

Nota: i metodi nell'interfaccia sono ancora astratti pubblici per impostazione predefinita se non utilizziamo esplicitamente le parole chiave default / static per renderle rispettive Metodi predefiniti e metodi statici.

C'è una risposta molto bella e concisa alla tua domanda qui . (Mi è sembrato un modo così semplice di spiegarlo che voglio collegarlo da qui.)

Sembra che il metodo statico nell'interfaccia potrebbe essere supportato in Java 8 , beh, la mia soluzione è semplicemente definirli nella classe interna.

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

La stessa tecnica può essere utilizzata anche nelle annotazioni:

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();
        }
    }
}

Si dovrebbe sempre accedere alla classe interna sotto forma Interface.fn...invece di Class.fn..., quindi, è possibile sbarazzarsi di problemi ambigui.

Un'interfaccia viene utilizzata per il polimorfismo, che si applica agli oggetti, non ai tipi. Pertanto (come già notato) non ha senso avere un membro di interfaccia statica.

Java 8 Aveva cambiato il mondo, puoi avere metodi statici nell'interfaccia, ma ti costringe a fornire l'implementazione per questo.

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);

}

Combinazione illegale di modificatori: statica e astratta

Se un membro di una classe viene dichiarato statico, può essere utilizzato con il suo nome di classe che è limitato a quella classe, senza creare un oggetto.

Se un membro di una classe viene dichiarato astratto, è necessario dichiarare la classe come astratta ed è necessario fornire l'implementazione del membro astratto nella sua classe ereditata (Sottoclasse).

È necessario fornire un'implementazione al membro astratto di una classe nella sottoclasse in cui si cambierà il comportamento del metodo statico, anche dichiarato astratto che è limitato alla classe base, che non è corretto

Poiché i metodi statici non possono essere ereditati. Quindi non serve metterlo nell'interfaccia. L'interfaccia è fondamentalmente un contratto che tutti i suoi abbonati devono seguire. Inserire un metodo statico nell'interfaccia costringerà gli abbonati a implementarlo. che ora diventa contraddittorio al fatto che i metodi statici non possono essere ereditati.

Con Java 8 , le interfacce possono ora avere metodi statici.

Ad esempio, Comparator ha un metodo statico naturalOrder ().

Anche il requisito secondo cui le interfacce non possono avere implementazioni è stato ridotto. Le interfacce possono ora dichiarare implementazioni di metodi "predefiniti", che sono come normali implementazioni con una sola eccezione: se erediti sia un'implementazione predefinita da un'interfaccia sia un'implementazione normale da una superclasse, l'implementazione della superclasse avrà sempre la priorità.

Forse un esempio di codice sarebbe di aiuto, userò C #, ma dovresti essere in grado di seguirlo.

Facciamo finta di avere un'interfaccia chiamata IPayable

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

Ora, abbiamo due classi concrete che implementano questa interfaccia:

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

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

Ora, facciamo finta di avere una raccolta di vari account, per fare questo useremo un elenco generico del tipo IPayable

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

Ora, vogliamo pagare $ 50,00 a tutti questi account:

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

Quindi ora vedi come le interfacce sono incredibilmente utili.

Sono utilizzati solo su oggetti istanziati. Non su classi statiche.

Se avessi reso pay statico, quando esegui il ciclo degli IPayable negli account To Pay non ci sarebbe modo di capire se dovrebbe chiamare pay su BusinessAcount o CustomerAccount.