Sobrescritura en Java
Reescribe un metodo padre en el hijo para que la llamada use el cuerpo del hijo. Mantén Truck extends Car. En Car, mantén horn imprimiendo beep. En Truck, escribe horn otra vez para que imprima honk. En Yard.java, construye un Truck y llama t.horn(). Compila con javac Yard.java y ejecuta java Yard. La pantalla debe mostrar honk. Una segunda demo tambien construye un Car simple para que oigas beep del padre y honk del hijo. Deja las interfaces para la pagina siguiente — esta leccion es un nombre de metodo con dos cuerpos.
Reescribe horn en el hijo
La pagina de herencia dejo Truck vacio para que t.horn() mantuviera el beep del padre. La pagina de super ejecuto constructores con super. Esta pagina cambia el cuerpo del metodo en el hijo. Abre Yard.java. Mantén el nombre de clase publica Yard. Borra impresiones solo-constructor de car y truck si entierran la historia del metodo, demos de ruta sobrantes, escritores Store y cualquier Scanner de teclado. El programa no debe esperar que escribas. No necesitas linea import.
Declara el padre con un metodo de instancia que imprima beep:
class Car {
void horn() {
System.out.println("beep");
}
}
Declara el hijo con extends Car. Dentro de Truck, escribe el mismo nombre de metodo otra vez, pero imprime honk:
void horn() {
System.out.println("honk");
}
Nombre coincidente y lista vacia de parametros coincidente significan que la version hija reemplaza la version padre para objetos Truck. No estas anadiendo un segundo metodo sin relacion. Estas sobrescribiendo horn.
Dentro de Yard.main construye un truck y llama el metodo:
Truck t = new Truck();
t.horn();
La llamada ejecuta el cuerpo escrito en Truck, asi que la pantalla imprime honk.
class Car {
void horn() {
System.out.println("beep");
}
}
class Truck extends Car {
void horn() {
System.out.println("honk");
}
}
public class Yard {
public static void main(String[] args) {
Truck t = new Truck();
t.horn();
}
}
Desde la carpeta que guarda Yard.java, ejecuta javac Yard.java. Cuando parenesis, 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 sola clase publica en el archivo para que el nombre coincida con Yard. Los tipos auxiliares Car y Truck se quedan sin public en esta forma para principiantes.
La pantalla muestra honk. Recorre la ejecucion una vez. Java empieza en Yard.main. new Truck() construye un truck. t.horn() mira el tipo real de t. Porque Truck escribio su propio horn, ese cuerpo hijo corre e imprime honk. El cuerpo beep del padre permanece en Car y no se usa para esta llamada de truck.
Si aun ves beep, comprueba si Truck contiene de verdad un metodo horn. Un Truck vacio de la pagina de herencia sigue heredando beep. La sobrescritura exige que el metodo hijo este presente con el mismo nombre. Si aun ves car luego truck de una demo de constructor, cambia al archivo didactico de sobrescritura y ejecuta java Yard otra vez.
Di la regla en voz alta mientras miras la pantalla: mismo nombre de metodo en el hijo, el cuerpo hijo gana para ese objeto. Mantén extends Car para que Truck siga siendo un tipo de Car. Sin extends, un horn en Truck seria una historia de tipo separada, no una sobrescritura del metodo padre.
No inventes un archivo interface en esta pagina. Las interfaces esperan la siguiente leccion. Hoy una jerarquia de clases lleva dos cuerpos horn, y el cuerpo hijo responde a la llamada en un truck.
beep del padre y honk del hijo lado a lado
Un segundo programa mantiene la sobrescritura. main construye un Car y un Truck, luego llama horn en cada uno. El padre sigue imprimiendo beep. El hijo sigue imprimiendo honk.
class Car {
void horn() {
System.out.println("beep");
}
}
class Truck extends Car {
void horn() {
System.out.println("honk");
}
}
public class Yard {
public static void main(String[] args) {
Car c = new Car();
Truck t = new Truck();
c.horn();
t.horn();
}
}
Compila con javac Yard.java, luego ejecuta java Yard. La pantalla muestra beep, luego honk. La primera linea viene del objeto Car. La segunda linea viene del objeto Truck. La sobrescritura en el hijo no borra el metodo padre para objetos padre. Cada objeto usa el cuerpo que pertenece a su propio tipo.
Lee los dos metodos horn otra vez. Mismo nombre. Misma lista vacia de parametros. Texto de impresion distinto. Esa igualdad de firma es lo que hace de la version hija una sobrescritura en vez de un metodo nuevo sin relacion. Si renombras el metodo hijo a otra cosa, la herencia volveria a mantener beep en trucks, y ya no estarias ensenando sobrescritura.
Si demos de constructor con super() aun estan en la carpeta, guardalas como historia. Para esta leccion ejecuta el archivo didactico de sobrescritura para que la pantalla muestre impresiones de metodo, no palabras de orden de constructor. Si javac se queja de clases publicas duplicadas, aun tienes mas de una clase publica en el archivo — mantén solo Yard publica.
Cuerpo padre versus cuerpo hijo
📊 Who prints what for horn
| Role | horn body |
|---|---|
Parent Car |
prints beep |
Child Truck |
prints honk (overrides) |
La tabla es el mapa corto de esta pagina. La herencia sola pondria beep en ambos roles cuando el hijo queda vacio. Tras la sobrescritura, la fila hijo cambia a honk mientras la fila padre sigue beep. Mantén ese mapa en mente cuando la segunda demo imprime ambas lineas. |
Comparado con extends vacio y con super
En la pagina de herencia, Truck vacio mantuvo horn del padre e imprimio beep. En la pagina de super, los constructores corrieron por super e imprimieron car luego truck. En esta pagina, el metodo mismo cambia en el hijo. Todavia necesitas extends. Todavia puedes usar constructores mas adelante. Todavia no necesitas una interface.
Si un Truck vacio sigue abierto, anade el horn hijo que imprime honk antes de juzgar la pantalla. Si un archivo de constructor sigue abierto, cambia al archivo de sobrescritura para que t.horn() sea la llamada bajo prueba. Los tokens nuevos son el metodo reescrito en el hijo y las dos palabras distintas de pantalla beep y honk.
Antes de las interfaces
Puedes reescribir horn en Truck y ver honk desde t.horn(). Puedes llamar tanto c.horn() como t.horn() y ver beep luego honk. Compila Yard.java y ejecuta java Yard para cada demo guardada por turno. El cuerpo hijo respondio a la llamada del truck. La pagina siguiente son interfaces, donde un tipo puede prometer metodos sin apoyarse solo en extends.
Mantén la demo de un solo truck con honk para una sobrescritura clara. Mantén la demo de dos objetos para un contraste claro padre versus hijo. Mantén los archivos interface fuera de esta pagina. Esos tres habitos son el punto de control antes de seguir. Cuando honk aparece tras t.horn() y beep aun aparece tras c.horn(), la sobrescritura hizo su trabajo en esta leccion y estas listo para el siguiente tema sobre interfaces.
Un ultimo pase por la carpeta: un Yard publico, dos tipos auxiliares, un horn hijo que imprime honk, sin espera de teclado, sin interface forzada. Ejecuta javac Yard.java y java Yard una vez mas en la demo abierta. Si la pantalla aun coincide con la tabla — padre beep, hijo honk — la sobrescritura esta firme y el curso puede pasar a interfaces 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