Classes abstratas em Java
Marque uma classe pai como abstract quando ela deve deixar pelo menos um metodo sem corpo para os filhos preencherem. Escreva abstract class Machine com abstract void horn(); e um metodo normal park que imprime park. Escreva class Truck extends Machine e de a horn um corpo que imprime honk. Em Yard.java, construa um Truck, chame t.horn(), depois chame t.park(). Compile com javac Yard.java e rode java Yard. A tela deve mostrar honk, depois park. Uma segunda demo adiciona Car para dois filhos preencherem horn de formas diferentes. Deixe polymorphism para a pagina seguinte — esta licao e o metodo inacabado do pai e o filho que o termina.
Preencha o metodo abstract no filho
A pagina de enums listou nomes fixos. Esta pagina deixa um metodo inacabado de proposito. Abra Yard.java. Mantenha o nome da classe publica Yard. Apague demos sobrando de enum Level se enterrarem a historia abstract, arquivos Signal / implements, demos de caminho, e qualquer Scanner de teclado. O programa nao deve esperar digitacao. Nenhuma linha import e necessaria.
Declare o pai abstract acima dos outros tipos:
abstract class Machine {
abstract void horn();
void park() {
System.out.println("park");
}
}
O metodo abstract termina com ponto e virgula e nao tem corpo { }. O metodo normal park guarda um corpo completo para todo filho reutilizar.
Declare o filho com extends Machine. Preencha horn:
void horn() {
System.out.println("honk");
}
Voce deve preencher todo metodo abstract listado no pai. Nesta pagina so ha horn. Nao escreva new Machine() em main — uma classe abstract nao e construida como objeto sozinha.
Dentro de Yard.main:
Truck t = new Truck();
t.horn();
t.park();
A primeira chamada roda o corpo em Truck. A segunda chamada roda o corpo compartilhado em Machine.
abstract class Machine {
abstract void horn();
void park() {
System.out.println("park");
}
}
class Truck extends Machine {
void horn() {
System.out.println("honk");
}
}
public class Yard {
public static void main(String[] args) {
Truck t = new Truck();
t.horn();
t.park();
}
}
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. Os tipos auxiliares Machine e Truck ficam sem public nesta forma iniciante.
A tela mostra honk, depois park. Percorra a execucao uma vez. Java comeca em Yard.main. new Truck() constroi um truck que terminou o horn abstract. t.horn() imprime honk. t.park() imprime park do corpo do pai que ja existia. O metodo inacabado viveu so como exigencia ate o filho escrever o corpo.
Se javac recusar, confira tres coisas. Primeiro, a linha da classe pai deve dizer abstract class Machine. Segundo, o metodo inacabado deve dizer abstract e terminar com ;. Terceiro, Truck deve de fato escrever horn com corpo. Se ainda vir MEDIUM de um arquivo enum, mude para o arquivo didatico abstract e rode java Yard de novo. Se tentar new Machine(), javac recusa — isso e esperado nesta pagina.
Diga a regra em voz alta enquanto olha a tela: o pai abstract nomeia o metodo faltando, o filho preenche, metodos compartilhados ainda rodam. Nao invente ainda um desfile longo de polymorphism com muitas variaveis tipadas no pai. Essa historia espera a licao seguinte.
Dois filhos preenchem horn de formas diferentes
Um segundo programa mantem o mesmo Machine abstract. Truck ainda imprime honk. Um Car novo imprime beep. main constroi os dois, chama cada horn, depois chama park no truck.
abstract class Machine {
abstract void horn();
void park() {
System.out.println("park");
}
}
class Truck extends Machine {
void horn() {
System.out.println("honk");
}
}
class Car extends Machine {
void horn() {
System.out.println("beep");
}
}
public class Yard {
public static void main(String[] args) {
Truck t = new Truck();
Car c = new Car();
t.horn();
c.horn();
t.park();
}
}
Compile com javac Yard.java, depois rode java Yard. A tela mostra honk, depois beep, depois park. Cada filho preencheu o mesmo nome abstract com a propria impressao. O corpo compartilhado de park ainda vem de Machine. Voce ainda nunca escreve new Machine().
Leia o pai outra vez: um metodo abstract, um metodo normal. Leia os filhos: cada um escreve horn, nenhum reescreve park nesta pagina. Essa divisao e o ponto didatico. Se omitir horn em Car enquanto Car extends Machine, javac recusa porque todo metodo abstract deve ser preenchido.
Se demos enum ainda ficarem por perto, mantenha-as como historia. Para esta licao rode o arquivo didatico abstract para a tela mostrar preenchimentos de metodo, nao MEDIUM. Se javac reclamar de classes publicas duplicadas, mantenha so Yard public.
Comparado com enums e interfaces
Na pagina de enums, Level listou nomes fixos. Na pagina de interfaces, implements preencheu metodos vazios de interface. Nesta pagina, abstract class mais extends deixa um metodo de classe inacabado ate um filho escrever o corpo. Voce ainda compila Yard.java e roda java Yard. Os tokens novos sao abstract class, abstract void horn();, e um filho que fornece o corpo enquanto reutiliza park.
Se um arquivo enum Level sobrando ainda estiver aberto, voce vera constantes e talvez um switch. Mude para o arquivo abstract para o topo mostrar abstract class Machine e main construir um Truck. Mantenha demos de polymorphism que so embaralham variaveis tipadas no pai fora desta pagina. Mantenha entrada de teclado fora desta pagina.
O que isto deixa para polymorphism
Esta pagina termina metodos abstract em filhos concretos. A pagina seguinte mostra polymorphism, onde uma variavel tipada no pai pode guardar objetos filhos diferentes e chamar o corpo correspondente. Fique com pais abstract e filhos preenchidos aqui. Ainda nao exija uma lista de variaveis Machine que apontam para muitos filhos.
Quando depois escrever demos de polymorphism, voce ainda costuma comecar de um nome de metodo abstract ou comum no pai. Trate esta pagina como a metade do metodo inacabado daquela historia vizinha. Termine as duas demos Yard ate honk depois park — e depois honk, beep, park — parecerem automaticas antes de abrir a licao de polymorphism.
Antes de polymorphism
Voce pode declarar abstract class Machine, preencher horn em Truck, e ver honk depois park. Voce pode adicionar Car com seu proprio horn e ver honk, depois beep, depois park. Compile Yard.java e rode java Yard para cada demo mantida. O filho terminou o metodo abstract. A pagina seguinte e polymorphism, onde chamadas por uma referencia tipada no pai escolhem o corpo do filho.
Mantenha a demo de um so truck para um preenchimento abstract claro mais park compartilhado. Mantenha a demo de dois filhos para um par claro de preenchimentos. Mantenha arquivos de desfile polymorphism fora desta pagina. Esses tres habitos sao o checkpoint antes de seguir. Quando honk aparece antes de park apos new Truck(), classes abstract fizeram o trabalho desta licao e voce esta pronto para o proximo topico sobre polymorphism.
Uma ultima passagem pela pasta: um Yard public, um Machine abstract, filhos concretos que preenchem horn, sem new Machine(), sem espera de teclado. Rode javac Yard.java e java Yard mais uma vez na demo que voce mantem aberta. Se a tela ainda imprimir os preenchimentos que voce escreveu, o contrato abstract esta solido e o curso pode ir para polymorphism na pagina seguinte.
🧠 Teste Seu Conhecimento
Teste Seu Conhecimento
Desafie-se com este questionário interativo e veja o quão bem você entende o tópico
📝 Instruções
- Leia cada pergunta cuidadosamente
- Selecione a melhor resposta para cada pergunta
- Você pode refazer o quiz quantas vezes quiser
- Seu progresso será mostrado no topo