1
00:00:01,370 --> 00:00:03,100
Hola y bienvenidos a esta elección.

2
00:00:03,110 --> 00:00:07,910
A continuación vamos a estudiar el tema de su escritura de métodos en Java están listos.

3
00:00:07,920 --> 00:00:15,420
Vamos bien como primer paso abrimos nuestro IDE y cerramos cualquier proyecto que tengamos abierto.

4
00:00:15,560 --> 00:00:21,350
Damos clic derecho Claws posteriormente vamos a crear un nuevo proyecto damos clic en File new project

5
00:00:22,010 --> 00:00:24,710
seleccionamos lleva Whitney en Java Application.

6
00:00:24,710 --> 00:00:26,020
Damos clic en Next.

7
00:00:26,180 --> 00:00:33,940
El nombre del proyecto se va a llamar ejemplo sobre escritura y lo depositamos en la carpeta de cursos

8
00:00:34,030 --> 00:00:35,380
y agonal Java.

9
00:00:35,680 --> 00:00:38,410
El nombre de proyecto va a ser MX con GBM globalmente.

10
00:00:38,470 --> 00:00:43,950
La versión 1.0 y dejamos el nombre vació del paquete y damos clic en Finalizar.

11
00:00:46,380 --> 00:00:51,660
Ahora para poner a prueba este ejemplo de escritura necesitamos aplicar también el concepto de herencia

12
00:00:51,990 --> 00:00:55,370
así que vamos a crear dos clases sobre sus packages.

13
00:00:55,380 --> 00:01:00,570
Vamos a crear una primera clase damos clic derecho y ya va a clase el nombre de la clase se va a llamar

14
00:01:00,600 --> 00:01:03,060
empleado y lo depositamos en el paquete.

15
00:01:03,060 --> 00:01:03,720
Ejemplo

16
00:01:06,470 --> 00:01:13,880
sobre escritura y damos clic en Finalizar y posteriormente vamos a crear una subclase de esta clase.

17
00:01:14,020 --> 00:01:19,120
Sobre ese mismo paquete damos un derecho Nioh y a la clase el nombre de la clase se va a llamar gerente

18
00:01:19,360 --> 00:01:23,020
y lo depositamos en el mismo paquete y damos sigue en finalizar.

19
00:01:23,020 --> 00:01:31,390
Sin embargo esta clase de gerente va a extender de la clase empleados a segregamos extenso empleado

20
00:01:32,070 --> 00:01:34,430
y con esto ya hemos creado nuestras dos clases.

21
00:01:34,590 --> 00:01:39,290
Ahora vamos a modificar nuestra clase empleado vamos a quitar estos comentarios con control.

22
00:01:40,260 --> 00:01:46,620
Posteriormente vamos a agregar dos atributos de tipo protected así decidimos protected estrellen.

23
00:01:47,250 --> 00:01:56,980
Posteriormente el atributo de nombre y otro atributo de tipo doble llamado sueldo y agregamos un constructor

24
00:01:57,010 --> 00:01:58,200
también de tipo protected

25
00:02:00,880 --> 00:02:06,010
vamos a recibir dos argumentos para inicializar cada uno de los atributos así que agregamos esto en

26
00:02:06,010 --> 00:02:15,650
nombre y doble sueldo para inicializar cada atributo y posteriormente modificamos el valor de cada atributo

27
00:02:15,650 --> 00:02:17,420
con los argumentos que estamos recibiendo

28
00:02:23,310 --> 00:02:28,620
bien con esto ya estamos inicializar cada atributo a través de este constructor con dos argumentos y

29
00:02:28,620 --> 00:02:33,570
posteriomente lo que vamos a hacer es definir un método llamado obtener detalles así escribimos Public

30
00:02:33,670 --> 00:02:34,040
destruí

31
00:02:38,280 --> 00:02:44,100
el método se llama obtener detalles y este método básicamente va a retornar los valores de los atributos

32
00:02:44,100 --> 00:02:45,490
nombre y sueldo.

33
00:02:45,630 --> 00:02:54,460
Así escribimos Bruton nombre la cadena de nombre dos puntos espacio y concatenados el valor del atributo

34
00:02:54,460 --> 00:03:05,780
de nombre y posteriormente con k tenemos el segundo valor agregamos Koma espacio sueldo dos puntos espacio

35
00:03:08,290 --> 00:03:10,160
e imprimimos el valor de sueldo.

36
00:03:10,160 --> 00:03:15,050
Podemos utilizar dis para que sepamos de manera inmediata que estamos utilizando los atributos de nuestra

37
00:03:15,050 --> 00:03:22,400
clase así que ya estamos definiendo el método obtener detalles y ahora vamos a agregar los métodos jet

38
00:03:22,520 --> 00:03:31,140
set para cada atributo nombre y sueldo así que damos clic derecho posteriormente seleccionamos insert

39
00:03:31,150 --> 00:03:38,520
Coupet seleccionamos Guedea Ancer y seleccionamos los dos atributos para que generen los métodos jet

40
00:03:38,640 --> 00:03:39,930
set para cada atributo

41
00:03:42,880 --> 00:03:47,400
así que con esto ya tenemos completa nuestra clase de empleado ahora vamos a hacer nuestra clase de

42
00:03:47,400 --> 00:03:50,950
gerente vamos a quitar estos comentarios

43
00:03:53,550 --> 00:03:58,870
y aquí en primer lugar ya nos empieza a mandar un mensaje en el cual nos indica que debemos utilizar

44
00:03:58,900 --> 00:04:04,690
un constructor con dos argumentos ya que la clase empleado ya no cuenta con el constructor vació debido

45
00:04:04,690 --> 00:04:08,050
a que hemos definido un constructor únicamente con dos argumentos.

46
00:04:08,050 --> 00:04:13,210
Por lo tanto es necesario utilizar el constructor con los argumentos de la clase empleado para poder

47
00:04:13,210 --> 00:04:16,440
inicializar correctamente este objeto de la clase gerente.

48
00:04:16,480 --> 00:04:22,510
Sin embargo esta clase gerente contiene una característica más a diferencia de la clase empleado el

49
00:04:22,510 --> 00:04:29,170
empleado tiene el nombre y el sueldo pero el gerente tiene además el atributo de departamento así que

50
00:04:29,170 --> 00:04:32,200
agregamos ese atributo privado de tipo string

51
00:04:35,280 --> 00:04:41,070
llamado departamento y posteriormente vamos a agregar un constructor para inicializar en todos los atributos

52
00:04:41,190 --> 00:04:46,500
de la clase padre de la clase empleado y también este nuevo atributo de la clase e hija así que agregamos

53
00:04:46,500 --> 00:04:56,350
un constructor público se llama gerente y recibimos los argumentos de nombre sueldo

54
00:04:59,140 --> 00:05:06,110
y departamento y lo que vamos a hacer es utilizar la palabra super para inicializar los atributos de

55
00:05:06,110 --> 00:05:07,100
la clase padre.

56
00:05:07,220 --> 00:05:13,190
Así escribimos super esto manda llamar al constructor de la clase padre y le pasamos los valores de

57
00:05:13,190 --> 00:05:17,080
nombre y sueldo que son los argumentos que estamos recibiendo.

58
00:05:17,570 --> 00:05:22,190
Recordemos que la palabra súper si la vamos a utilizar para mandar a llamar a un constructor debe de

59
00:05:22,190 --> 00:05:33,140
ser la primera línea dentro de un constructor y posteriormente inicializar el atributo de departamento.

60
00:05:33,250 --> 00:05:37,310
Hasta aquí todavía no hemos visto nada de eso reestructuran esto solamente en la configuración de nuestra

61
00:05:37,310 --> 00:05:39,970
clase empleados y gerentes respectivamente.

62
00:05:40,250 --> 00:05:45,400
Ahora vamos a empezar a aplicar el concepto de escritura el método heredado de la clase padre.

63
00:05:45,650 --> 00:05:55,370
Así que escribimos lo siguiente escribimos el método padre heredado así que para sobrescribir un método

64
00:05:55,610 --> 00:06:01,670
básicamente vamos a utilizar la misma firma del método padre así que incluso podemos copiar esta misma

65
00:06:01,670 --> 00:06:02,120
firma

66
00:06:05,120 --> 00:06:12,300
la pegamos y con eso estamos asegurando que estamos escribiendo el método de la clase padre podemos

67
00:06:12,300 --> 00:06:17,700
hacer cambios en el modificador de acceso pero no puede ser más restrictivo así que como en este caso

68
00:06:17,830 --> 00:06:22,820
tipo de público ya no podríamos hacerlo más restrictivo es decir que ya no podemos utilizar protected

69
00:06:23,130 --> 00:06:29,280
de fought opacas ni tampoco Privé bien así que con eso estamos definiendo la sobre escritura del método

70
00:06:29,310 --> 00:06:36,720
obtener detalles de la clase padre y ahora lo que vamos a hacer es que vamos a retornar cada uno de

71
00:06:36,720 --> 00:06:40,590
los atributos tanto de la clase empleado como de la clase gerente.

72
00:06:42,380 --> 00:06:45,470
Así que vamos a copiar el contenido del método obtener detalle

73
00:06:49,150 --> 00:06:56,410
pero la escritura significa que podemos modificar el contenido de la clase padre y precisamente modificar

74
00:06:56,470 --> 00:07:02,050
o sobreescribir el contenido del método en la clase e hija así que en este caso vamos a modificar el

75
00:07:02,050 --> 00:07:05,920
contenido en la clase e hija y vamos a agregar lo siguiente

76
00:07:09,740 --> 00:07:14,900
agregamos el atributo de departamento en la definición de este método obtener detalles

77
00:07:22,470 --> 00:07:27,450
así que podemos observar que este método obtener detalles no solamente está regresando lo que ya hacia

78
00:07:27,450 --> 00:07:33,030
el método de la clase padre sino que además estamos modificando el comportamiento obviamente podría

79
00:07:33,030 --> 00:07:34,770
regresar cualquier otro código.

80
00:07:34,800 --> 00:07:39,720
Esto solamente lo estamos haciendo para que podamos observar que la clase e hija puede modificar el

81
00:07:39,720 --> 00:07:46,140
contenido del método definido en la clase padre eso es la escritura de métodos y finalmente agregamos

82
00:07:46,200 --> 00:07:51,210
los métodos jet set para el atributo de departamento

83
00:07:54,380 --> 00:08:01,920
damos clic en generar y ya tenemos los métodos G.T y ser el atributo de departamento.

84
00:08:01,960 --> 00:08:06,670
Aquí otra cosa interesante es que podemos observar que estamos accediendo a los atributos de nombre

85
00:08:06,730 --> 00:08:09,640
y sueldo sin necesidad de mandar a llamar.

86
00:08:09,640 --> 00:08:16,060
Los métodos jet set de estos atributos ya que sus atributos se declararon como protegidos en la clase

87
00:08:16,060 --> 00:08:21,610
padre así que realmente aquí lo que estamos utilizando es directamente los atributos definidos en la

88
00:08:21,610 --> 00:08:26,910
clase padre son atributos heredados de la clase padre.

89
00:08:27,020 --> 00:08:33,830
Bien vamos a dar un formato y finalmente vamos a crear una clase de prueba sobre son los packages.

90
00:08:33,850 --> 00:08:39,060
Vamos a dar clic derecho new Java class que se llame ejemplo

91
00:08:41,820 --> 00:08:46,720
sobre escritura y el paquete se llama test y damos sigue en finalizar.

92
00:08:49,550 --> 00:08:57,840
Quitamos estos comentarios agregamos un método main Publix atisbó y Main tabulador y vamos a crear un

93
00:08:57,840 --> 00:08:59,670
objeto primero de la clase empleado

94
00:09:02,490 --> 00:09:04,890
una variable de tipo empleado llamado empleado

95
00:09:09,140 --> 00:09:19,100
y mandamos a llamar el constructor de la clase padre con los valores de Juan en el nombre y mil en el

96
00:09:19,100 --> 00:09:27,060
valor de sueldo importamos esta clase ya que se encuentra en el paquete de ejemplo sobre escritura y

97
00:09:27,070 --> 00:09:30,900
mandamos a imprimir esta variable con ese tabulador.

98
00:09:31,120 --> 00:09:38,310
Mandamos a imprimir la variable empleado aquí tenemos que cambiar un detalle en la clase empleado utilice

99
00:09:38,310 --> 00:09:39,090
protected.

100
00:09:39,180 --> 00:09:45,940
En este caso no necesitamos utilizar el modificador acceso público de lo contrario no vamos a poder

101
00:09:45,970 --> 00:09:52,720
utilizar ese constructor en una clase externa al paquete que no extiende de la clase empleado así que

102
00:09:52,720 --> 00:09:58,330
por ello necesitamos hacer este cambio para que podamos ejecutar esta prueba así que guardamos cambios

103
00:09:58,870 --> 00:09:59,680
y ejecutamos

104
00:10:06,660 --> 00:10:10,520
y podemos ver que se está imprimiendo la información del objeto empleado.

105
00:10:10,570 --> 00:10:15,070
Sin embargo como no hemos definido el método autodestruyen únicamente estamos recibiendo la información

106
00:10:15,360 --> 00:10:17,890
donde se encuentra este objeto en memoria.

107
00:10:17,890 --> 00:10:23,560
Vamos a hacer un cambio con la variable empleado vamos a mandar a llamar el método obtener detalles

108
00:10:24,570 --> 00:10:26,250
guardamos cambios y ejecutamos

109
00:10:29,260 --> 00:10:31,810
y ahora sí podemos observar el detalle del objeto.

110
00:10:31,930 --> 00:10:37,420
El nombre con el valor de Juan y el sueldo con el valor de mil así que hasta aquí estamos utilizando

111
00:10:37,450 --> 00:10:40,750
únicamente el método de la clase padre.

112
00:10:40,750 --> 00:10:43,150
Ahora vamos a crear un objeto de la clase e hija

113
00:10:45,820 --> 00:10:48,060
definimos el objeto de tipo gerente.

114
00:10:50,460 --> 00:11:05,210
Creamos el objeto le asignamos el nombre de Carla el sueldo de 2 000 y el departamento finanzas y hacemos

115
00:11:05,210 --> 00:11:17,290
lo mismo mandamos a imprimir importamos esta clase y mandamos a imprimir esta variable pero con el objeto

116
00:11:17,290 --> 00:11:18,560
gerente mandamos a imprimir.

117
00:11:18,580 --> 00:11:25,820
Ahora el método obtener detalles de la clase e hija guardamos cambios y ejecutamos

118
00:11:28,770 --> 00:11:34,540
y podemos observar que a diferencia de la clase padre donde no se incluye el departamento en el caso

119
00:11:34,540 --> 00:11:40,210
de la clase gerente se incluye no solamente el nombre y el sueldo sino que también ahora se modificó

120
00:11:40,210 --> 00:11:43,960
se escribió este método para que incluyera el departamento.

121
00:11:44,050 --> 00:11:46,920
En este caso el Departamento de Finanzas.

122
00:11:47,020 --> 00:11:49,270
Ahora qué pasa si no hubiéramos escrito este método.

123
00:11:49,270 --> 00:11:51,510
Obtener detalles en la Clase E HIJA.

124
00:11:51,610 --> 00:11:53,520
Vamos a poner esto entre comentarios

125
00:11:57,780 --> 00:12:01,370
podemos observar que el código sigue compilando sin ningún problema.

126
00:12:01,590 --> 00:12:08,230
Guardamos cambios y ejecutamos y podemos llevar también que se ejecuta sin ningún problema.

127
00:12:08,480 --> 00:12:13,940
Así que el objeto gerente manda imprimir el nombre de Carla y el sueldo de 2000.

128
00:12:13,940 --> 00:12:18,560
Sin embargo en este caso como no estamos escribiendo el método en la clase e hija

129
00:12:21,630 --> 00:12:28,410
ya no estamos accediendo al valor de departamento ya que la clase padre únicamente puede acceder a los

130
00:12:28,410 --> 00:12:34,170
atributos definidos precisamente en la clase padre pero no puede acceder a los atributos definidos en

131
00:12:34,170 --> 00:12:39,690
las clases hijas así que por ello este código sigue funcionando.

132
00:12:39,850 --> 00:12:45,850
Pero el método que se está ejecutando es el método heredado de la clase padre ya que no se ha escrito

133
00:12:46,030 --> 00:12:53,620
en la clase gerente vamos a regresar este código lo volvemos a activar y en este momento se está escribiendo

134
00:12:53,890 --> 00:12:59,560
se está modificando el contenido del método obtener detalles desde la clase e hija se incluye el atributo

135
00:12:59,800 --> 00:13:01,100
de departamento.

136
00:13:01,300 --> 00:13:08,680
Ejecutamos y observamos el mismo resultado donde recibimos el método desde la clase e hija y obtenemos

137
00:13:08,770 --> 00:13:11,730
el Departamento de Finanzas.

138
00:13:11,740 --> 00:13:19,170
Una última cosa en la clase gerente también se puede utilizar lo que se conoce como una anotación la

139
00:13:19,170 --> 00:13:26,530
notación de overnight para indicar al compilador que estamos escribiendo un método de la clase padre.

140
00:13:26,730 --> 00:13:30,600
Aquí nos marca algo más el Live que necesitamos crear el Java Doc.

141
00:13:30,600 --> 00:13:34,160
Vamos a dar clic simplemente para agregar este ya vacío.

142
00:13:34,500 --> 00:13:40,560
Pero aquí lo interesante es que el compilador nos agrega esta ONG de que estamos escribiendo el método

143
00:13:40,560 --> 00:13:48,280
de la clase empleado y como indica aquí para ir al método ancestro podemos presionar contra el chip.

144
00:13:48,300 --> 00:13:54,720
Así que si presionamos sobre el método contra el chip nos lleva a la definición del método padre.

145
00:13:54,780 --> 00:13:57,690
El método que estamos ocultando o sobre escribiendo

146
00:14:00,460 --> 00:14:04,950
bien vamos a quitar este comentario de Java Doc no es necesario a menos que ustedes quieran agregarlo

147
00:14:05,440 --> 00:14:10,590
bien pero con esto podemos observar que podemos utilizar la notación de averigue para indicar al compilador

148
00:14:10,590 --> 00:14:14,310
que vamos a sobreescribir un método de una clase padre.

149
00:14:14,340 --> 00:14:20,310
Esta anotación no es necesaria pero es recomendable agregarla para que líder también detecte que estamos

150
00:14:20,460 --> 00:14:26,550
escribiendo un método de la clase padre además de que estamos ayudando al compilador para que detecte

151
00:14:26,580 --> 00:14:31,070
automáticamente que estamos escribiendo un método de la clase padre.

152
00:14:31,080 --> 00:14:37,080
Un detalle más en la escritura de métodos es que no podemos cambiar por ejemplo el nombre debe de ser

153
00:14:37,080 --> 00:14:42,630
exactamente el mismo no lo podemos cambiar así que en la clase padre el método se llama obtener detalles

154
00:14:42,980 --> 00:14:46,030
y también en la clase hija se debe de llamar exactamente igual.

155
00:14:46,050 --> 00:14:50,020
El tipo de dato tampoco lo podemos modificar debe de ser el mismo.

156
00:14:50,040 --> 00:14:53,180
Lo único que podemos variar es el modificador de acceso.

157
00:14:53,280 --> 00:14:58,430
Por ejemplo si lo hacemos más restrictivo vamos a ponerlo como protected.

158
00:14:58,540 --> 00:15:04,630
Hay una regla en la escritura que no podemos asignar un modificador de acceso más restrictivo ya que

159
00:15:04,630 --> 00:15:06,850
en el caso del método padre fue público.

160
00:15:06,850 --> 00:15:11,720
No podemos sobreescribir un método e indicar que tenga un modificado el acceso más restrictivo.

161
00:15:11,860 --> 00:15:14,610
Así que por ello en este caso nos marca este error.

162
00:15:14,620 --> 00:15:21,200
No podemos hacer si en la clase de padre el modificador de acceso es públic en la clase e hija.

163
00:15:21,200 --> 00:15:27,440
La escritura no puede tener un modificador más restrictivo pero si por ejemplo en la clase padre en

164
00:15:27,440 --> 00:15:33,470
lugar de Public utilizáramos por ejemplo de opacas es decir en ausencia de modificador se convierte

165
00:15:33,530 --> 00:15:34,570
en opacas.

166
00:15:35,060 --> 00:15:41,150
Entonces la escritura es decir en la clase hija podríamos hacerlo menos restrictivo entonces de default

167
00:15:41,150 --> 00:15:49,360
opacas lo podemos cambiar por ejemplo hacia Public y en este caso únicamente está fallando la llamada

168
00:15:49,420 --> 00:15:54,730
al objeto de la clase padre ya que estamos dentro de otra clase y no podemos mandar a llamar.

169
00:15:54,730 --> 00:15:57,960
Un método que es de falopa cazzo dentro de otro paquete.

170
00:15:57,970 --> 00:16:02,230
Esta clase de ejemplos sobre escritura tendría que estar en el mismo paquete para que este método pudiera

171
00:16:02,230 --> 00:16:09,090
ser utilizado pero podemos observar que el método obtener detalles funciona sin ningún problema.

172
00:16:09,240 --> 00:16:13,130
Vamos a poner esta línea entre comentarios para poder realizar la prueba.

173
00:16:13,200 --> 00:16:17,490
Guardamos cambios y ejecutamos y con eso podemos ver que podemos mandar a llamar.

174
00:16:17,490 --> 00:16:21,600
Este método que es menos restrictivo en la clase hija sin ningún problema.

175
00:16:22,230 --> 00:16:30,200
Aunque la clase padre este método es más restrictivo es decir de falopa catch en la clase fija estamos

176
00:16:30,200 --> 00:16:31,910
abriendo más este método.

177
00:16:32,060 --> 00:16:38,870
Es decir que lo estamos haciendo menos restrictivo o en este caso público así que son las reglas para

178
00:16:38,870 --> 00:16:44,610
sobreescribir un método en Java sin embargo lo común es que si estamos utilizando por ejemplo públic

179
00:16:45,030 --> 00:16:49,410
en la clase padre también en la clase e hija vamos a utilizar el mismo modificador de acceso.

180
00:16:49,740 --> 00:16:52,180
Sin embargo estamos preparando una certificación.

181
00:16:52,200 --> 00:16:57,360
Esto puede ser preguntá de certificación que en la clase e hija el modificador de acceso puede variar

182
00:16:57,540 --> 00:17:00,210
pero únicamente hacerlo menos restrictivo.

183
00:17:00,330 --> 00:17:06,270
Si hacemos más receptivo el método que estamos escribiendo no va a funcionar la escritura así que eso

184
00:17:06,270 --> 00:17:09,150
es todo por esta elección y nos vemos en el siguiente video.

185
00:17:09,150 --> 00:17:09,770
Saludos.
