Regras de Interfaces Java
Autor: Gabriel Rubens | Publicado: 2009-10-06T23:32:00-03:00

Olá pessoal... Hoje estou aqui pra falar sobre as famosas interfaces Java!

Não interface gráfica (GUI, Swing e AWT), mas as classes 100% abstratas, que são declaradas com a palavra-chave interface.

Ainda me lembro do dia em que eu tive o meu primeiro contato com as interfaces (estudando). Eu tinha acabado de entender como funcionava a herança em Java... Tinha descoberto que boa parte dos meus problemas havia acabado naquele momento, afinal, eu tinha aprendido que poderia economizar centenas de linhas de código nos meus programinhas herdando tudo. 

Aí veio a decepção, quando eu comecei a aprender sobre as interfaces... Eu descobri que o que eu estava fazendo era herdando por preguiça, e a herança não foi feita pra isso, a herança tem que fazer sentido. Mas, isso vai ficar pra outro post, porque o assunto de hoje é sobre a prova SCJP.

Vamos ao resumo para certificação...

Declaração de InterfacesUma interface é como uma classe 100% abstrata;
 As interfaces são implicitamente abstract, colocar      esse modificador é opcional;
Uma interface só pode ser public ou default;
 Uma interface NÂO pode ter o modificador private ou      protected;
Uma interface pode estender várias interfaces (isso      mesmo, a palavra usada é extends);
Uma interface NÂO pode implementar outra interface      ou classe (parece estranho, mas uma interface estende outras interfaces);
Classes que ImplementamUma classe concreta (não abstract) que implementa uma      interface deve fornecer implementações para todos os seus métodos;
Uma classe abstract quem implementa uma interface      não é obrigada a implementar seus métodos, mas a primeira classe concreta      da arvore de herança deve implementá-los;
Uma classe que implementa uma interface não pode      declarar nenhuma exceção nova, ou mais abrangente, mas pode declarar      exceções de tempo de execução em qualquer método;
Regras dos MétodosTodos os métodos de uma interface são implicitamente      public e abstract;
E já que os métodos são abstract eles devem terminam      com ponto-e-vírgula (;);
Os métodos declarados em uma interface não podem ser      static;
Os métodos da interface não podem ser marcados com      final, native, strictfp ou synchronized;
Regras das Variáveis (Constantes)Todas as variáveis de uma interface são public,      static e final, sendo assim, todas as variáveis são constantes (toda      constante deve ser inicializada);
As declarações public, static e final são opcionais;
Como de costume, agora vamos a alguns exemplos em código:

Um ponto que pode confundir, é que uma interface estende outra, então a seguinte interface não é válida:

interface B implements A{

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // Uma interface estende outra interface

}

interface C extends A, B{

/* Como podemos ver, uma interface pode estender várias interfaces*/&nbsp;&nbsp; 

}

Como dito anteriormente, todos os método de uma interface são public e abstract implicitamente, e colocar esses modificadores fica opcional. 

Todo método que é declarado desse modo:

interface TesteInterface {

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; int getExemplo();

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; void setExemplo();

}

É lido pelo compilador assim:

interface TesteInterface {

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; public abstract int getExemplo();

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; public abstract void setExemplo();

}

Abaixo segue alguns exemplos de métodos que não são válidos:

int getExemplo(){ 

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // O método deve terminar com ponto-e-vírgula

}

static int getExemplo(){ 

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // O método não pode ser static

}

final int getExemplo(){ 

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // O método não pode ser final, native, strictfp ou synchronized

}

Todas as variáveis são constantes, então devem ser inicializadas na declaração:

interface A {

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; int TAMANHO; // Declaração inválida

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; double MEDIA = 1.5; // Declaração válida

}

Todas as variáveis são implicitamente marcadas como public, static e final, sendo assim a seguinte declaração:

int VALOR = 20;

É lido dessa maneira pelo compilador:

public static final int VALOR = 20;

Bom, os exemplos de códigos vão ficando por aqui (está tarde, eu tenho uma semana de prova, e tenho que estudar!!!)... rsrs

Esse é um tipo de assunto que vale apena entender, não só pra certificação, é importante saber como é sua utilização na prática, e qual o motivo que fez o Joshua Bloch escrever em algumas partes do seu livro Effective Java fases do tipo "Prefira composição ao invés de herança", "Prefira interfaces a classes abstratas" e "Herança quebra o encapsulamento". 

Não é difícil entender como declarar e implementar interfaces, difícil é saber qual é a hora de utilizá-la, e em que a sua utilização vai implicar no programa.

Uma ótima explicação para a utilização de interfaces está no livro Use a Cabeça! Java, em que a resposta é simples e direta, "Polimorfismo, polimorfismo, polimorfismo... As interfaces são a última palavra em flexibilidade...". Esse é um assunto que dever ser destrinchado além das explicações que são dadas no livro SCJP.

Com certeza as interfaces serão abordadas em outras postagens. 

Até breve! ; )

Gabriel Rubens