Por que não posso declarar métodos estáticos em uma interface?

O tópico diz o máximo - qual é a razão do fato de que métodos estáticos não podem ser declarados em uma interface?

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

O código acima me fornece o seguinte erro (no Eclipse, pelo menos): "Modificador ilegal para o método de interface ITest.test (); somente público e resumo são permitidos".

Existem alguns problemas em jogo aqui. O primeiro é a questão de declarar um método estático sem defini-lo. Essa é a diferença entre

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

e

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

O primeiro é impossível pelos motivos mencionados pela Espo : você não sabe qual classe de implementação é a definição correta.

Java poderia permitir o último; e, de fato, a partir do Java 8, ele faz!

A razão pela qual você não pode ter um método estático em uma interface está na maneira como o Java resolve as referências estáticas. Java não se incomodará em procurar uma instância de uma classe ao tentar executar um método estático. Isso ocorre porque os métodos estáticos não dependem da instância e, portanto, podem ser executados diretamente do arquivo de classe. Dado que todos os métodos em uma interface são abstratos, a VM precisaria procurar uma implementação específica da interface para encontrar o código por trás do método estático para que ele pudesse ser executado. Isso então contradiz como a resolução estática do método funciona e introduziria uma inconsistência na linguagem.

Eu responderei sua pergunta com um exemplo. Suponha que tenhamos uma classe Math com um método estático add. Você chamaria esse método da seguinte maneira:

Math.add(2, 3);

Se o Math fosse uma interface em vez de uma classe, ele não poderia ter nenhuma função definida. Como tal, dizer algo como Math.add (2, 3) não faz sentido.

A razão reside no princípio de design, que java não permite herança múltipla. O problema com herança múltipla pode ser ilustrado pelo seguinte exemplo:

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

Agora, o que acontece se você chamar Cx ()? O Ax () ou o Bx () serão executados? Todo idioma com herança múltipla precisa resolver esse problema.

As interfaces permitem em Java algum tipo de herança múltipla restrita. Para evitar o problema acima, eles não têm permissão para ter métodos. Se olharmos para o mesmo problema com interfaces e métodos estáticos:

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

Mesmo problema aqui, o que acontece se você chamar Cx ()?

Métodos estáticos não são métodos de instância. Não há contexto de instância; portanto, implementá-lo a partir da interface faz pouco sentido.

Agora, o Java8 nos permite definir até métodos estáticos na interface.

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: Os métodos na Interface ainda são abstratos públicos por padrão, se não usarmos explicitamente as palavras-chave default / static para torná-las Métodos padrão e Métodos estáticos resp.

Há uma resposta muito agradável e concisa para sua pergunta aqui . (Pareceu-me uma maneira bem direta de explicar que quero vinculá-lo daqui.)

Parece que o método estático na interface pode ser suportado no Java 8 , bem, minha solução é apenas defini-los na classe interna.

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

A mesma técnica também pode ser usada nas anotações:

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

A classe interna sempre deve ser acessada na forma de, em Interface.fn...vez de Class.fn..., então, você pode se livrar de um problema ambíguo.

Uma interface é usada para o polimorfismo, que se aplica a objetos, não a tipos. Portanto (como já observado), não faz sentido ter um membro de interface estática.

Java 8 Mudou o mundo, você pode ter métodos estáticos na interface, mas obriga a fornecer implementação para isso.

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

}

Combinação ilegal de modificadores: estático e abstrato

Se um membro de uma classe é declarado como estático, ele pode ser usado com seu nome de classe que é confinado a essa classe, sem criar um objeto.

Se um membro de uma classe for declarado como abstrato, você precisará declarar a classe como abstrata e fornecer a implementação do membro abstrato em sua classe herdada (Subclasse).

Você precisa fornecer uma implementação para o membro abstrato de uma classe na subclasse em que irá alterar o comportamento do método estático, também declarado como abstrato, que está confinado à classe base, o que não está correto

Como métodos estáticos não podem ser herdados. Portanto, não adianta colocá-lo na interface. Interface é basicamente um contrato que todos os seus assinantes precisam seguir. A colocação de um método estático na interface forçará os assinantes a implementá-lo. o que agora se torna contraditório com o fato de que métodos estáticos não podem ser herdados.

Com o Java 8 , as interfaces agora podem ter métodos estáticos.

Por exemplo, o Comparator possui um método estático naturalOrder ().

O requisito de que as interfaces não possam ter implementações também foi relaxado. As interfaces agora podem declarar implementações de método "padrão", que são como implementações normais, com uma exceção: se você herdar uma implementação padrão de uma interface e uma implementação normal de uma superclasse, a implementação da superclasse sempre terá prioridade.

Talvez um exemplo de código ajude, eu vou usar o C #, mas você deve acompanhar.

Vamos fingir que temos uma interface chamada IPayable

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

Agora, temos duas classes concretas que implementam essa interface:

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

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

Agora, vamos fingir que temos uma coleção de várias contas. Para isso, usaremos uma lista genérica do tipo IPayable

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

Agora, queremos pagar R $ 50,00 a todas essas contas:

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

Então agora você vê como as interfaces são incrivelmente úteis.

Eles são usados ​​apenas em objetos instanciados. Não em classes estáticas.

Se você tivesse feito o pagamento estático, ao percorrer o IPayable em accountsToPay, não haveria maneira de descobrir se ele deveria pagar pelo BusinessAcount ou CustomerAccount.