1
00:00:00,840 --> 00:00:02,460
Hola y bienvenidos a esta elección.

2
00:00:02,460 --> 00:00:06,930
A continuación vamos a ver el tema de sobrecarga de métodos en Java están listos.

3
00:00:06,990 --> 00:00:11,650
Vamos vamos a cerrar este proyecto y vamos a crear un nuevo

4
00:00:17,190 --> 00:00:22,250
enfile new project Java Web Maybe en Java Application.

5
00:00:22,320 --> 00:00:25,740
Y el nombre del proyecto se va a llamar sobrecarga métodos

6
00:00:28,590 --> 00:00:34,060
lo depositamos en la carpeta de cursos diagonal Java en nombre del paquete lo dejamos vació y damos

7
00:00:34,060 --> 00:00:35,640
clic en Finalizar.

8
00:00:35,770 --> 00:00:40,810
Vamos a agregar una nueva clase click derecho ni un Java class y el nombre de la clase se va a llamar

9
00:00:40,870 --> 00:00:44,880
operaciones y damos en finalizar

10
00:00:49,540 --> 00:00:50,840
esta clase de operaciones.

11
00:00:50,880 --> 00:00:53,190
Va a tener un método llamado sumar.

12
00:00:53,190 --> 00:00:57,990
Sin embargo ese método va a poder recibir varios argumentos de varios tipos.

13
00:00:58,140 --> 00:01:03,810
Esto quiere decir que vamos a sobrecargar el método sumar al agregar dos o más métodos con el mismo

14
00:01:03,810 --> 00:01:04,400
nombre.

15
00:01:04,560 --> 00:01:10,380
Así que esto es la sobrecarga de métodos agregar dos o más métodos con el mismo nombre con diferentes

16
00:01:10,380 --> 00:01:15,750
argumentos y vamos a ver a continuación varias de las reglas para definir la sobrecarga de métodos en

17
00:01:15,750 --> 00:01:16,330
Java.

18
00:01:16,470 --> 00:01:21,920
Por ejemplo en este caso vamos a definir nuestro primer método el primer método de sumar va a ser de

19
00:01:21,920 --> 00:01:25,340
tipo Public para que pueda ser llamado desde otras clases.

20
00:01:25,340 --> 00:01:30,080
Va a ser estático para que no haya necesidad de crear instancias para mandar a llamar.

21
00:01:30,080 --> 00:01:38,360
Estos métodos va a regresar un entero y el método se va a llamar sumar va a recibir dos argumentos el

22
00:01:38,360 --> 00:01:46,600
argumento de A y B respectivamente y vamos a hacer un gritón de la suma de estos argumentos además de

23
00:01:48,080 --> 00:01:52,850
sin embargo vamos a mandar un mensaje a consola para saber cuál es el método que se está ejecutando

24
00:01:53,330 --> 00:01:58,820
ya que como vamos a tener varios métodos con el mismo nombre entonces queremos saber cuál es el método

25
00:01:58,820 --> 00:02:07,170
sobrecargado que se está ejecutando así que mandamos a imprimir método sumar con los argumentos de tipo

26
00:02:07,230 --> 00:02:12,790
entero ambos argumentos son de tipo entero.

27
00:02:12,930 --> 00:02:18,030
Hasta aquí todavía no existe la sobrecarga de métodos ya que para sobrecargar un método debe de haber

28
00:02:18,030 --> 00:02:20,880
al menos otro método con el mismo nombre.

29
00:02:21,150 --> 00:02:29,850
Así que vamos a definir otro método aquí sería la sobrecarga del método sumar definimos.

30
00:02:29,850 --> 00:02:39,220
Otro método es público de tipo Static pero en este caso va a regresar un doble y el método se llama

31
00:02:39,220 --> 00:02:43,120
también sumar así que en este caso es cuando existe la sobrecarga.

32
00:02:43,120 --> 00:02:48,540
Tenemos dos o más métodos con el mismo nombre pero los argumentos no pueden ser iguales.

33
00:02:50,080 --> 00:02:55,840
Debe de tener diferentes argumentos en este caso los argumentos en lugar de ser de tipo entero son de

34
00:02:55,840 --> 00:03:03,520
tipo doble y en el cuerpo de este método vamos a hacer lo siguiente Vamos a retornar la suma de ambas.

35
00:03:04,450 --> 00:03:10,030
Pero con los argumentos de tipo doble que estamos recibiendo y de igual manera vamos a mandar un mensaje

36
00:03:10,090 --> 00:03:17,450
a consola método sumar pero con los argumentos de tipo doble.

37
00:03:17,730 --> 00:03:20,950
Así que este método ya se considera un método sobrecargado.

38
00:03:21,300 --> 00:03:26,760
Ahora para aullaba únicamente se va a revisar que los argumentos sean distintos ya que incluso el orden

39
00:03:26,760 --> 00:03:32,970
de los argumentos importa pero únicamente va a considerar los tipos y no los nombres los nombres los

40
00:03:32,970 --> 00:03:35,960
va a omitir y únicamente le interesa revisar los tipos.

41
00:03:36,090 --> 00:03:43,130
Así que en este caso tenemos el tipo int e int y en este caso tenemos el tipo doble y el tipo doble.

42
00:03:43,470 --> 00:03:48,600
Pero también podríamos definir por ejemplo un tipo int y con que tuviéramos un tipo doble de este lado

43
00:03:48,720 --> 00:03:53,730
entonces ya tenemos diferentes argumentos o podríamos tener también por ejemplo un doble de este lado

44
00:03:54,020 --> 00:04:01,710
y un int de este lado y con eso sería suficiente para tener la combinación de indol o de doble Int.

45
00:04:02,030 --> 00:04:08,330
Cualquier intercambio que hagamos con los argumentos no sean iguales el mismo tipo entonces se considera

46
00:04:08,360 --> 00:04:10,090
una sobrecarga de métodos.

47
00:04:10,250 --> 00:04:16,280
Así que el nombre de las variables no se considera solamente los tipos y el orden de los tipos.

48
00:04:16,280 --> 00:04:21,910
Otra de las características en la sobrecarga de métodos es que podemos modificar el tipo de retorno.

49
00:04:21,920 --> 00:04:27,980
Podemos ver que no importa si los tipos de retorno son diferentes se sigue considerando una sobrecarga

50
00:04:28,010 --> 00:04:32,670
vãlida y también podríamos cambiar incluso el modificador de acceso.

51
00:04:32,720 --> 00:04:38,870
Podríamos tener un método privado y otro público y como en los constructores también se seguiría considerando

52
00:04:38,930 --> 00:04:44,660
una sobrecarga del método sumar así que esas son las reglas para definir la sobrecarga de métodos en

53
00:04:44,660 --> 00:04:45,460
Java.

54
00:04:45,710 --> 00:04:53,690
Bien vamos a crear una clase para poner en prueba esto damos derecho a new Java class y el nombre de

55
00:04:53,690 --> 00:04:59,960
la clase se va a llamar sobrecarga métodos damos en finalizar

56
00:05:03,500 --> 00:05:11,780
vamos a llegar a un método main damos formato y vamos a utilizar nuestro método sumar pero aquí lo interesante

57
00:05:11,780 --> 00:05:13,840
va a ser cuál es el método que se manda llamar.

58
00:05:13,880 --> 00:05:21,240
Dependiendo de los argumentos que enviemos al método sumar así que vamos a imprimir lo siguiente Vamos

59
00:05:21,240 --> 00:05:28,980
a hacer una primera operación así que ponemos resultado 1 y vamos a utilizar el nombre de nuestra clase

60
00:05:29,580 --> 00:05:30,510
para mandar a llamar.

61
00:05:30,510 --> 00:05:36,300
El método estático y podemos observar que ya se nos muestran las dos opciones así que la sobrecarga

62
00:05:36,300 --> 00:05:42,060
de métodos es tener dos o más métodos con el mismo nombre podemos sumar que ya tenemos el mismo nombre

63
00:05:42,810 --> 00:05:44,850
pero tenemos diferentes argumentos.

64
00:05:44,970 --> 00:05:51,720
En este caso los argumentos de doble y doble respectivamente y los argumentos de INT e Inter respectivamente

65
00:05:52,050 --> 00:05:57,270
y también tenemos el tipo de regreso en el primer caso es doble y en el segundo caso es Int.

66
00:05:57,450 --> 00:06:01,620
Así que el tipo de retorno como hemos comentado puede cambiar bien.

67
00:06:01,770 --> 00:06:08,250
Así que en primer lugar vamos a utilizar nuestro método que recibe dos enteros así que vamos a proporcionar

68
00:06:08,250 --> 00:06:12,000
las literales enteras 3 y 4 respectivamente.

69
00:06:12,300 --> 00:06:17,720
Guardamos cambios y ejecutamos y vamos a ver cuál es el método que se manda llamar

70
00:06:20,960 --> 00:06:26,440
y podemos observar que en este caso se mandan a llamar el método sumar con dos argumentos de tipo entero

71
00:06:26,790 --> 00:06:33,850
y el resultado de sumar tres +4 es igual a 7 así que hasta aquí todo funciona sin ningún problema.

72
00:06:33,850 --> 00:06:37,000
Vamos a ver un segundo ejemplo resultado 2

73
00:06:40,740 --> 00:06:48,720
de igual manera mandamos a llamar ahora el método sumar por ejemplo 2 y 4 ahora para qué mala llamar

74
00:06:48,810 --> 00:06:51,480
el método con valores de tipo doble.

75
00:06:51,480 --> 00:06:57,870
Podemos utilizar punto flotante por ejemplo 2.0 o indicar que esta literal en lugar de ser de tipo entero

76
00:06:58,800 --> 00:07:03,610
podemos indicar que sea de tipo doble o de tipo flotante.

77
00:07:03,660 --> 00:07:09,180
Cualquier duda con esto pueden revisar las lecciones de tipos primitivos en este caso vamos a poner

78
00:07:09,360 --> 00:07:17,290
2.0 y aunque tenemos una literal de tipo entero vamos a ver cuál es el método que se manda llamar ejecutamos

79
00:07:18,710 --> 00:07:25,160
y podemos observar que el método que se mandó a llamar es el método sumar con dos argumentos de tipo

80
00:07:25,160 --> 00:07:25,520
doble.

81
00:07:26,120 --> 00:07:30,870
Así que aunque uno de sus argumentos fue de tipo entero ya no se puede mandar a llamar.

82
00:07:30,950 --> 00:07:36,710
El método con dos enteros ya que uno de sus argumentos es de tipo doble y recordemos que un valor de

83
00:07:36,710 --> 00:07:43,370
tipo doble no se puede almacenar en un tipo entero ya que podríamos perder precisión al almacenar un

84
00:07:43,370 --> 00:07:49,930
tipo doble el cual tiene 64 bits y querer almacenarlo en un tipo entero que tiene 32 bits.

85
00:07:50,360 --> 00:07:56,090
Así que por ello se está mandando llamar el método con dos argumentos de tipo doble bien vamos a continuar

86
00:07:56,090 --> 00:08:03,800
vamos a agregar otro método sobrecargado vamos a agregar ahora el método públic Static de tipo doble

87
00:08:07,010 --> 00:08:14,250
y vamos a recibir dos argumentos pero el primero va a ser de tipo entero y el segundo va a ser de tipo

88
00:08:14,250 --> 00:08:21,730
doble esto para revisar que también importa el orden en que definimos los argumentos mandamos a imprimir

89
00:08:22,000 --> 00:08:35,450
método sumar pero con los argumentos de INT y Nobol respectivamente y hacemos al botón de Hamás de y

90
00:08:35,460 --> 00:08:40,080
también vamos a agregar otro método públic Static Nobol

91
00:08:42,880 --> 00:08:49,260
llamado sumar pero vamos a intercambiar los tipos de los argumentos.

92
00:08:49,320 --> 00:08:53,830
Ahora el primer argumento es de tipo doble y el segundo argumento es de tipo int.

93
00:08:54,150 --> 00:09:01,990
Mandamos a imprimir que se manda llamar el método sumar pero con los argumentos de doble respectivamente

94
00:09:04,680 --> 00:09:10,410
y regresamos la suma de ambas ve bien con eso es suficiente ya tenemos varios métodos sobrecargados

95
00:09:12,330 --> 00:09:16,700
ahora vamos a ejecutar esta misma prueba y vamos a ver cuál es el método que se manda llamar.

96
00:09:16,700 --> 00:09:23,000
En esta línea debido a que ya agregamos más métodos sobrecargados vamos a ver que en este caso se mandó

97
00:09:23,020 --> 00:09:24,650
llamar el método doble doble.

98
00:09:24,870 --> 00:09:27,770
Pero ahora vamos a ver cuál es el método que se manda llamar.

99
00:09:27,990 --> 00:09:34,840
Guardamos cambios ejecutamos y podemos ver que ahora ya se manda llamar el método sumar pero con los

100
00:09:34,840 --> 00:09:40,960
argumentos de doble e int respectivamente ya que ya tenemos un método que soporta el tipo doble y el

101
00:09:40,960 --> 00:09:41,890
tipo entero.

102
00:09:41,890 --> 00:09:49,070
En este orden y si invertimos el orden en que pasamos los argumentos vamos a validar otra prueba

103
00:09:55,190 --> 00:10:03,330
podemos ver que ya tenemos más métodos sobrecargados más opciones y ahora la prueba va a ser tres y

104
00:10:03,330 --> 00:10:09,360
posteriormente pasamos el valor por ejemplo de cinco pero vamos a indicar que va a ser un tipo longe

105
00:10:09,870 --> 00:10:15,840
así que la pregunta aquí es cuál es el método que se manda llamar ya que estamos proporcionando un entero

106
00:10:16,110 --> 00:10:22,210
y un tipo lonko pueden poner pausa al video y revisar cuál es el método que se debería ejecutar

107
00:10:27,420 --> 00:10:27,760
bien.

108
00:10:28,130 --> 00:10:34,100
Esperemos que ya lo hayan resuelto pero en este caso para poder entenderlo a detalle estamos observando

109
00:10:34,340 --> 00:10:39,620
que vamos a mandar a llamar un tipo entero así que de entrada el primer argumento deberá de ser de tipo

110
00:10:39,620 --> 00:10:47,000
entero así que podría ser este método o este método ya que son los dos métodos de tipo entero que podemos

111
00:10:47,000 --> 00:10:47,930
ejecutar.

112
00:10:47,930 --> 00:10:54,680
Sin embargo el segundo argumento es de tipo longe así que de manera automática este método se debería

113
00:10:54,680 --> 00:11:02,000
de descartar ya que un tipo long tiene 64 bits y un tipo entero tiene 32 bits así que el siguiente método

114
00:11:02,000 --> 00:11:08,150
que se podría utilizar sería éste y debido a que un tipo longe se puede almacenar directamente a un

115
00:11:08,150 --> 00:11:14,030
tipo flotante de manera automática entonces este es el método que se debería mandar a llamar el método

116
00:11:14,030 --> 00:11:17,670
sumar con los argumentos de INT y doblón respectivamente.

117
00:11:17,690 --> 00:11:23,510
Esto debido a que no tenemos el método sobrecargado con el tipo log así que lo que va a hacer es hacer

118
00:11:23,570 --> 00:11:29,780
un casting o una conversión hacia arriba y a buscar el tipo que soporte de mejor manera almacenar su

119
00:11:29,780 --> 00:11:35,990
valor así que en este caso si hubiera tipo Oolong buscaría utilizar el método con un argumento de tipo

120
00:11:36,020 --> 00:11:37,400
longe como no existe.

121
00:11:37,400 --> 00:11:44,090
Entonces busca el tipo float y como tampoco existe entonces busca el tipo doble así que podemos observar

122
00:11:44,090 --> 00:11:49,940
que es bastante flexible en este caso hace una conversión hacia arriba de manera automática así que

123
00:11:49,940 --> 00:11:51,020
vamos a comprobar esto

124
00:11:54,150 --> 00:11:58,950
mandamos a llamar este método y podemos observar que el método que se mandó a llamar en nuestra prueba

125
00:11:58,950 --> 00:12:06,180
tres es el método de sumar con los argumentos de hit y dobles respectivamente así que recordemos que

126
00:12:06,180 --> 00:12:15,720
en primer lugar tenemos el tipo bait con 8 bits posteriormente tenemos el tipo Llort y el tipo Char

127
00:12:17,990 --> 00:12:29,790
con 16 bits posteriormente estos se pueden convertir a un tipo entero que tiene 32 bits posteriormente

128
00:12:29,850 --> 00:12:38,640
este se puede convertir a un tipo long de manera automática que tiene 64 bits y posteriormente empezamos

129
00:12:38,640 --> 00:12:40,330
con los tipos flotantes.

130
00:12:40,320 --> 00:12:43,500
El Long se puede almacenar a un tipo flotante

131
00:12:46,730 --> 00:12:51,070
y aunque tiene menos bits maneja la notación exponencial.

132
00:12:51,200 --> 00:12:56,480
Por lo tanto un valor de tipo no se puede almacenar en un tipo float debido a que maneja la notación

133
00:12:56,480 --> 00:13:04,050
exponencial y puede almacenar números bastante más grandes que el tipo log y finalmente el tipo doble

134
00:13:04,990 --> 00:13:11,320
es el más grande tiene 64 bits pero con notación exponencial así que este es el tipo que almacena los

135
00:13:11,320 --> 00:13:12,520
números más grandes.

136
00:13:12,610 --> 00:13:16,920
Así que en este caso el argumento Long busca un tipo log para almacenar.

137
00:13:17,020 --> 00:13:21,860
Como no existe esta firma de método entonces busca un tipo float como no existe.

138
00:13:21,970 --> 00:13:24,270
Entonces finalmente busca el tipo doble.

139
00:13:24,610 --> 00:13:31,420
Así que el método que se mandó a llamar es el método que recibe en primer lugar un entero y en segundo

140
00:13:31,420 --> 00:13:38,950
lugar un doble ya que se realizó la conversión hacia arriba o castin del tipo primitivo.

141
00:13:38,950 --> 00:13:43,620
Cualquier duda también pueden revisar los tipos primitivos pero básicamente esto es lo que está sucediendo.

142
00:13:43,660 --> 00:13:49,990
El tipo long busca asignarse a un tipo Flock y como no existe entonces busca asignarlo a un tipo doble

143
00:13:50,260 --> 00:13:51,580
y ese es el argumento que existe.

144
00:13:51,580 --> 00:13:54,400
Por lo tanto ese es el tipo que va a utilizar.

145
00:13:54,400 --> 00:13:58,210
Ahora vamos a poner otro ejemplo también para que lo puedan poner en práctica

146
00:14:02,260 --> 00:14:09,970
pero ahora los argumentos que vamos a proporcionar son los valores de 3 F es decir una litera flotante

147
00:14:10,180 --> 00:14:20,910
y el carácter de A. pueden poner pausa al vídeo y resolver cuál es el método que se va a mandar a llamar.

148
00:14:20,930 --> 00:14:25,370
Esperemos que ya lo hayan resuelto y ahora vamos a explicar cuál es el método que se manda a llamar

149
00:14:26,000 --> 00:14:29,750
para agregar a esta clase de lado derecho y poder analizar las dos clases.

150
00:14:29,810 --> 00:14:37,190
Vamos a dar clic derecho sobre esta clase y seleccionamos New document tap Group y de esta manera ya

151
00:14:37,190 --> 00:14:42,290
tenemos la clase de operaciones del lado izquierdo y la clase de sobrecarga de métodos del lado derecho

152
00:14:42,770 --> 00:14:47,810
y si queremos regresar esta clase de nueva cuenta como estaba del lado izquierdo entonces damos clic

153
00:14:47,810 --> 00:14:55,050
derecho y seleccionamos colapsã document tap Group y de esta manera ya regresamos.

154
00:14:55,050 --> 00:15:00,720
Como teníamos nuestras clases así que vamos a poner la del lado derecho click derecho nuevo documental

155
00:15:00,740 --> 00:15:06,970
Group y vamos a comenzar a analizar cuál es el método que se va a mandar a llamar así que en este caso

156
00:15:09,780 --> 00:15:17,100
tenemos los siguientes métodos sobrecargados y tenemos nuestro método sumar con los atributos de 3 F

157
00:15:17,340 --> 00:15:22,800
que es el tipo flotante y un tipo Char así que vamos a empezar a revisar cuáles son los métodos que

158
00:15:22,800 --> 00:15:24,080
se dejan de ejecutar.

159
00:15:24,270 --> 00:15:31,020
Por un lado tenemos el método con dos argumentos de tipo entero pero si revisamos nuestro primer argumento

160
00:15:31,080 --> 00:15:36,120
es de tipo flotante así que un flotante no se puede almacenar en un tipo entero.

161
00:15:36,120 --> 00:15:42,450
Por lo tanto este primer método se descartaría simplemente porque un tipo flotante tiene 32 bits y un

162
00:15:42,450 --> 00:15:47,140
tipo entero aunque también tiene 32 bits el flotante tiene notación exponencial.

163
00:15:47,280 --> 00:15:52,800
Por lo tanto un número flotante de manera automática no se puede almacenar en un tipo entero.

164
00:15:52,800 --> 00:15:58,710
Ahora posteriormente tenemos los métodos que reciben argumentos de tipo doble así que podría ser este

165
00:15:58,710 --> 00:16:03,980
método o podría ser este método también este método lo descartaría.

166
00:16:04,610 --> 00:16:10,580
Así que ya tenemos como dos candidatos el método sumar con los dos argumentos de tipo doble o con un

167
00:16:10,580 --> 00:16:13,390
argumento de tipo doble y un tipo entero.

168
00:16:13,520 --> 00:16:19,610
Ahora vamos a analizar el segundo argumento el tipo Char se puede almacenar en un tipo doble así que

169
00:16:19,610 --> 00:16:25,550
también este método es candidato y un tipo hecharse puede almacenar en un tipo entero y aunque no tenemos

170
00:16:25,550 --> 00:16:31,430
un tipo Char en nuestros métodos sobrecargados el tipo int puede funcionar para almacenarlo así que

171
00:16:31,430 --> 00:16:36,140
tanto el tipo Nobol como el tipo entero podrían funcionar para almacenar un tipo Char.

172
00:16:36,170 --> 00:16:41,570
Sin embargo cuál es el método que se manda a llamar ya va a seleccionar el tipo con menor número de

173
00:16:41,570 --> 00:16:46,910
bits así que en este caso en lugar de mandar a llamar el tipo Nobol va a mandar a llamar el tipo int

174
00:16:47,300 --> 00:16:48,920
para recibir el tipo Char.

175
00:16:48,950 --> 00:16:56,250
Vamos a ver la explicación de nueva cuenta tenemos los tipos primitivos bait con 8 bits.

176
00:16:56,560 --> 00:16:58,300
Posteriormente tenemos sort

177
00:17:01,000 --> 00:17:09,890
y Char al mismo nivel con 16 bits y un char recordemos que se puede convertir a un tipo entero por lo

178
00:17:09,890 --> 00:17:17,900
tanto el siguiente tipo primitivo que puede almacenar un char o un short es el tipo entero con 32 bits.

179
00:17:17,930 --> 00:17:25,690
Después tenemos el tipo long con 64 bits tenemos el tipo float

180
00:17:28,920 --> 00:17:38,750
con 32 bits pero con anotación exponencial y finalmente el tipo doble connotación exponencial de 64

181
00:17:38,750 --> 00:17:45,300
bits así que podemos observar que el tipo Char puede ser almacenado en un tipo doble o en un tipo int

182
00:17:45,610 --> 00:17:51,090
pero Char empieza su conversión hacia arriba es decir el casting y al no encontrar un tipo Char que

183
00:17:51,090 --> 00:17:54,340
lo pueda almacenar entonces busca el siguiente tipo.

184
00:17:54,360 --> 00:17:59,970
En este caso un tipo entero así que se va a quedar hasta aquí para poder utilizar la menor cantidad

185
00:17:59,970 --> 00:18:00,620
de bits.

186
00:18:00,720 --> 00:18:06,990
Si no tuviéramos este tipo entero entonces seguiría buscando buscaría un tipo log si no lo encontrara

187
00:18:07,200 --> 00:18:10,980
buscaría un tipo Floqq y si no lo encontrara buscaría un tipo doble.

188
00:18:11,430 --> 00:18:16,940
Así que por ello es que podemos observar que tanto este método con la firma del tipo doble o con la

189
00:18:16,940 --> 00:18:22,920
firma del tipo int en el segundo argumento podrían funcionar pero se va a quedar en el tipo entero ya

190
00:18:22,920 --> 00:18:28,440
que es el tipo con menor cantidad de bits así que el casting o conversión hacia arriba también va a

191
00:18:28,440 --> 00:18:30,660
ser lo más eficiente posible.

192
00:18:30,660 --> 00:18:32,010
Vamos a comprobar esto.

193
00:18:32,160 --> 00:18:33,990
Guardamos cambios y ejecutamos

194
00:18:43,160 --> 00:18:48,380
así que podemos observar finalmente que el método que se mandó a llamar en este último caso es el método

195
00:18:48,380 --> 00:18:55,340
que recibe los atributos de doble ya que el float se convirtió Adol y el char se convirtió a tipo entero

196
00:18:55,760 --> 00:19:02,170
y el resultado es igual a 68 ya que se suma el valor de tres y posteriormente el valor de 65.

197
00:19:02,180 --> 00:19:06,800
Recordemos que el carácter Char corresponde en decimal al valor de 65.

198
00:19:06,800 --> 00:19:12,140
Por lo tanto se realizó la conversión de Char a tipo entero y se utiliza el valor decimal.

199
00:19:12,140 --> 00:19:19,900
Por lo tanto el resultado de 3 más 65 tenemos el resultado de 68 bien por último se les deja realizar

200
00:19:19,900 --> 00:19:25,090
la prueba paso a paso para que resuelvan cualquier duda extra que pudieran tener con el tema de sobrecarga

201
00:19:25,090 --> 00:19:30,730
de métodos pero con esto ya debería quedar claro cómo funciona la sobrecarga de métodos en Java y cada

202
00:19:30,730 --> 00:19:35,810
una de las reglas que debemos de considerar cuando estamos trabajando con este concepto.

203
00:19:35,860 --> 00:19:38,700
Eso es todo por esta elección y nos vemos en el siguiente vídeo.

204
00:19:38,750 --> 00:19:39,340
Saludos.