Interfaces em Java

Declare um interface com cabecalhos de metodo vazios, depois preencha esses metodos numa classe com implements. Escreva interface Signal com void horn(); e sem corpo. Escreva class Truck implements Signal e de a horn um corpo que imprime honk. Em Yard.java, construa um Truck e chame t.horn(). Compile com javac Yard.java e rode java Yard. A tela deve mostrar honk. Uma segunda demo deixa uma classe implements dois interfaces de uma vez. Deixe enums para a pagina seguinte — esta licao e a promessa de um metodo e a classe que a cumpre.

Implemente um metodo de interface

A pagina de override reescreveu horn num filho que ja tinha extends Car. Esta pagina comeca de uma promessa sem corpo. Abra Yard.java. Mantenha o nome da classe publica Yard. Apague demos sobrando de Car/Truck com extends se enterrarem a historia da interface, impressoes de construtor com super, demos de caminho, e qualquer Scanner de teclado. O programa nao deve esperar digitacao. Nenhuma linha import e necessaria.
Declare a interface acima das classes:
interface Signal {
void horn();
}
O cabecalho termina com ponto e virgula. Nao ha corpo { } para horn dentro da interface nesta forma iniciante.
Declare a classe que cumpre a promessa:
class Truck implements Signal {
Dentro de Truck, escreva um metodo public com o mesmo nome e preencha o corpo:
public void horn() {
System.out.println("honk");
}
A palavra-chave e implements, nao extends. A classe deve fornecer um corpo para cada metodo listado na interface. Nesta pagina isso e so horn.
Dentro de Yard.main, construa um truck e chame o metodo:
Truck t = new Truck();
t.horn();
A chamada roda o corpo escrito em Truck, entao a tela imprime honk.

Da pasta que guarda Yard.java, rode javac Yard.java. Quando parenteses, chaves e ponto e virgula batem, javac nao escreve linha propria. Depois rode java Yard — nao java Yard.java. Tire o sufixo .java do comando de execucao. Mantenha uma classe publica no arquivo para o nome coincidir com Yard. A interface Signal e a classe auxiliar Truck ficam sem public nesta forma iniciante.
A tela mostra honk. Percorra a execucao uma vez. Java comeca em Yard.main. new Truck() constroi um truck que prometeu Signal. t.horn() roda o corpo em Truck e imprime honk. Voce nunca escreve new Signal() — a interface nomeia os metodos; a classe fornece os corpos e o objeto.
Se javac recusar, confira tres coisas. Primeiro, a linha da classe deve dizer implements Signal, nao extends Signal. Segundo, cada metodo da interface precisa de um metodo correspondente na classe. Terceiro, o metodo de implementacao e public nesta forma didatica para bater com o contrato publico da interface. Se voce ainda ve beep de um arquivo antigo de override, mude para o arquivo didatico de interface e rode java Yard de novo.
Diga a regra em voz alta enquanto olha a tela: interface nomeia a chamada, classe preenche o corpo, objeto roda aquele corpo. Mantenha implements na classe que possui a impressao. Nao invente um enum nesta pagina. Enums esperam a licao seguinte.

Implemente dois interfaces numa classe

Um segundo programa mantem Yard e Truck. Agora Truck implementa dois interfaces. Signal ainda pede horn. Mark pede show. A classe preenche os dois corpos. main chama os dois metodos.

Compile com javac Yard.java, depois rode java Yard. A tela mostra honk, depois truck. A primeira linha vem da promessa Signal preenchida em Truck. A segunda linha vem da promessa Mark preenchida na mesma classe. Separe os nomes de interface com virgula na lista implements: implements Signal, Mark.
Leia o cabecalho da classe mais uma vez. Uma classe. Dois interfaces. Dois corpos de metodo. Essa e a imagem iniciante de cumprir mais de uma promessa sem usar dois pais extends. Java deixa uma classe estender so uma classe; ela pode implementar varios interfaces. Esta pagina mostra essa lista com virgula num arquivo Yard pequeno.
Se voce omitir show enquanto Mark esta na lista, javac recusa porque cada metodo de interface listado precisa de um corpo. Se voce omitir Mark da lista implements mas ainda escrever show, voce tem um metodo comum, nao o cumprimento da interface para Mark. Mantenha os dois nomes na linha da classe quando quiser que as duas promessas sejam checadas.

Comparado com override via extends

Na pagina de override, Truck extends Car e reescreveu horn que ja tinha corpo no pai. Nesta pagina, Signal comeca sem corpo, e Truck implements Signal fornece o primeiro corpo. Voce ainda compila Yard.java e roda java Yard. Voce ainda chama t.horn(). Os tokens novos sao interface, implements, e — na segunda demo — uma lista implements separada por virgula.
Se um arquivo de override sobrando ainda estiver aberto, voce vera extends Car e talvez beep ao lado de honk. Mude para o arquivo didatico de interface para o topo do arquivo mostrar interface Signal e a linha da classe mostrar implements. Mantenha demos de enum fora desta pagina. Mantenha entrada de teclado fora desta pagina.

O que isto deixa para enums

Esta pagina preenche metodos de interface com implements. A pagina seguinte mostra enums, onde um tipo lista um conjunto fixo de valores nomeados. Fique com as promessas de interface aqui. Nao substitua as demos de hoje por uma lista enum como requisito ainda.
Quando depois voce usar enums, ainda pode implementar interfaces em outros tipos no mesmo programa. Trate esta pagina como a metade de interface dessa historia vizinha. Termine as duas demos Yard ate honk — e depois honk mais truck — parecerem automaticos antes de abrir a licao de enums.

Antes dos enums

Voce pode escrever interface Signal com horn() vazio, implementa-lo em Truck, e ver honk de t.horn(). Voce pode implementar Signal e Mark numa classe e ver honk depois truck. Compile Yard.java e rode java Yard para cada demo mantida por vez. A classe cumpriu as promessas da interface. A pagina seguinte e enums, onde um tipo lista nomes fixos.
Mantenha a demo de um so interface com honk para uma historia clara de implements. Mantenha a demo de dois interfaces para uma lista clara com virgula. Mantenha arquivos enum fora desta pagina. Esses tres habitos sao o ponto de checagem antes de seguir. Quando honk aparece depois de t.horn() — e quando a segunda demo tambem imprime truck depois de show() — interfaces fizeram o trabalho desta licao e voce esta pronto para o proximo topico sobre enums.
Uma ultima passagem pela pasta: um Yard publico, cabecalhos de interface com metodos vazios, uma classe que os implements, sem espera de teclado, sem enum forcado. Rode javac Yard.java e java Yard mais uma vez na demo que voce mantem aberta. Se a tela ainda imprime os preenchimentos de interface que voce escreveu, as promessas estao solidas e o curso pode ir para enums na pagina seguinte.