Polimorfismo en Java
Guarda objetos distintos en una variable tipada padre para que un solo nombre de llamada pueda ejecutar cuerpos distintos. Mantén horn en Machine imprimiendo tone. En Truck, reescribe horn para imprimir honk. En Car, reescribe horn para imprimir beep. En Yard.java, asigna Machine m = new Machine();, Machine t = new Truck(); y Machine c = new Car();, luego llama horn en cada una. Compila con javac Yard.java y ejecuta java Yard. La pantalla debe mostrar tone, luego honk, luego beep. Una segunda demo guarda solo los dos hijos como referencias Machine. Deja equals para la pagina siguiente — esta leccion es un tipo padre que guarda muchas formas.
Un tipo padre, tres cuerpos horn
La pagina abstract dejo un metodo incompleto para que los hijos lo llenen. Esta pagina se centra en la llamada a traves de una variable tipada padre. Abre Yard.java. Mantén el nombre de clase publica Yard. Borra demos solo-abstract si entierran la historia tipada padre, archivos enum Level sobrantes, demos de ruta y cualquier Scanner de teclado. El programa no debe esperar que escribas. No necesitas linea import.
Declara un padre normal con un cuerpo horn:
class Machine {
void horn() {
System.out.println("tone");
}
}
Declara hijos con extends Machine y sus propios cuerpos horn que imprimen honk y beep. Nombre coincidente y lista de parametros vacia significan que cada hijo sobrescribe el metodo padre.
Dentro de Yard.main, construye tres variables cuyo tipo declarado es Machine:
Machine m = new Machine();
Machine t = new Truck();
Machine c = new Car();
Luego llama:
m.horn();
t.horn();
c.horn();
El tipo declarado es Machine para las tres. El objeto real decide cual cuerpo horn se ejecuta.
class Machine {
void horn() {
System.out.println("tone");
}
}
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) {
Machine m = new Machine();
Machine t = new Truck();
Machine c = new Car();
m.horn();
t.horn();
c.horn();
}
}
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. Quita el final .java del comando de ejecucion. Mantén una clase publica en el archivo para que el nombre coincida con Yard. Los tipos auxiliares se quedan sin public en esta forma para principiantes.
La pantalla muestra tone, luego honk, luego beep. Recorre la ejecucion una vez. Java empieza en Yard.main. m guarda un Machine simple, asi que m.horn() imprime tone. t guarda un Truck aunque el tipo de variable diga Machine, asi que t.horn() imprime honk. c guarda un Car, asi que c.horn() imprime beep. Misma ortografia de llamada. Tres cuerpos.
Senala cada asignacion mientras lees la linea de pantalla que le corresponde. La primera linea pertenece a la maquina simple. La segunda linea pertenece al objeto truck detras de un nombre tipado machine. La tercera linea pertenece al objeto car detras de un nombre tipado machine. Ese juego de emparejar es toda la leccion en un pase.
Si aun ves solo honk luego park de una demo abstract, cambia al archivo de ensenanza de polimorfismo y ejecuta java Yard otra vez. Si cada variable esta tipada solo Truck o Car, aun no muestras la forma tipada padre que ensena esta pagina — mantén el tipo Machine a la izquierda de las asignaciones para la demo.
Di la regla en voz alta mientras miras la pantalla: el tipo de variable puede ser el padre, el objeto puede ser el hijo, la llamada ejecuta el cuerpo del hijo cuando el hijo sobrescribio el metodo. No inventes un override de equals en esta pagina. Ese tema espera la siguiente leccion.
Dos hijos a traves de referencias Machine
Un segundo programa mantiene los overrides. main construye solo Truck y Car, aun guardados como Machine, y llama horn en cada uno.
class Machine {
void horn() {
System.out.println("tone");
}
}
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) {
Machine t = new Truck();
Machine c = new Car();
t.horn();
c.horn();
}
}
Compila con javac Yard.java, luego ejecuta java Yard. La pantalla muestra honk, luego beep. No hay objeto Machine simple en esta segunda demo, y aun asi ambas variables siguen tipadas Machine. Los objetos hijo aportan los cuerpos. Es la misma idea de polimorfismo con pantalla mas corta.
Lee las lineas de asignacion una vez mas: izquierda Machine, derecha new Truck() o new Car(). La izquierda nombra el tipo padre por el que llamaras. La derecha nombra el objeto real. Mantén extends Machine en ambos hijos para que esas asignaciones sigan siendo legales.
Si demos abstract aun estan cerca, guardalas como historia. Para esta leccion ejecuta el archivo de ensenanza de polimorfismo para que la pantalla muestre tone / honk / beep o honk / beep, no park como historia principal. Si javac se queja de clases publicas duplicadas, mantén solo Yard publica.
Que cuerpo horn se ejecuta
📊 Who runs for each Machine variable
| Variable | Real object | horn prints |
|---|---|---|
m |
Machine |
tone |
t |
Truck |
honk |
c |
Car |
beep |
Comparado con rellenos abstract
En la pagina abstract, Machine dejo horn incompleto y los hijos lo llenaron, a menudo con un park compartido. En esta pagina, Machine ya tiene un cuerpo tone, los hijos lo sobrescriben, y variables tipadas padre guardan los objetos. Sigues compilando Yard.java y ejecutando java Yard. Los tokens nuevos son asignaciones tipadas padre como Machine t = new Truck(); y las tres impresiones distintas de un solo nombre de llamada.
Si un archivo abstract sigue abierto, puedes ver abstract void horn(); y park. Cambia al archivo de polimorfismo para que Machine tenga un cuerpo horn normal y main asigne variables Machine a objetos distintos. Mantén demos equals fuera de esta pagina. Mantén la entrada de teclado fuera de esta pagina.
Antes de equals
Puedes asignar variables Machine a objetos Machine, Truck y Car y ver tone, luego honk, luego beep. Puedes guardar solo los dos hijos como referencias Machine y ver honk luego beep. Compila Yard.java y ejecuta java Yard para cada demo que conserves, por turnos. La llamada uso el dueno del cuerpo. La pagina siguiente es equals, donde dos objetos se comparan por igualdad de forma segura para ensenar.
Mantén la demo de tres objetos para una pantalla clara de padre mas hijos. Mantén la demo de dos hijos para un par tipado padre claro. Mantén archivos equals fuera de esta pagina. Esos tres habitos son el punto de control antes de seguir. Cuando honk aparece desde una variable truck tipada Machine, el polimorfismo hizo su trabajo en esta leccion y estas listo para el siguiente tema sobre equals.
Un ultimo pase por la carpeta: un Yard publico, cuerpos horn padre e hijo, variables tipadas padre en main, sin espera de teclado, sin equals forzado. Ejecuta javac Yard.java y java Yard una vez mas en la demo abierta. Si la pantalla aun coincide con la tabla, la llamada de muchas formas esta solida y el curso puede pasar a equals 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