super en Java

Usa super dentro del constructor hijo para que el constructor padre se ejecute primero. Mantén Truck extends Car. En Truck() llama super(); y luego imprime truck. En Car() imprime car. Compila Yard.java y ejecuta java Yard. La pantalla debe mostrar car, luego truck. Una segunda demo pasa una marca con super("car") a Car(String mark). Deja el override de un metodo para la pagina siguiente — esta leccion trata el orden de constructores con super.

Llama primero al constructor padre

La pagina de herencia dejo que un Truck vacio usara horn de Car. Esta pagina anade constructores. Abre Yard.java. Mantén el nombre de clase publica Yard. Borra demos de ruta sobrantes, archivos solo-horn si confunden los constructores, escritores Store y cualquier Scanner de teclado. El programa no debe esperar que escribas. No necesitas linea import.
Declara el padre con un constructor sin argumentos que imprima car:
class Car {
Car() {
System.out.println("car");
}
}
Declara el hijo con extends Car. Dentro de Truck(), pon super(); como primera sentencia y luego imprime truck:
super();
System.out.println("truck");
Dentro de Yard.main construye un truck:
Truck t = new Truck();
Construir el truck entra en Truck(). Esa llamada empieza con super(), que ejecuta Car(). Cuando el padre termina, corre la impresion del hijo.

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 car, luego truck. Recorre la ejecucion una vez. Java empieza en Yard.main. new Truck() entra en Truck(). La primera sentencia es super();, asi que Car() corre e imprime car. El control vuelve a Truck(), que imprime truck. La linea del padre aparece antes que la del hijo porque super() corrio primero.
Di el orden en voz alta mientras miras la pantalla: constructor padre, luego impresion del hijo. Ese orden hablado coincide con lo que super() fuerza en el constructor hijo. Si las lineas llegan en secuencia incorrecta, abre de nuevo el archivo didactico y comprueba que super(); sigue siendo la primera sentencia dentro de Truck() antes de cualquier println.
Si imprimes truck antes de super() en un experimento posterior donde el constructor padre necesita argumentos, javac puede rechazar — super debe ser la primera sentencia cuando lo escribes. En la primera demo el padre no necesita argumentos, y el archivo didactico mantiene super(); primero a proposito para que el orden quede claro. Si solo ves beep de una demo antigua de horn, cambia al archivo didactico de constructores y ejecuta java Yard otra vez.
No reescribas horn en Truck en esta pagina. El override de un metodo es la siguiente leccion. Hoy el constructor hijo habla con el padre con super y luego imprime su propia palabra. Mantén la palabra car en el lado padre y truck en el lado hijo para que cada linea diga que constructor termino.

Pasa un valor al padre con super

Un segundo programa mantiene extends. El constructor padre ahora toma un String mark e imprime esa marca. El hijo llama super("car") y luego imprime truck.

Compila con javac Yard.java, luego ejecuta java Yard. La pantalla otra vez muestra car, luego truck. Esta vez car es el argumento que pasaste por super("car"), no una impresion fija dentro de un Car() sin argumentos. El hijo eligio la cadena de marca; el constructor padre la imprimio. Despues el hijo imprimio truck.
Lee otra vez la firma del constructor padre: Car(String mark). La cadena entre comillas dentro de super("car") es esa marca. No cambies nada mas en el archivo para esta comprobacion — mantén extends Car, mantén la impresion hija de truck, y mantén new Truck() en main. La pantalla sigue terminando con truck bajo car porque la impresion hija solo corre despues de que super("car") vuelve.
Si omites super("car") mientras Car solo tiene Car(String mark), javac rechaza, porque el padre ya no tiene un constructor silencioso sin argumentos que llamar por ti. Escribir la llamada super(...) coincidente es como el hijo arranca el padre con los valores que necesita. Mantén super como primera sentencia en Truck(). Si javac se queja de un constructor por defecto ausente en Car, mira primero el constructor hijo y confirma que la linea super("car") esta presente y sigue primero.

Comparado con extends simple en la pagina horn

En la pagina de herencia, un Truck vacio llamo horn sin escribir constructores. En esta pagina, los constructores corren en orden mediante super. Mantén las demos horn como historia si siguen cerca; ejecuta el archivo didactico de super con java Yard para que la pantalla muestre car luego truck.
La pagina horn demostro que extends comparte un metodo. Esta pagina demuestra que extends tambien comparte un camino de construccion: el hijo arranca el padre mediante super y luego continua con su propia impresion. Ambas lecciones mantienen Truck extends Car. Solo cambia el cuerpo de Truck — de llaves vacias con una llamada posterior a horn, a un constructor que empieza con super.
super(), super("car") y el orden de constructores son los tokens nuevos. Todavia necesitas extends. Todavia no necesitas sobreescribir un metodo. Si una llamada horn sobrante sigue en main, quitala para estas demos para que la pantalla solo muestre las impresiones del constructor.

Lo que esta pagina deja para el override

Esta pagina ejecuta constructores padre con super. La pagina siguiente muestra override, donde un hijo escribe su propia version de un metodo que el padre ya tiene. Quedate aqui con las llamadas super de constructor. No reemplaces horn en Truck como requisito en estas demos todavia.
Cuando mas adelante sobreescribas un metodo, a menudo seguiras llamando primero un constructor padre con super. Trata esta pagina como la mitad de constructor de esa historia. Termina ambas demos Yard hasta que car luego truck se sienta automatico antes de abrir la leccion de override.

Antes del override

Puedes llamar super();, luego imprimir truck y ver car primero. Puedes llamar super("car") cuando el padre toma una marca y aun ver car, luego truck. Compila Yard.java y ejecuta java Yard para cada demo guardada por turno. El constructor padre termino antes de la impresion del hijo. La pagina siguiente es override, donde el hijo reemplaza el cuerpo de un metodo.
Mantén la demo super() sin argumentos para un orden claro. Mantén la demo super("car") para un paso de argumento claro. Mantén el override de metodo fuera de esta pagina. Esos tres habitos son el punto de control antes de seguir. Cuando car aparece encima de truck despues de new Truck(), super hizo su trabajo en esta leccion y estas listo para el siguiente tema sobre override.
Un ultimo repaso de la carpeta: un Yard publico, dos tipos auxiliares, sin espera de teclado, sin restos de path, sin reescritura forzada de horn. Ejecuta javac Yard.java y java Yard una vez mas en la demo abierta. Si la pantalla todavia imprime car luego truck, el orden de constructores esta solido y el curso puede pasar al override en la pagina siguiente.