Interfaces

###### << Anterior - Home - Próxima >>

O Java e a maioria das linguagens orientadas a objeto, não permitem herança múltipla, ou seja, cada classe só pode herdar diretamente de uma única classe. O mecanismo de herança só pode ser usado uma única vez em cada classe. Entretanto, o java fornece a opção de implementar interfaces, quantas forem necessárias, o que na maioria das vezes resolve essa limitação. Uma interface é uma estrutura que lembra uma classe, podendo ter métodos e atributos, mas que não implementa nada realmente, não tem nenhum código, então está muito longe de ser uma classe. Os métodos em uma interface são sempre abstratos e públicos. Pode ter atributos, mas serão sempre públicos, estáticos e finais (não podem ter seu valor modificado, ou seja, são constantes).
Assim como as classes abstratas, a função das interfaces é criar uma linguagem padrão de comunicação com as classes, definindo métodos que serão implementados nas classes. A diferença é que a interface não usa o mecanismo de herança das classes, portanto uma classe pode herdar de outra classe e também implementar uma ou mais interfaces.
O uso de interfaces permite também a subtipagem de classes. Assim como uma classe descendente é um subtipo da classe ancestral, a classe que implementa uma interface se torna um subtipo dela. Isso significa que um objeto criado a partir de uma classe que implementa determinada interface é considerado uma instância desta interface (além de continuar sendo uma instância da classe).
A grande vantagem de usar interfaces é que uma classe pode ter acesso e usar outras classes que não são conhecidas por ela. Como isso é possível? Como dito antes, quando uma classe implementa uma interface, se torna um subtipo dela. Então é possível que um método receba um objeto de uma classe desconhecida, mas se a classe desse objeto implementa uma interface conhecida, o método pode identificar a interface através do operador **instanceOf** e utilizar os métodos da interface que estão no objeto. Isso é extremamente útil para fazer a integração de sistemas diferentes, ou para criar sistemas que podem ser facilmente expandidos com novos módulos.

**IMPORTANTE: uma interface não tem construtores.**

Sintaxe:

```
public interface NomeInterface {
 <Lista de atributos estáticos>
 <Lista de métodos abstratos>
}

```

Exemplo de declaração de interface:

```
interface NomeInterface{
 int Atrib = 10; //este atributo é público, estático e final
 void Metodo1(); //Estes métodos são abstratos e públicos
 double Metodo2();
 int Metodo3();
}

```

Associação com classe e implementação:

```
public class NomeClasse extends Ancestral implements NomeInterface{
 // atributos
 // construtores
 // outros métodos

 @Override
 public void Metodo1(){
 //código do método 1
 }

 @Override
 public double Metodo2(){
 //código do método 2
 }

 @Override
 public int Metodo3(){
 //código do método 3
 }
}

```

Se uma classe precisa implementar duas ou mais interfaces, basta separar por vírgulas na declaração da classe:

```
public class NomeClasse implements Interface1, Interface2{
 ...
}

```

**Herança**O mecanismo de herança também pode ser utilizado com interfaces. Uma interface pode herdar de outra interface. Nesse caso a interface descendente irá conter todos os atributos e métodos declarados na interface ancestral.