Uso de super en la sobrecarga de constructores vamos a revisar a continuación un ejemplo del uso de
súper dentro de la sobrecarga de constructores partiendo de la clase de persona que analizamos en la
lámina anterior definiremos la clase empleado la cual extiende la clase de persona por lo tanto hereda
todas las características de esta clase de persona.
Sin embargo no hereda las características que son de tipo privado.
Esto quiere decir que la clase empleado tiene acceso al constructor público de la clase persona de dos
argumentos estrechen e int y por lo tanto podemos apoyarnos de este constructor para inicializar los
atributos de la clase persona.
De hecho por la forma en que está construida la clase de persona es la única forma de inicializar los
atributos de dicha clase.
Por ejemplo el atributo Heydi persona de la clase persona no hay forma de acceder directamente ni siquiera
a través de algún método o constructor.
La única forma de acceder inicializar es mandar a llamar el constructor vacío.
Sin embargo este constructor vació de la clase persona es privado por lo tanto no podemos usarlo desde
la clase empleado.
La única forma que tenemos de inicializar el objeto persona es a través de la llamada al constructor
público con dos argumentos de tipo string e int.
Ahora la pregunta es cómo podemos acceder a este constructor.
La respuesta es utilizando la palabra super.
Recordemos que la palabra super lo que hace es mandar a llamar a algún método o atributo de la clase
padre.
Sin embargo en este caso si utilizamos la sintaxis Supper y entre paréntesis indicamos cuál es el constructor
que queremos mandar a llamar.
En este caso proporcionamos dos argumentos nombre y edad para mandar a llamar el constructor de la clase
persona que es público pero no podemos mandar a llamar un constructor privado así que no podríamos utilizar
la línea de Super y entre paréntesis punto y coma es decir la llamada al constructor vacío.
Esto no es posible ya que este constructor dentro de la clase persona es privado pero sí podemos mandar
a llamar el constructor público proporcionando los argumentos respectivos.
Así que para el ejemplo que estamos mostrando la palabra super la estamos usando para inicializar los
atributos de la clase persona de la cual extiende empleado si no lo hiciéramos de esta forma estaríamos
dejando sin asignar los valores respectivos a los atributos de la clase persona ya que todos sus atributos
son privados podríamos asignar valores si existieran métodos tipo teitos es decir métodos C.T para los
atributos respectivos pero en este caso no existen este tipo de métodos por lo que los atributos se
quedarían sin inicializar así que este es un ejemplo de cómo podemos empezar a configurar nuestras clases
para que al momento de crear nuestros objetos empecemos a poner restricciones sobre cómo se deben utilizar
e inicializar sus atributos finalmente podemos observar que cada clase realiza su labor es decir la
clase persona realiza las tareas respectivas al momento de crear un objeto de tipo personal pero también
podemos observar cómo en las clases hijas pueden realizar sus tareas para inicializar sus propios atributos
así que una vez que hemos terminado de mandar a llamar el constructor de la clase padre el siguiente
paso es terminar de inicializar los atributos de esta clase empleado y de esta manera es que podemos
ya tener completamente configurado nuestro objeto de tipo empleado.
Así evitamos duplicar código y cada una de las clases realiza únicamente la tarea que debe realizar.
Por ello es que delegamos cualquier tarea a la clase padre a los constructores correspondientes y de
esta manera evitamos la duplicación de código y comenzamos a crear diseños más elaborados y funcionales
en la creación y codificación de nuestras clases.
Orden de llamada de constructores con lo que hemos visto hasta ahora podemos darnos cuenta no solamente
de cómo se configuran nuestras clases Java sino también el orden en que se crean los objetos en primer
lugar se manda llamar el constructor del objeto que estamos creando por ejemplo vamos a revisar el siguiente
código cuando estamos creando el objeto empleado proporcionamos el nombre la edad y el sueldo y posteriormente
mandamos a imprimir el objeto.
Este objeto que se está creando no solamente incluye valores de la clase empleado sino que hereda de
la clase persona y a su vez la clase de persona hereda de la clase obvie.
Así que para ver un objeto de tipo empleado tendríamos que entender que estamos configurando un objeto
más grande que simplemente los atributos de la clase empleado.
Por ello es que mostramos esta figura y ahora veamos el orden en que se mandan a llamar los constructores
para crear este objeto de tipo empleado en primer lugar se manda llamar el constructor del objeto que
estamos creando en este caso la clase empleado al comenzar a ejecutar este constructor de la clase empleado
se hace una llamada implícita a super de la clase padre si es que no hemos proporcionado otra sintaxis
se hace una llamada al constructor vació de la clase padre así que de manera implícita de manera automática
lo primero que se hace es mandar a llamar a super sin argumentos es decir al constructor vació de la
clase padre todas las clases en Java heredan de la clase Object.
Según hemos comentado por lo tanto todos los constructores en un momento determinado hacen una llamada
a Súper de la clase Object así que eventualmente haremos la llamada al constructor vació de la clase
Object por medio de la llamada a Super entre paréntesis sin argumentos para que se pueda ejecutar la
llamada al constructor vació de la clase obvie este constructor es el encargado de reservar memoria
de manera dinámica entre varias tareas más.
Sin embargo para esta lección basta con saber que el constructor se manda a llamar en todos los casos
que se crea un objeto una vez que termina de ejecutarse el constructor de la clase padre se regresa
el control al constructor que había iniciado la llamada o que a su vez es el constructor padre y así
hasta que la cadena de constructores se concluya.
Así que podemos observar que una vez que se termina de crear el objeto de la clase padre en este caso
la clase Object comienza de nueva cuenta.
De regreso hacia las clases hijas que hicieron la llamada a este constructor padre.
Así que la clase padre de la clase de persona fue la clase obvien y una vez que termina de ejecutarse
este constructor de la clase padre se regresa el control a la clase hija en este caso a la clase de
persona y este proceso se continúa con la siguiente clase.
En este caso una vez que termina de ejecutarse el código del constructor de la clase de persona se regresa
el control a la clase e hija que hizo la llamada en este caso a la clase empleado y así sucesivamente.
Si tuviéramos una jerarquía más larga de clases este sería el orden de llamada de constructores así
que una vez que el constructor vació de la clase padre termina de ejecutarse se regresa el control al
constructor de la clase e hija que hizo la llamada y continúa con la ejecución de su código.
Si ya se concluyó con la llamada de constructores entonces se regresa el control al método que hizo
la llamada a la construcción del objeto respectivo por ejemplo en nuestro código el método main es quien
crea un objeto de la clase empleado pero éste a su vez tiene como clase padre a la clase persona y la
clase persona a ya no extender de ninguna otra clase de manera explícita entonces extiende de manera
implícita de la clase obvie todas las clases en Java si no especifican una extensa en la definición
de su clase podemos decir que su clase padre es la clase Object.
Según hemos comentado por lo tanto la primera llamada que se realiza es al constructor de la clase empleado
y posteriormente se manda a llamar los constructores de la clase de persona y obvia respectivamente.
Sin embargo si recordamos el Código de la lámina anterior recordamos que la clase empleado si hace una
llamada implícita de super esto para mandar a llamar el constructor de la clase persona con dos argumentos
según recordamos de tipo String int para proporcionar el nombre y la edad de la persona entonces antes
de hacer la asignación del atributo sueldo de la clase empleado lo primero que hace es hacer una llamada
al constructor de la clase padre es decir al constructor de la clase persona debido a que si se está
haciendo una llamada explícita por medio de super entonces se manda a llamar al constructor de la clase
persona con dos argumentos este constructor de la clase persona con dos argumentos supondremos que es
el mismo código de las láminas anteriores.
Por lo tanto se hace una llamada al constructor sin argumentos con el uso de Diz y este constructor
sin argumentos debido a que no hace una llamada explícita a Supper entonces de manera implícita manda
llamar a Súper de la clase obvie una vez que termina este constructor de la clase Object de ejecutarse
regresa el control al constructor vació de la clase persona y continúa con la línea siguiente donde
se hizo la llamada implícita a Super y continúa una línea después de donde se hizo la llamada a Super
ya sea de manera implícita o explícita.
Por ello es que la palabra super debe de ser la primera línea que debe de encontrarse en un constructor
si es que existe ya que posteriormente de la llamada a Super es que se regresa el control a este constructor
y termina de ejecutar las siguientes líneas una vez que termina la ejecución de los códigos de los constructores
de la clase personan regresa el control al constructor de la clase empleado para finalmente concluir
con la creación del objeto empleado el cual ya ha inicializar todos los atributos tanto de la clase
empleado y de la clase de persona según el proceso descrito anteriormente.
El orden de llamada de constructores es importante tenerlo en cuenta ya que cuando estamos programando
nuestros constructores y considerando la inicialización de variables es importante saber el orden en
el que nuestros constructores serán ejecutados así como la creación de los objetos sobre todo cuando
estamos aplicando el concepto de herencia.
A continuación vamos a realizar un ejercicio para poner en práctica el concepto de sobrecarga de constructores
en Java.