Vamos a continuar
en la clase persona también vamos a agregar los métodos jet set para cada uno de los atributos así que
damos un derecho Intercorp
seleccionamos acceder y agregamos los métodos jet set para cada atributo y posteriormente vamos a hacer
algunas correcciones quitamos el método set Heidi persona ya que una vez establecido este valor ya no
vamos a permitir modificarlo y también el método set Contador personas no vamos a permitir que se modifique
ya que este se maneja de manera automática a través del conductor privado de la clase bien con eso ya
tenemos los métodos jet set para nuestra clase y ahora vamos a crear la clase para poner a prueba estas
clases que hemos creado así que dan su derecho Niu ya va a clase y creamos la clase sobrecarga de constructores
vamos a agregar un método main
y vamos a crear nuestro objeto de tipo personal más es lo primero que vamos a hacer.
Creamos un objeto llamado Persona 1 la variable Persona 1 de tipo Persona y creamos un nuevo objeto
de tipo persona.
Sin embargo si queremos utilizar el constructor vacío podemos observar que el compilador nos manda un
error ya que el constructor vació de la clase persona es privado y en este caso el compilador nos obliga
a proporcionar dos argumentos ya que como nos comenta en este caso no se puede mandar a llamar el constructor
con los tipos indicados.
Requerimos dos tipos el tipo string y el tipo entero y se en control que queremos utilizar el constructor
sin argumentos así que la razón dice que los argumentos difieren en la lista de argumentos y en el largo
del número de argumentos así que debemos de empezar a entender los errores que nos manda el compilador
para saber cómo corregirlos así que lo que vamos a hacer es proporcionar dos valores.
Por ejemplo el valor de Juan
con la edad por ejemplo 25 y esto ya es un objeto válido de tipo persona vamos a mandarlo a imprimir
ejecutamos
y podemos ver que se ha creado correctamente nuestro objeto persona se le ha asignado el valor del atributo
Heydi persona igual a 1 nombre de Juan I Edad 25 así que ya se ha creado correctamente nuestro objeto.
Ahora si lo ejecutamos paso a paso vamos a ver el orden de creación de nuestro objeto de tipo persona
así que damos un derecho de Buffy Buffalo y para entrar al detalle presionamos F7 y podemos ver que
ya estamos dentro del constructor de la clase persona con dos argumentos estamos recibiendo los valores
de Juan I de edad 25 para poder inicializar los atributos de esta clase.
Sin embargo lo primero que va a hacer es mandar a llamar el constructor privado de esta clase así que
para entrar al detalle de este constructor presionamos de nueva cuenta F7 y ya estamos en el constructor
privado de esta clase.
Si presionamos en este momento F7 entonces no solamente vamos a ejecutar este constructor sino vamos
a ir al constructor vació de la clase padre de esta clase persona.
Esto quiere decir que ese constructor vacio de la clase obvie vamos a revisar esto presionamos F7 y
podemos observar que ya estamos en el constructor vació de la clase obvie presionamos f 8 se termina
de ejecutar.
El constructor vació de la clase padre de la clase Object y ya estamos de nueva cuenta dentro de la
clase persona.
El constructor vació y básicamente este constructor vació lo que va a hacer es inicializar el valor
del atributo de persona presionamos F8 y ya hemos asignado el valor de 1 al atributo de persona.
Presionamos de nueva cuenta f 8 y ahora regresamos a la ejecución del constructor con dos argumentos
para poder terminar de inicializar los atributos de nuestra clase ya tenemos los valores de Juan y edad
igual a 25 en cada uno de los atributos presionamos f8 de nueva cuenta F8 y ya tenemos inicializar nuestra
variable Persona 1 con el objeto que se ha creado en memoria y podemos observar cada uno de sus valores.
Tenemos el objeto de tipo personal en memoria con los valores de Persona 1 nombre Juán y edad 25 así
que en este caso la sobrecarga de métodos no pudimos utilizar varios constructores para crear este objeto
ya que uno de los constructores sobrecargados fue privado bien para terminar de ejecutar este código.
Presionamos F8 y vemos la salida y Podemos se vaya a los valores que ya habíamos analizado.
Presionamos F8 y terminamos de ejecutar nuestro código.
Quitamos el punto de ruptura y ahora vamos a continuar creando un objeto de tipo empleado así que creamos
una variable llamada empleado uno de tipo empleado y vamos a utilizar alguno de los constructores de
la clase empleado si presionamos contra el espacio.
Podemos observar que nos muestra a los dos constructores que tenemos disponibles.
Así que en este caso es más claro la sobrecarga de constructores ya que podemos observar las dos opciones.
Sin embargo cuando creamos el objeto persona aunque no vimos las dos opciones también existe la sobrecarga
de manera interna en la clase persona así que cualquiera de las dos opciones es el concepto de sobrecarga
y en este caso podemos seleccionar creando un objeto de tipo empleado proporcionando dos argumentos
o tres argumentos así quedamos contra el espacio nuevamente y escogemos el constructor con tres argumentos.
Proporcionamos el valor de nombre por ejemplo el valor de Carla.
Posteriormente proporcionamos el valor de edad por ejemplo 30 y el sueldo el valor de 4000 y mandamos
a imprimir esta variable.
Guardamos cambios y ejecutamos y podemos observar que se ejecuta correctamente el empleado.
1 contiene valores de la clase padre C inicial hizó el Heydi persona con el valor de 2 ya que recordemos
que agregamos un contador de objetos de tipo Persona que es la variable estática.
Por lo tanto esta variable estática está asignando el valor a los atributos de mi persona.
Posteriormente agregamos los valores de Karla y edad igual a 30.
Estos son los valores heredados de la clase persona de la clase padre y finalmente los valores de la
clase e hija tenemos el atributo de sueldo igual a 4000 bien vamos a ejecutar paso a paso finalmente
para que veamos la creación de este objeto hijo damos el derecho de Bofill
presionamos F7 para entrar al detalle y ya estamos dentro del constructor sobrecargado y en este caso
la primer línea va a mandar a llamar el constructor sobrecargado pero con dos argumentos.
Así que si presionamos F 7 podemos observar que nos manda ahora al constructor sobrecargado.
Dentro de esta misma clase pero con dos argumentos así que recibimos los valores de Karla y edad respectivamente
y a su vez este constructor sobrecargado va a mandar a llamar el constructor de la clase padre así que
si presionamos F7 podemos observar que ahora vamos hacia la clase padre y esto ya hace el mismo análisis
que vimos cuando creamos el objeto de tipo Persona.
Aquí básicamente va a mandar a llamar el constructor privado de esta clase persona para terminar de
crear este objeto.
Pero antes de terminar de crear este objeto tiene que terminar de crear el objeto persona y ahora vamos
hacia abajo de nueva cuenta desde la clase Objet hacia la clase empleado así que podemos observar que
el orden de nuestras clases la jerarquía de clases tenemos la clase obvie como la clase padre de todas
las clases.
Posteriormente tenemos nuestra clase de persona que hereda de la clase Objet y tenemos nuestra clase
empleado
que hereda de la clase persona y entonces cuando creamos este objeto de tipo empleado lo que tiene que
hacer en primer lugar es empezar a mandar a llamar los constructores en este caso de la clase persona
posteriormente de la clase Object.
Y para terminar de crear el objeto.
Entonces ahora empieza el trabajo hacia abajo vamos a empezar a regresar de obvie a persona de persona
a empleado y finalmente regresa a la referencia en este caso a la variable empleado que hemos creado
la variable empleado 1 y ese es el orden de creación de nuestro objeto incluyendo el orden de llamada
de los constructores así que este constructor presionamos f 8 y vamos a empezar el regreso regresamos
a la clase de persona el constructor privado inicializar del atributo de persona presionamos F8 ahora
regresamos al constructor público con dos argumentos de la clase persona inicializar los atributos y
finalmente regresamos al constructor de la clase empleado el constructor con dos argumentos.
Posteriormente regresamos al constructor que hizo la llamada a este constructor de dos argumentos y
ya estamos en el constructor con tres argumentos para inicializar el atributo de sueldo ya tenemos el
valor en el atributo de sueldo y en este momento ya tenemos el objeto creado completamente.
Si vemos los valores del objeto que se ha creado es un objeto de tipo empleado el sueldo tiene el valor
de 4000 tenemos los valores estáticos la variable contador de personas en este momento tiene el valor
de dos ya que es el segundo objeto de tipo Persona que se crea y finalmente tenemos los atributos heredados
de persona con el valor de 2 nombre Karla y edad 30 así que ya está el objeto completamente creado presionamos
f8 de nueva cuenta F8 y ya tenemos la referencia almacenada en la variable empleado 1.
Finalmente mandamos a imprimir nuestro objeto y podemos observar que ya tenemos la variable empleado
con los atributos heredados de la clase persona y con los atributos particulares de esta clase empleado
pero recordemos que todo es un solo objeto de memoria presionamos f 8 y con eso termina de ejecutarse
este ejercicio.
Así que con esto hemos puesto en práctica varios conceptos relacionados con la construcción de constructores
el orden de llamada de los mismos y también la sobrecarga de constructores en Java.
Bien eso es todo por esta elección y nos vemos en el siguiente vídeo.
Saludos.