Clases abstractas en Java
Marca una clase padre como abstract cuando debe dejar al menos un metodo sin cuerpo para que los hijos lo llenen. Escribe abstract class Machine con abstract void horn(); y un metodo normal park que imprime park. Escribe class Truck extends Machine y dale a horn un cuerpo que imprime honk. En Yard.java, construye un Truck, llama t.horn(), luego llama t.park(). Compila con javac Yard.java y ejecuta java Yard. La pantalla debe mostrar honk, luego park. Una segunda demo añade Car para que dos hijos llenen horn de forma distinta. Deja polymorphism para la pagina siguiente — esta leccion es el metodo incompleto del padre y el hijo que lo termina.
Llena el metodo abstract en el hijo
La pagina de enums listo nombres fijos. Esta pagina deja un metodo incompleto a proposito. Abre Yard.java. Mantén el nombre de clase publica Yard. Borra demos sobrantes de enum Level si entierran la historia abstract, archivos Signal / implements, demos de ruta y cualquier Scanner de teclado. El programa no debe esperar que escribas. No necesitas linea import.
Declara el padre abstract encima de los otros tipos:
abstract class Machine {
abstract void horn();
void park() {
System.out.println("park");
}
}
El metodo abstract termina con punto y coma y no tiene cuerpo { }. El metodo normal park mantiene un cuerpo completo para que cada hijo pueda reutilizarlo.
Declara el hijo con extends Machine. Llena horn:
void horn() {
System.out.println("honk");
}
Debes llenar cada metodo abstract listado en el padre. En esta pagina eso es solo horn. No escribas new Machine() en main — una clase abstract no se construye como objeto por si sola.
Dentro de Yard.main:
Truck t = new Truck();
t.horn();
t.park();
La primera llamada ejecuta el cuerpo en Truck. La segunda llamada ejecuta el cuerpo compartido en 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();
}
}
Desde la carpeta que guarda Yard.java, ejecuta javac Yard.java. Cuando parentesis, llaves y puntos y coma coinciden, javac no escribe una linea propia. Luego ejecuta java Yard — no java Yard.java. Deja fuera la extension .java del comando de ejecucion. Mantén una clase publica en el archivo para que el nombre coincida con Yard. Los tipos auxiliares Machine y Truck se quedan sin public en esta forma para principiantes.
La pantalla muestra honk, luego park. Recorre la ejecucion una vez. Java empieza en Yard.main. new Truck() construye un truck que termino el horn abstract. t.horn() imprime honk. t.park() imprime park desde el cuerpo del padre que ya existia. El metodo incompleto vivio solo como requisito hasta que el hijo escribio el cuerpo.
Si javac rechaza, revisa tres cosas. Primero, la linea de la clase padre debe decir abstract class Machine. Segundo, el metodo incompleto debe decir abstract y terminar con ;. Tercero, Truck debe escribir de verdad horn con un cuerpo. Si aun ves MEDIUM de un archivo enum, cambia al archivo de enseñanza abstract y ejecuta java Yard otra vez. Si pruebas new Machine(), javac rechaza — eso es lo esperado en esta pagina.
Di la regla en voz alta mientras miras la pantalla: el padre abstract nombra el metodo que falta, el hijo lo llena, los metodos compartidos siguen ejecutandose. No inventes todavia un desfile largo de polymorphism con muchas variables tipadas al padre. Esa historia espera la leccion siguiente.
Dos hijos llenan horn de forma distinta
Un segundo programa mantiene la misma Machine abstract. Truck sigue imprimiendo honk. Un Car nuevo imprime beep. main construye ambos, llama cada horn, luego llama park en el 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();
}
}
Compila con javac Yard.java, luego ejecuta java Yard. La pantalla muestra honk, luego beep, luego park. Cada hijo lleno el mismo nombre abstract con su propia impresion. El cuerpo compartido park sigue viniendo de Machine. Todavia nunca escribes new Machine().
Lee el padre una vez mas: un metodo abstract, un metodo normal. Lee los hijos: cada uno escribe horn, ninguno reescribe park en esta pagina. Esa division es el punto de enseñanza. Si omites horn en Car mientras Car extends Machine, javac rechaza porque cada metodo abstract debe llenarse.
Si demos enum sobrantes siguen cerca, conservalas como historia. Para esta leccion ejecuta el archivo de enseñanza abstract para que la pantalla muestre llenados de metodo, no MEDIUM. Si javac se queja de clases publicas duplicadas, mantén solo Yard publica.
Comparado con enums e interfaces
En la pagina de enums, Level listo nombres fijos. En la pagina de interfaces, implements lleno metodos vacios de interface. En esta pagina, abstract class mas extends deja un metodo de clase incompleto hasta que un hijo escribe el cuerpo. Sigues compilando Yard.java y ejecutando java Yard. Los tokens nuevos son abstract class, abstract void horn();, y un hijo que aporta el cuerpo mientras reutiliza park.
Si un archivo enum Level sobrante sigue abierto, veras constantes y quizas un switch. Cambia al archivo abstract para que arriba se vea abstract class Machine y main construya un Truck. Mantén fuera de esta pagina demos de polymorphism que solo reordenan variables tipadas al padre. Mantén fuera de esta pagina la entrada de teclado.
Que deja esta pagina para polymorphism
Esta pagina termina metodos abstract en hijos concretos. La pagina siguiente muestra polymorphism, donde una variable tipada al padre puede guardar distintos objetos hijo y llamar el cuerpo de metodo que corresponde. Quedate aqui con padres abstract e hijos llenos. Aun no exijas una lista de variables Machine que apunten a muchos hijos.
Cuando mas tarde escribas demos de polymorphism, a menudo empezaras todavia desde un nombre de metodo padre abstract u ordinario. Trata esta pagina como la mitad del metodo incompleto de esa historia vecina. Termina ambas demos Yard hasta que honk luego park — y luego honk, beep, park — se sientan automaticos antes de abrir la leccion de polymorphism.
Antes de polymorphism
Puedes declarar abstract class Machine, llenar horn en Truck y ver honk luego park. Puedes añadir Car con su propio horn y ver honk, luego beep, luego park. Compila Yard.java y ejecuta java Yard para cada demo que conserves, por turnos. El hijo termino el metodo abstract. La pagina siguiente es polymorphism, donde las llamadas a traves de una referencia tipada al padre eligen el cuerpo del hijo.
Conserva la demo de un solo truck para un llenado abstract claro mas park compartido. Conserva la demo de dos hijos para un par claro de llenados. Mantén fuera de esta pagina los archivos de desfile de polymorphism. Esos tres habitos son el punto de control antes de avanzar. Cuando honk aparece antes de park tras new Truck(), las clases abstract hicieron su trabajo para esta leccion y estas listo para el tema siguiente sobre polymorphism.
Un ultimo pase por la carpeta: un Yard publico, un Machine abstract, hijos concretos que llenan horn, sin new Machine(), sin espera de teclado. Ejecuta javac Yard.java y java Yard una vez mas en la demo que dejas abierta. Si la pantalla sigue imprimiendo los llenados que escribiste, el contrato abstract es solido y el curso puede pasar a polymorphism en la pagina siguiente.
🧠 Pon a Prueba tu Conocimiento
Pon a Prueba tu Conocimiento
Ponte a prueba con este cuestionario interactivo y descubre qué tan bien entiendes el tema
📝 Instrucciones
- Lee cada pregunta cuidadosamente
- Selecciona la mejor respuesta para cada pregunta
- Puedes repetir el quiz tantas veces como quieras
- Tu progreso se mostrará en la parte superior