1
00:00:00,780 --> 00:00:01,620
Vamos a continuar

2
00:00:04,570 --> 00:00:11,440
en la clase persona también vamos a agregar los métodos jet set para cada uno de los atributos así que

3
00:00:11,440 --> 00:00:12,700
damos un derecho Intercorp

4
00:00:15,300 --> 00:00:22,050
seleccionamos acceder y agregamos los métodos jet set para cada atributo y posteriormente vamos a hacer

5
00:00:22,050 --> 00:00:29,200
algunas correcciones quitamos el método set Heidi persona ya que una vez establecido este valor ya no

6
00:00:29,200 --> 00:00:37,910
vamos a permitir modificarlo y también el método set Contador personas no vamos a permitir que se modifique

7
00:00:38,150 --> 00:00:43,730
ya que este se maneja de manera automática a través del conductor privado de la clase bien con eso ya

8
00:00:43,730 --> 00:00:49,730
tenemos los métodos jet set para nuestra clase y ahora vamos a crear la clase para poner a prueba estas

9
00:00:49,730 --> 00:00:59,610
clases que hemos creado así que dan su derecho Niu ya va a clase y creamos la clase sobrecarga de constructores

10
00:01:04,550 --> 00:01:05,850
vamos a agregar un método main

11
00:01:10,780 --> 00:01:14,980
y vamos a crear nuestro objeto de tipo personal más es lo primero que vamos a hacer.

12
00:01:14,980 --> 00:01:21,670
Creamos un objeto llamado Persona 1 la variable Persona 1 de tipo Persona y creamos un nuevo objeto

13
00:01:21,670 --> 00:01:23,140
de tipo persona.

14
00:01:23,260 --> 00:01:28,750
Sin embargo si queremos utilizar el constructor vacío podemos observar que el compilador nos manda un

15
00:01:28,750 --> 00:01:34,600
error ya que el constructor vació de la clase persona es privado y en este caso el compilador nos obliga

16
00:01:34,810 --> 00:01:41,230
a proporcionar dos argumentos ya que como nos comenta en este caso no se puede mandar a llamar el constructor

17
00:01:41,470 --> 00:01:43,210
con los tipos indicados.

18
00:01:43,300 --> 00:01:50,200
Requerimos dos tipos el tipo string y el tipo entero y se en control que queremos utilizar el constructor

19
00:01:50,200 --> 00:01:57,550
sin argumentos así que la razón dice que los argumentos difieren en la lista de argumentos y en el largo

20
00:01:57,550 --> 00:02:02,680
del número de argumentos así que debemos de empezar a entender los errores que nos manda el compilador

21
00:02:02,860 --> 00:02:08,370
para saber cómo corregirlos así que lo que vamos a hacer es proporcionar dos valores.

22
00:02:08,370 --> 00:02:09,870
Por ejemplo el valor de Juan

23
00:02:13,250 --> 00:02:19,820
con la edad por ejemplo 25 y esto ya es un objeto válido de tipo persona vamos a mandarlo a imprimir

24
00:02:22,440 --> 00:02:23,280
ejecutamos

25
00:02:27,550 --> 00:02:33,010
y podemos ver que se ha creado correctamente nuestro objeto persona se le ha asignado el valor del atributo

26
00:02:33,090 --> 00:02:40,600
Heydi persona igual a 1 nombre de Juan I Edad 25 así que ya se ha creado correctamente nuestro objeto.

27
00:02:40,600 --> 00:02:45,730
Ahora si lo ejecutamos paso a paso vamos a ver el orden de creación de nuestro objeto de tipo persona

28
00:02:46,160 --> 00:02:56,770
así que damos un derecho de Buffy Buffalo y para entrar al detalle presionamos F7 y podemos ver que

29
00:02:56,770 --> 00:03:03,280
ya estamos dentro del constructor de la clase persona con dos argumentos estamos recibiendo los valores

30
00:03:03,280 --> 00:03:09,490
de Juan I de edad 25 para poder inicializar los atributos de esta clase.

31
00:03:09,490 --> 00:03:15,490
Sin embargo lo primero que va a hacer es mandar a llamar el constructor privado de esta clase así que

32
00:03:15,490 --> 00:03:21,790
para entrar al detalle de este constructor presionamos de nueva cuenta F7 y ya estamos en el constructor

33
00:03:21,790 --> 00:03:23,680
privado de esta clase.

34
00:03:23,680 --> 00:03:30,040
Si presionamos en este momento F7 entonces no solamente vamos a ejecutar este constructor sino vamos

35
00:03:30,040 --> 00:03:34,240
a ir al constructor vació de la clase padre de esta clase persona.

36
00:03:34,270 --> 00:03:40,870
Esto quiere decir que ese constructor vacio de la clase obvie vamos a revisar esto presionamos F7 y

37
00:03:40,870 --> 00:03:48,290
podemos observar que ya estamos en el constructor vació de la clase obvie presionamos f 8 se termina

38
00:03:48,290 --> 00:03:49,240
de ejecutar.

39
00:03:49,280 --> 00:03:55,040
El constructor vació de la clase padre de la clase Object y ya estamos de nueva cuenta dentro de la

40
00:03:55,040 --> 00:03:56,750
clase persona.

41
00:03:56,750 --> 00:04:02,330
El constructor vació y básicamente este constructor vació lo que va a hacer es inicializar el valor

42
00:04:02,570 --> 00:04:09,620
del atributo de persona presionamos F8 y ya hemos asignado el valor de 1 al atributo de persona.

43
00:04:09,620 --> 00:04:17,250
Presionamos de nueva cuenta f 8 y ahora regresamos a la ejecución del constructor con dos argumentos

44
00:04:17,460 --> 00:04:23,220
para poder terminar de inicializar los atributos de nuestra clase ya tenemos los valores de Juan y edad

45
00:04:23,250 --> 00:04:32,250
igual a 25 en cada uno de los atributos presionamos f8 de nueva cuenta F8 y ya tenemos inicializar nuestra

46
00:04:32,250 --> 00:04:38,370
variable Persona 1 con el objeto que se ha creado en memoria y podemos observar cada uno de sus valores.

47
00:04:38,370 --> 00:04:45,540
Tenemos el objeto de tipo personal en memoria con los valores de Persona 1 nombre Juán y edad 25 así

48
00:04:45,540 --> 00:04:50,880
que en este caso la sobrecarga de métodos no pudimos utilizar varios constructores para crear este objeto

49
00:04:51,240 --> 00:04:56,820
ya que uno de los constructores sobrecargados fue privado bien para terminar de ejecutar este código.

50
00:04:56,910 --> 00:05:01,710
Presionamos F8 y vemos la salida y Podemos se vaya a los valores que ya habíamos analizado.

51
00:05:03,040 --> 00:05:06,750
Presionamos F8 y terminamos de ejecutar nuestro código.

52
00:05:06,910 --> 00:05:14,860
Quitamos el punto de ruptura y ahora vamos a continuar creando un objeto de tipo empleado así que creamos

53
00:05:15,010 --> 00:05:21,880
una variable llamada empleado uno de tipo empleado y vamos a utilizar alguno de los constructores de

54
00:05:21,880 --> 00:05:27,210
la clase empleado si presionamos contra el espacio.

55
00:05:27,210 --> 00:05:30,680
Podemos observar que nos muestra a los dos constructores que tenemos disponibles.

56
00:05:30,810 --> 00:05:35,990
Así que en este caso es más claro la sobrecarga de constructores ya que podemos observar las dos opciones.

57
00:05:36,030 --> 00:05:42,570
Sin embargo cuando creamos el objeto persona aunque no vimos las dos opciones también existe la sobrecarga

58
00:05:42,720 --> 00:05:49,680
de manera interna en la clase persona así que cualquiera de las dos opciones es el concepto de sobrecarga

59
00:05:50,240 --> 00:05:56,070
y en este caso podemos seleccionar creando un objeto de tipo empleado proporcionando dos argumentos

60
00:05:56,340 --> 00:06:05,380
o tres argumentos así quedamos contra el espacio nuevamente y escogemos el constructor con tres argumentos.

61
00:06:05,380 --> 00:06:09,070
Proporcionamos el valor de nombre por ejemplo el valor de Carla.

62
00:06:09,730 --> 00:06:19,870
Posteriormente proporcionamos el valor de edad por ejemplo 30 y el sueldo el valor de 4000 y mandamos

63
00:06:19,870 --> 00:06:22,390
a imprimir esta variable.

64
00:06:22,390 --> 00:06:29,620
Guardamos cambios y ejecutamos y podemos observar que se ejecuta correctamente el empleado.

65
00:06:29,620 --> 00:06:38,840
1 contiene valores de la clase padre C inicial hizó el Heydi persona con el valor de 2 ya que recordemos

66
00:06:38,840 --> 00:06:43,030
que agregamos un contador de objetos de tipo Persona que es la variable estática.

67
00:06:43,130 --> 00:06:48,710
Por lo tanto esta variable estática está asignando el valor a los atributos de mi persona.

68
00:06:48,860 --> 00:06:54,410
Posteriormente agregamos los valores de Karla y edad igual a 30.

69
00:06:54,410 --> 00:07:00,260
Estos son los valores heredados de la clase persona de la clase padre y finalmente los valores de la

70
00:07:00,260 --> 00:07:06,470
clase e hija tenemos el atributo de sueldo igual a 4000 bien vamos a ejecutar paso a paso finalmente

71
00:07:06,740 --> 00:07:11,230
para que veamos la creación de este objeto hijo damos el derecho de Bofill

72
00:07:14,570 --> 00:07:21,530
presionamos F7 para entrar al detalle y ya estamos dentro del constructor sobrecargado y en este caso

73
00:07:21,530 --> 00:07:27,150
la primer línea va a mandar a llamar el constructor sobrecargado pero con dos argumentos.

74
00:07:27,260 --> 00:07:33,930
Así que si presionamos F 7 podemos observar que nos manda ahora al constructor sobrecargado.

75
00:07:33,930 --> 00:07:40,860
Dentro de esta misma clase pero con dos argumentos así que recibimos los valores de Karla y edad respectivamente

76
00:07:41,400 --> 00:07:47,130
y a su vez este constructor sobrecargado va a mandar a llamar el constructor de la clase padre así que

77
00:07:47,130 --> 00:07:53,070
si presionamos F7 podemos observar que ahora vamos hacia la clase padre y esto ya hace el mismo análisis

78
00:07:53,070 --> 00:07:55,620
que vimos cuando creamos el objeto de tipo Persona.

79
00:07:55,710 --> 00:08:02,070
Aquí básicamente va a mandar a llamar el constructor privado de esta clase persona para terminar de

80
00:08:02,070 --> 00:08:03,300
crear este objeto.

81
00:08:03,300 --> 00:08:09,600
Pero antes de terminar de crear este objeto tiene que terminar de crear el objeto persona y ahora vamos

82
00:08:09,600 --> 00:08:16,110
hacia abajo de nueva cuenta desde la clase Objet hacia la clase empleado así que podemos observar que

83
00:08:16,110 --> 00:08:23,330
el orden de nuestras clases la jerarquía de clases tenemos la clase obvie como la clase padre de todas

84
00:08:23,330 --> 00:08:24,450
las clases.

85
00:08:24,500 --> 00:08:36,010
Posteriormente tenemos nuestra clase de persona que hereda de la clase Objet y tenemos nuestra clase

86
00:08:36,040 --> 00:08:36,670
empleado

87
00:08:39,810 --> 00:08:45,930
que hereda de la clase persona y entonces cuando creamos este objeto de tipo empleado lo que tiene que

88
00:08:45,930 --> 00:08:51,630
hacer en primer lugar es empezar a mandar a llamar los constructores en este caso de la clase persona

89
00:08:53,300 --> 00:08:55,250
posteriormente de la clase Object.

90
00:08:55,250 --> 00:08:56,930
Y para terminar de crear el objeto.

91
00:08:56,960 --> 00:09:02,630
Entonces ahora empieza el trabajo hacia abajo vamos a empezar a regresar de obvie a persona de persona

92
00:09:02,660 --> 00:09:08,390
a empleado y finalmente regresa a la referencia en este caso a la variable empleado que hemos creado

93
00:09:10,920 --> 00:09:17,160
la variable empleado 1 y ese es el orden de creación de nuestro objeto incluyendo el orden de llamada

94
00:09:17,160 --> 00:09:25,170
de los constructores así que este constructor presionamos f 8 y vamos a empezar el regreso regresamos

95
00:09:25,170 --> 00:09:33,520
a la clase de persona el constructor privado inicializar del atributo de persona presionamos F8 ahora

96
00:09:33,700 --> 00:09:41,970
regresamos al constructor público con dos argumentos de la clase persona inicializar los atributos y

97
00:09:41,970 --> 00:09:47,640
finalmente regresamos al constructor de la clase empleado el constructor con dos argumentos.

98
00:09:47,640 --> 00:09:53,160
Posteriormente regresamos al constructor que hizo la llamada a este constructor de dos argumentos y

99
00:09:53,160 --> 00:09:58,560
ya estamos en el constructor con tres argumentos para inicializar el atributo de sueldo ya tenemos el

100
00:09:58,560 --> 00:10:03,540
valor en el atributo de sueldo y en este momento ya tenemos el objeto creado completamente.

101
00:10:03,540 --> 00:10:10,680
Si vemos los valores del objeto que se ha creado es un objeto de tipo empleado el sueldo tiene el valor

102
00:10:10,680 --> 00:10:17,100
de 4000 tenemos los valores estáticos la variable contador de personas en este momento tiene el valor

103
00:10:17,100 --> 00:10:24,700
de dos ya que es el segundo objeto de tipo Persona que se crea y finalmente tenemos los atributos heredados

104
00:10:25,040 --> 00:10:32,290
de persona con el valor de 2 nombre Karla y edad 30 así que ya está el objeto completamente creado presionamos

105
00:10:32,290 --> 00:10:42,040
f8 de nueva cuenta F8 y ya tenemos la referencia almacenada en la variable empleado 1.

106
00:10:42,210 --> 00:10:49,260
Finalmente mandamos a imprimir nuestro objeto y podemos observar que ya tenemos la variable empleado

107
00:10:49,710 --> 00:10:56,330
con los atributos heredados de la clase persona y con los atributos particulares de esta clase empleado

108
00:10:56,850 --> 00:11:03,800
pero recordemos que todo es un solo objeto de memoria presionamos f 8 y con eso termina de ejecutarse

109
00:11:04,040 --> 00:11:05,990
este ejercicio.

110
00:11:06,100 --> 00:11:11,100
Así que con esto hemos puesto en práctica varios conceptos relacionados con la construcción de constructores

111
00:11:11,370 --> 00:11:16,620
el orden de llamada de los mismos y también la sobrecarga de constructores en Java.

112
00:11:16,610 --> 00:11:19,800
Bien eso es todo por esta elección y nos vemos en el siguiente vídeo.

113
00:11:19,830 --> 00:11:20,430
Saludos.
