Interface abstrata Java

Considere um exemplo (que compila em java)

public abstract interface Interface {
    public void interfacing();
    public abstract boolean interfacing(boolean really);
}

Por que é necessário que uma interface seja "declarada" abstrata? Existem outras regras que se aplicam a uma interface abstrata?

Finalmente: se abstractestá obsoleto, por que está incluído no Java? Existe um histórico para a interface abstrata?

Por que é necessário que uma interface seja "declarada" abstrata?

Não é.

public abstract interface Interface {
       \___.__/
           |
           '----> Neither this...

    public void interfacing();
    public abstract boolean interfacing(boolean really);
           \___.__/
               |
               '----> nor this, are necessary.
}

As interfaces e seus métodos são implicitamente abstracte adicionar esse modificador não faz diferença.

Existem outras regras que se aplicam a uma interface abstrata?

Não, as mesmas regras se aplicam. O método deve ser implementado por qualquer classe de implementação (concreta).

Se o resumo é obsoleto, por que ele está incluído no Java? Existe um histórico para a interface abstrata?

Pergunta interessante. Desenterrei a primeira edição do JLS e, mesmo lá, ele diz "Este modificador é obsoleto e não deve ser usado em novos programas Java" .

Ok, cavando ainda mais ... Depois de acessar vários links quebrados, consegui encontrar uma cópia da Especificação Oak 0.2 original (ou "manual"). Leitura bastante interessante, devo dizer, e apenas 38 páginas no total! :-)

Na Seção 5, Interfaces, fornece o seguinte exemplo:

public interface Storing {
    void freezeDry(Stream s) = 0;
    void reconstitute(Stream s) = 0;
}

E na margem diz

No futuro, a parte "= 0" dos métodos de declaração nas interfaces poderá desaparecer.

Supondo que =0foi substituído pela abstractpalavra - chave, suspeito que abstractem algum momento era obrigatório para os métodos de interface!

Artigo relacionado: Java: interfaces abstratas e métodos de interface abstrata

Não é necessário, é opcional, assim como publicnos métodos de interface.

Veja o JLS sobre isso:

http://java.sun.com/docs/books/jls/second_edition/html/interfaces.doc.html

9.1.1.1 Interfaces abstratas Toda interface é implicitamente abstrata. Este modificador é obsoleto e não deve ser usado em novos programas.

E

9.4 Declarações de métodos abstratos

[...]

Para compatibilidade com versões mais antigas da plataforma Java, é permitido, mas desanimado, por uma questão de estilo, especificar de forma redundante o modificador abstrato para métodos declarados nas interfaces.

É permitido, mas fortemente desencorajado por uma questão de estilo, especificar de forma redundante o modificador público para métodos de interface.

Não é necessário declarar a interface abstrata.

Assim como declarar todos esses métodos públicos (que já são, se a interface for pública) ou abstratos (que já estão em uma interface) são redundantes.

Ninguém está parando você, no entanto.

Outras coisas que você pode declarar explicitamente, mas não precisa:

• chame super () na primeira linha de um construtor
• extends Object
• implementar interfaces herdadas

Existem outras regras que se aplicam a uma interface abstrata?

Uma interface já é "abstrata". A aplicação dessa palavra-chave novamente não faz absolutamente nenhuma diferença.

Esteja ciente de que na primavera tem um significado não acadêmico. A interface abstrata é um aviso para o desenvolvedor não usá-la @Autowired. Espero que a primavera / eclipse @Autowiredanalise esse atributo e avise / falhe sobre o uso de tais atributos.

Um exemplo real: o proxy @Service em @Transnational para um @Repository precisa usar os mesmos métodos básicos, no entanto, eles devem usar interfaces diferentes que estendem essa interface abstrata devido a @Autowired. (Eu chamo essa interface de XXXSpec)

Toda interface é implicitamente abstrata.
Este modificador é obsoleto e não deve ser usado em novos programas.

[A especificação da linguagem Java - 9.1.1.1 abstractinterfaces]

Observe também que os métodos dos membros da interface são implicitamente public abstract.
[A especificação da linguagem Java - 9.2 membros da interface]

Por que esses modificadores estão implícitos? Não há outro modificador (nem mesmo o modificador ' no modifier ') que seria útil aqui, portanto você não precisa digitá-lo explicitamente.

Não é necessário. É uma peculiaridade da linguagem.

Não é necessário, pois as interfaces são abstratas por padrão, pois todos os métodos em uma interface são abstratos.

Uma interface abstrata não é tão redundante quanto todo mundo parece dizer, pelo menos em teoria.

Uma interface pode ser estendida, assim como uma classe. Se você projetar uma hierarquia de interfaces para o seu aplicativo, poderá ter uma interface 'base', ampliando outras interfaces, mas não quer como um objeto em si.

Exemplo:

public abstract interface MyBaseInterface {
    public String getName();
}

public interface MyBoat extends MyBaseInterface {
    public String getMastSize();
}

public interface MyDog extends MyBaseInterface {
    public long tinsOfFoodPerDay();
}

Você não deseja que uma classe implemente o MyBaseInterface, apenas os outros dois, MMyDog e MyBoat, mas ambas as interfaces compartilham a interface MyBaseInterface, portanto, tenha uma propriedade 'name'.

Eu sei que é meio acadêmico, mas achei que alguns poderiam achar interessante. :-)

É realmente apenas um 'marcador', neste caso, para sinalizar aos implementadores da interface que não foram projetados para serem implementados por conta própria. Devo apontar que um compilador (pelo menos o sun / ora 1.6 com o qual tentei) compila uma classe que implementa uma interface abstrata.

O poço 'Abstract Interface' é uma construção Lexical: http://en.wikipedia.org/wiki/Lexical_analysis .

É exigido pelo compilador, você também pode escrever interface.

Bem, não se preocupe muito com a construção lexical da linguagem, pois eles podem tê-la colocado para resolver alguma ambiguidade de compilação que é denominada casos especiais durante o processo de compilação ou, para alguma compatibilidade com versões anteriores, tente se concentrar na construção lexical principal.

A essência da `interface é capturar algum conceito abstrato (idéia / pensamento / pensamento de ordem superior etc.) cuja implementação pode variar ... ou seja, pode haver uma implementação múltipla.

Uma interface é um tipo de dados abstrato puro que representa os recursos do objeto que está capturando ou representando.

Os recursos podem ser representados pelo espaço ou pelo tempo. Quando eles são representados pelo espaço (armazenamento em memória), significa que sua classe concreta implementará um campo e método / métodos que operarão nesse campo ou no tempo, o que significa que a tarefa de implementar o recurso é puramente computacional (requer mais relógios da CPU para processamento), para que você tenha uma troca entre espaço e tempo para a implementação do recurso.

Se sua classe concreta não implementar todos os recursos, ela se tornará novamente abstrata porque você implementou seu pensamento, ideia ou abstração, mas não está completa, especifique-a por abstractclasse.

Uma classe concreta será uma classe / conjunto de classes que capturará completamente a abstração que você está tentando capturar na classe XYZ.

Então o padrão é

Interface--->Abstract class/Abstract classes(depends)-->Concrete class