Interface (Java) - Interface (Java)

Uma interface na linguagem de programação Java é um tipo abstrato usado para especificar um comportamento que as classes devem implementar. Eles são semelhantes aos protocolos . As interfaces são declaradas usando a interface palavra - chave e podem conter apenas assinatura de método e declarações de constantes (declarações de variáveis ​​que são declaradas como statice final). Todos os métodos de uma interface não contêm implementação (corpos de método) em todas as versões abaixo Java 8. Começando com Java 8, defaulte staticmétodos podem ter aplicação na interfacedefinição. Então, em Java 9, privatee private staticmétodos foram adicionados. Atualmente, uma interface Java pode ter até seis tipos diferentes.

As interfaces não podem ser instanciadas , mas sim implementadas. Uma classe que implementa uma interface deve implementar todos os métodos não padrão descritos na interface ou ser uma classe abstrata . As referências de objeto em Java podem ser especificadas para ser de um tipo de interface; em cada caso, eles devem ser nulos ou estar vinculados a um objeto que implementa a interface.

Um benefício de usar interfaces é que elas simulam herança múltipla . Todas as classes em Java devem ter exatamente uma classe base , sendo a única exceção java.lang.Object(a classe raiz do sistema de tipo Java ); herança múltipla de classes não é permitida. No entanto, uma interface pode herdar várias interfaces e uma classe pode implementar várias interfaces.

Visão geral

As interfaces são usadas para codificar semelhanças que as classes de vários tipos compartilham, mas não constituem necessariamente um relacionamento de classe. Por exemplo, um humano e um papagaio podem assobiar ; entretanto, não faria sentido representar Humans e Parrots como subclasses de uma Whistlerclasse. Em vez disso, provavelmente seriam subclasses de uma Animalclasse (provavelmente com classes intermediárias), mas ambas implementariam a Whistlerinterface.

Outro uso de interfaces é poder usar um objeto sem saber seu tipo de classe, mas apenas que implementa uma determinada interface. Por exemplo, se alguém se incomoda com um assobio, pode não saber se é um humano ou um papagaio, porque tudo o que se pode determinar é que um assobiador está assobiando. A chamada whistler.whistle()irá chamar o método implementado whistledo objeto, whistlernão importa a classe que ele tenha, desde que implemente Whistler. Em um exemplo mais prático, um algoritmo de classificação pode esperar um objeto do tipo Comparable. Assim, sem conhecer o tipo específico, ele sabe que objetos desse tipo podem ser classificados de alguma forma.

Por exemplo:

interface Bounceable {
    double pi = 3.1415;
    void setBounce();  // Note the semicolon
                       // Interface methods are public, abstract and never final.
                       // Think of them as prototypes only; no implementations are allowed.
}

Uma interface:

  • declara apenas cabeçalhos de método e constantes públicas.
  • não pode ser instanciado.
  • pode ser implementado por uma classe.
  • não pode estender uma classe.
  • pode estender várias outras interfaces.

Uso

Definindo uma interface

As interfaces são definidas com a seguinte sintaxe (compare com a definição de classe do Java ):

[visibility] interface InterfaceName [extends other interfaces] {
        constant declarations
        abstract method declarations
}

Exemplo: interface pública Interface1 estende Interface2;

O corpo da interface contém métodos abstratos , mas como todos os métodos em uma interface são, por definição, abstratos, a abstractpalavra-chave não é necessária. Como a interface especifica um conjunto de comportamentos expostos, todos os métodos são implicitamente public.

Assim, uma interface simples pode ser

public interface Predator {
    boolean chasePrey(Prey p);
    void eatPrey(Prey p);
}

As declarações de tipo de membro em uma interface são implicitamente estáticas, finais e públicas, mas, caso contrário, podem ser qualquer tipo de classe ou interface.

Implementando interfaces em uma classe

A sintaxe para implementar uma interface usa esta fórmula:

... implements InterfaceName[, another interface, another, ...] ...

As classes podem implementar uma interface. Por exemplo:

public class Lion implements Predator {

    @Override
    public boolean chasePrey(Prey p) {
           // Programming to chase prey p (specifically for a lion)
    }

    @Override
    public void eatPrey(Prey p) {
           // Programming to eat prey p (specifically for a lion)
    }
}

Se uma classe implementa uma interface e não implementa todos os seus métodos, ela deve ser marcada como abstract. Se uma classe é abstrata, espera-se que uma de suas subclasses implemente seus métodos não implementados, embora se qualquer uma das subclasses da classe abstrata não implementar todos os métodos de interface, a própria subclasse deve ser marcada novamente como abstract.

As classes podem implementar várias interfaces:

public class Frog implements Predator, Prey { ... }

As interfaces podem compartilhar métodos de classe comuns:

class Animal implements LikesFood, LikesWater {
    boolean likes() { return true; }
}

No entanto, uma determinada classe não pode implementar a mesma interface ou uma interface semelhante várias vezes:

class Animal implements Shares<Boolean>, Shares<Integer> ...
// Error: repeated interface

As interfaces são comumente usadas na linguagem Java para callbacks , já que o Java não permite a herança múltipla de classes, nem permite a passagem de métodos (procedimentos) como argumentos. Portanto, a fim de passar um método como um parâmetro para um método alvo, a prática atual é definir e passar uma referência a uma interface como um meio de fornecer a assinatura e o endereço do método de parâmetro para o método alvo em vez de definir várias variantes do método de destino para acomodar cada classe de chamada possível.

Subinterfaces

As interfaces podem estender várias outras interfaces, usando a mesma fórmula descrita abaixo. Por exemplo,

public interface VenomousPredator extends Predator, Venomous {
    // Interface body
}

é legal e define uma subinterface. Ele permite herança múltipla, ao contrário de classes. Predatore Venomouspode definir ou herdar métodos com a mesma assinatura, digamos kill(Prey p). Quando uma classe implementa, VenomousPredatorela implementa os dois métodos simultaneamente.

Exemplos

Algumas interfaces Java comuns são:

  • Comparabletem o método compareTo, que é usado para descrever dois objetos como iguais ou para indicar que um é maior do que o outro. Os genéricos permitem a implementação de classes para especificar quais instâncias de classe podem ser comparadas a elas.
  • Serializableé uma interface de marcador sem métodos ou campos - tem um corpo vazio. É usado para indicar que uma classe pode ser serializada . Seu Javadoc descreve como ele deve funcionar, embora nada seja imposto de maneira programática

Veja também

Referências

links externos