1
00:00:00,150 --> 00:00:01,020
Bien, continuemos.

2
00:00:01,110 --> 00:00:02,940
Vamos a crear la clase con el método Main.

3
00:00:03,090 --> 00:00:04,740
Nos vamos al package como siempre.

4
00:00:04,920 --> 00:00:05,610
Derecho.

5
00:00:05,700 --> 00:00:07,490
New yaba class.

6
00:00:08,580 --> 00:00:10,290
Ejemplo sobrecarga.

7
00:00:13,250 --> 00:00:14,030
Y con el Main?

8
00:00:18,190 --> 00:00:23,200
Vamos a crear la instancia de Calculadora Cal Igual New Calculadora

9
00:00:28,840 --> 00:00:32,350
y comenzamos, tenemos la instancia, vamos a sumar dos entero.

10
00:00:32,590 --> 00:00:41,550
Entonces sumar enteros, como por ejemplo Call punto, sumar y acá tenemos la sobrecarga.

11
00:00:41,560 --> 00:00:47,740
Se fijan varios métodos, mismo nombre, pero distintos tipos de argumento y cantidad independientes.

12
00:00:47,740 --> 00:00:54,190
Uno retorna un entero, otros tipo float, flotantes o vinton se fijan independiente.

13
00:00:54,250 --> 00:00:56,080
Lo importante son los argumentos.

14
00:00:56,320 --> 00:00:58,930
Lo único que importa en este caso vamos a sumar entero.

15
00:00:59,050 --> 00:01:02,020
Entonces se debería de invocar este método.

16
00:01:02,140 --> 00:01:02,950
Esta sobrecarga.

17
00:01:03,550 --> 00:01:07,420
Entonces, por ejemplo, 10 y 5.

18
00:01:07,600 --> 00:01:11,290
Si se fijan automáticamente acá no indica cuál va a ser el método.

19
00:01:11,470 --> 00:01:16,780
El que recibe el entero a y el entero de claro es justamente por el tipo de dato que estamos pasando.

20
00:01:18,580 --> 00:01:20,470
Veamos un ejemplo con flotantes

21
00:01:22,960 --> 00:01:34,510
sumar float 2 punto, un espacio sumar y acá vamos a colocar 10, por ejemplo coma cero para negar que

22
00:01:34,510 --> 00:01:40,540
un decimal, pero tenga que indicar que el tipo flotante float con F puede ser F mayúscula minúscula

23
00:01:40,690 --> 00:01:42,790
coma cinco F.

24
00:01:43,030 --> 00:01:50,610
Acá se selecciona el float X y el float y esa sobrecarga se fijan de acuerdo al tipo dato de forma automática.

25
00:01:50,800 --> 00:01:57,620
Incluso sobre el método sumar aparece el método que se va a invocar, que se va a llamar float, que

26
00:01:57,640 --> 00:02:01,390
retorna float y recibe el float x y el float y.

27
00:02:01,510 --> 00:02:08,470
A diferencia de este, como son dos entero acá va a invocar el entero a y dentro de esa sobrecarga.

28
00:02:09,730 --> 00:02:17,770
Pero también podríamos tener combinaciones sumar por ejemplo float int 2 punto.

29
00:02:21,190 --> 00:02:22,270
Bien, entonces comencemos.

30
00:02:22,420 --> 00:02:28,420
Vamos a sumar un flotante 10 f coma y un entero 5.

31
00:02:28,530 --> 00:02:32,320
Entonces sea invocar esta sobrecarga float i y entero.

32
00:02:32,380 --> 00:02:35,170
J el segundo sería entero y el primero flotante.

33
00:02:35,420 --> 00:02:37,150
Bien puede estar en minúscula o mayúscula.

34
00:02:37,210 --> 00:02:37,750
Recuerden

35
00:02:41,530 --> 00:02:45,790
sumar y al revés Integer y float

36
00:02:49,870 --> 00:02:53,320
diez coma cinco cero.

37
00:02:53,980 --> 00:03:01,690
Si se fijan como no puse f o float puse 5.0 por defecto el doble, entonces se va a seleccionar esta

38
00:03:01,690 --> 00:03:03,520
sobrecarga de forma automática.

39
00:03:03,580 --> 00:03:10,510
Va a convertir el entero 10 a un tipo double de que se puede convertir un tipo de menor tamaño que sería

40
00:03:10,600 --> 00:03:16,570
un entero de 32 bits a un doble, que sería un número flotante de 64 bits.

41
00:03:16,780 --> 00:03:22,390
Por lo tanto, se puede hacer, se puede convertir eso en caso de que no indique el float.

42
00:03:23,080 --> 00:03:29,740
Pero si acá indico que es float, ya deja de ser double y selecciona este acá entero y por lo tanto

43
00:03:29,740 --> 00:03:34,780
está perfecto, entero con entero y flotante con flotante, un float con flota acá.

44
00:03:35,650 --> 00:03:36,790
Entonces aflojamos de esa forma.

45
00:03:37,000 --> 00:03:39,430
Hay que tratar de ser lo más explícito posible.

46
00:03:40,600 --> 00:03:43,580
Shout sumar double.

47
00:03:49,570 --> 00:03:56,800
Ahora sé que si, por ejemplo 10 da lo mismo, puede ser de esta forma con la de o de mayúscula coma

48
00:03:56,890 --> 00:04:00,420
cinco de picas son dos double.

49
00:04:00,730 --> 00:04:02,850
Pero lo estoy indicando con la letra B.

50
00:04:03,310 --> 00:04:10,450
Bueno, por defecto es 10 punto cero y acá 5.0, pero del tipo double o bien punto cero.

51
00:04:10,900 --> 00:04:11,740
Y acá también.

52
00:04:12,070 --> 00:04:12,630
Punto cero.

53
00:04:12,880 --> 00:04:13,600
Por la literal.

54
00:04:13,690 --> 00:04:19,030
Cuando hay un punto por defecto, el doble, entonces se va a llamar o se va a invocar este método.

55
00:04:19,570 --> 00:04:24,550
Acá lo tenemos Tobón y recibe el doble A y el doble y los suma.

56
00:04:27,790 --> 00:04:29,080
Sumar es trenca.

57
00:04:33,310 --> 00:04:37,720
Bueno, un strength 10 y otro 5.

58
00:04:38,680 --> 00:04:42,450
Llega tenemos, retorna uno entero, pero suma dos estric OIV.

59
00:04:42,940 --> 00:04:45,490
Ese es el método que se va a llamar en la sobrecarga

60
00:04:50,950 --> 00:04:52,240
sumar tres enteros.

61
00:04:58,710 --> 00:05:01,560
Por ejemplo, 10, 5 y 3.

62
00:05:01,990 --> 00:05:08,640
Bueno, éste se selecciona entero antro de entero, se está sobrecarga, así que está perfecto.

63
00:05:08,790 --> 00:05:14,790
Ahora veamos la conversión automática de tipos cuando, por ejemplo, quiero sumar tipos de datos que

64
00:05:14,790 --> 00:05:20,460
son de menor tamaño, pero que compatible con alguno de estos métodos que reciba parámetros de mayor

65
00:05:20,460 --> 00:05:21,770
tamaño pero compatible.

66
00:05:21,870 --> 00:05:27,210
Por ejemplo, si quiero sumar lonko, pero no tenemos el método implementado que suma zol lonko, por

67
00:05:27,210 --> 00:05:27,570
ejemplo.

68
00:05:27,630 --> 00:05:31,320
Pero bien, como no lo tenemos, va a buscar un método que coincida.

69
00:05:31,410 --> 00:05:37,140
Es decir, que sume dos números compatibles de mayor tamaño y cuál va a seleccionar el más cercano.

70
00:05:37,170 --> 00:05:42,960
Por ejemplo, el que suma flotantes float o doble, pero el más cercano es el flop.

71
00:05:43,050 --> 00:05:50,310
Por lo tanto, va a invocar o va a llamar a este método al que suma los dos float x y diga.

72
00:05:51,620 --> 00:05:52,100
Veamos

73
00:05:56,990 --> 00:05:57,800
del tipo lonco.

74
00:06:01,550 --> 00:06:11,030
10 L Koma 5 l tontón lonko se fijan busca y selecciona e float X y offroad y bueno, la aplicación se

75
00:06:11,030 --> 00:06:17,900
debe a que el LOC es de 64 bits que para almacenar enteros grandes, pero sin embargo el float es de

76
00:06:17,900 --> 00:06:24,530
menor tamaño de 32 bits, pero puede almacenar número mucho mayores, ya que maneja el formato o la

77
00:06:24,530 --> 00:06:27,170
notación científica se guardan con el exponente.

78
00:06:27,380 --> 00:06:31,520
Entonces un long se puede almacenar dentro de un float sin ningún problema.

79
00:06:31,610 --> 00:06:32,450
Es compatible.

80
00:06:32,510 --> 00:06:35,540
Entonces por eso selecciona ese método con los flotantes.

81
00:06:35,720 --> 00:06:41,930
Ahora, si no tuviéramos este método implementado, seleccionaría el doble que de hecho permite guardar

82
00:06:42,020 --> 00:06:49,160
mucha más capacidad porque de 64 bits y además soporta la notación científica con el exponente.

83
00:06:49,340 --> 00:06:54,870
Es decir, podríamos guardar en el double número muchísimo más grande que el máximo que soporta el lonko.

84
00:06:55,040 --> 00:06:56,110
Entonces también sería compatible.

85
00:06:56,360 --> 00:06:57,590
De hecho, lo pudiéramos probar.

86
00:06:57,710 --> 00:07:03,560
Veamos qué pasa si comentamos este acá el float x y float y lo voy a comentar.

87
00:07:03,830 --> 00:07:06,470
No es necesario que lo hagan, pero solamente para que lo veamos.

88
00:07:06,560 --> 00:07:07,490
Lo comentamos.

89
00:07:08,300 --> 00:07:09,080
Perfecto.

90
00:07:09,620 --> 00:07:10,820
Veamos cual se invoca.

91
00:07:12,040 --> 00:07:14,560
El doble A y B se fijan.

92
00:07:14,680 --> 00:07:16,390
Y qué pasa con este también?

93
00:07:16,480 --> 00:07:19,430
Sumar doble A y golpe.

94
00:07:19,900 --> 00:07:24,280
Justamente porque el float es de menor tamaño de 32 bits.

95
00:07:24,460 --> 00:07:30,100
Entonces va a buscar algún tipo compatible que sea mayor y que se pueda almacenar y vuelve a contar

96
00:07:30,250 --> 00:07:32,050
el que suma los DOPO.

97
00:07:32,560 --> 00:07:35,560
Llega también como el log de menor tamaño.

98
00:07:35,770 --> 00:07:38,320
Encuentra el compatible el doble.

99
00:07:38,680 --> 00:07:40,690
El método sobrecargado con los dos.

100
00:07:40,780 --> 00:07:42,460
Doblón este acá.

101
00:07:44,250 --> 00:07:45,390
Bien, voy a volver.

102
00:07:45,780 --> 00:07:46,650
Lo dejé como estaba.

103
00:07:48,760 --> 00:07:53,930
Entonces sabemos si queremos sumar lonko va a seleccionar la sobrecarga con los float.

104
00:07:54,790 --> 00:07:55,390
Es todo acá.

105
00:07:55,600 --> 00:08:00,190
A menos que implemente uno paralelo, por ejemplo, tampoco es necesario que lo hagan.

106
00:08:01,150 --> 00:08:02,260
Lo voy a hacer acá.

107
00:08:02,350 --> 00:08:03,270
Voy a colocar lonko.

108
00:08:04,690 --> 00:08:05,260
Deja también.

109
00:08:09,520 --> 00:08:11,160
Bien, se colocó entero.

110
00:08:12,150 --> 00:08:17,610
No sé, yo podría haber perdido información porque estoy sumando dos números long, que mucho mayor

111
00:08:17,640 --> 00:08:18,360
que un entero.

112
00:08:18,510 --> 00:08:23,250
Entonces, por supuesto, se sumó dos log tengo que retornar un tipo compatible, lonko.

113
00:08:24,850 --> 00:08:33,190
Jassi Y ahora este long be embocar esta nueva sobrecarga que recibe los dos lonko se fijen.

114
00:08:34,700 --> 00:08:36,890
Pero la idea de ver la conversión automática.

115
00:08:36,980 --> 00:08:38,180
Entonces te quitas.

116
00:08:41,880 --> 00:08:46,200
Y los loc@ se van a sumar con la sobrecarga de lo flotante o de los dobl.

117
00:08:46,590 --> 00:08:47,640
Bien, veamos otro ejemplo.

118
00:08:50,730 --> 00:08:54,150
Sumar enteros, pero con una diferencia.

119
00:08:55,290 --> 00:08:57,690
Punto sum sumar.

120
00:08:58,290 --> 00:09:05,490
Qué pasa si colocamos, por ejemplo, ya diez coma un char el arroba?

121
00:09:07,070 --> 00:09:09,260
Se fijan, funciona bien, no marca ningún error.

122
00:09:09,380 --> 00:09:09,980
Y por qué?

123
00:09:10,070 --> 00:09:16,010
Recuerden que un carácter también tiene su representación decimal en número en la tabla y único.

124
00:09:16,190 --> 00:09:18,140
Por ejemplo, el arroba.

125
00:09:18,410 --> 00:09:26,180
Si nos vamos a la página de Wikipedia lista de caracteres y único bueno en inglés list of y único caracteres

126
00:09:27,050 --> 00:09:27,800
más abajo.

127
00:09:27,860 --> 00:09:29,270
Por acá tengo que buscar el arroba.

128
00:09:29,600 --> 00:09:30,560
Acá tenemos el ejemplo.

129
00:09:30,620 --> 00:09:33,980
Acá está la година y corresponde al decimal 64.

130
00:09:34,070 --> 00:09:36,920
Por lo tanto su representación en número es 7 y 4.

131
00:09:37,490 --> 00:09:41,480
Y también podemos revisarlo en la página jónico Tapley puntocom.

132
00:09:42,170 --> 00:09:46,580
Acá también está la година y acá dice decimal 64.

133
00:09:46,910 --> 00:09:48,140
Se fijan por sobre.

134
00:09:48,290 --> 00:09:49,400
Incluso hacemos un clic.

135
00:09:50,240 --> 00:09:53,090
Y también lo muestra en el código HTML acá.

136
00:09:53,540 --> 00:09:54,410
64.

137
00:09:55,190 --> 00:09:58,160
Entonces al final va a sumar 10 más 64.

138
00:09:59,330 --> 00:10:05,510
Y por supuesto, el método que se llama es el que suma 12 entero, ya que el carácter es un entero,

139
00:10:05,510 --> 00:10:07,490
también una representación de un decimal.

140
00:10:09,940 --> 00:10:10,530
Shout.

141
00:10:13,490 --> 00:10:15,050
Float int.

142
00:10:18,650 --> 00:10:19,310
Ahora desembocamos.

143
00:10:19,340 --> 00:10:22,520
10 f coma arroba.

144
00:10:22,760 --> 00:10:24,410
Cual sea invocar lo mismo.

145
00:10:24,620 --> 00:10:25,880
Recuerden que este es un entero.

146
00:10:25,970 --> 00:10:34,400
Por lo tanto se llamar al flog y integer int j de forma automática por la conversión iba a sumar 64

147
00:10:34,490 --> 00:10:38,020
más diez coma cero o .0 float.

148
00:10:38,510 --> 00:10:42,050
Ven y para probar voy a colocar un punto y quiero r. como por acá.

149
00:10:43,150 --> 00:10:49,810
En la línea 6 y lo vamos a ejecutar paso a paso para que veamos qué método sobrecargado se está llamando

150
00:10:50,350 --> 00:10:51,700
según los tiempos que estamos pasando.

151
00:10:51,850 --> 00:10:57,040
Aunque igual lo vimos según lo que nos va indicando el IDE, pero la idea de que ejecutemos paso a paso,

152
00:10:57,430 --> 00:10:59,590
entonces clic derecho de back.

153
00:11:03,110 --> 00:11:10,430
Bien, entonces ejecutamos este over y acá la idea, en vez de colocar step over step into para ir al

154
00:11:10,430 --> 00:11:11,990
detalle, se fijan.

155
00:11:12,080 --> 00:11:14,020
Seleccionamos sumar acá con un clic.

156
00:11:14,240 --> 00:11:17,780
Ahora, si amas B, se fijan entero a más entero.

157
00:11:18,050 --> 00:11:18,890
Así que está perfecto.

158
00:11:19,250 --> 00:11:20,720
Listo, volvemos.

159
00:11:21,570 --> 00:11:22,880
Ejecutamos el siguiente.

160
00:11:23,300 --> 00:11:25,940
Volvemos a ejecutar ahora un clic en Sumar.

161
00:11:26,820 --> 00:11:28,510
Se va al float float.

162
00:11:28,770 --> 00:11:29,310
Perfecto.

163
00:11:29,400 --> 00:11:30,270
Continuamos.

164
00:11:32,050 --> 00:11:33,820
Este tinto seleccionamos.

165
00:11:34,730 --> 00:11:36,740
Y se va al float int.

166
00:11:37,310 --> 00:11:38,090
Perfecto.

167
00:11:38,390 --> 00:11:41,980
Ejecutamos con step into, siempre con este punto.

168
00:11:43,490 --> 00:11:44,120
Sumar.

169
00:11:45,220 --> 00:11:49,180
Ahora al revés, se va al entero i y el j flop.

170
00:11:50,390 --> 00:11:51,200
Perfecto.

171
00:11:52,460 --> 00:11:58,310
Step into nuevamente sumar se va el que suma dos dobles.

172
00:11:59,920 --> 00:12:07,840
Este Pinto o este obert da lo mismo, nuevamente esté Pinto, esté Pinto y seleccionamos el que suma

173
00:12:07,900 --> 00:12:08,500
Strength.

174
00:12:09,580 --> 00:12:10,510
Se fijan acá.

175
00:12:12,650 --> 00:12:13,590
Step over.

176
00:12:13,730 --> 00:12:20,030
No quiero ir al detalle, solamente quiero pasar por encima perfecto y nos salimos el resultado de 15.

177
00:12:21,090 --> 00:12:21,690
Perfecto.

178
00:12:22,110 --> 00:12:25,560
Y de hecho, podríamos ir a consola, ir viendo el resultado de cada uno.

179
00:12:25,980 --> 00:12:27,000
Bueno, todos a15.

180
00:12:28,150 --> 00:12:30,550
Y continuamos este tinto.

181
00:12:32,040 --> 00:12:32,550
Sumar.

182
00:12:33,540 --> 00:12:34,740
Suma los tres enteros.

183
00:12:36,710 --> 00:12:37,880
Y acá suma los dos, lonko.

184
00:12:38,150 --> 00:12:45,580
Entonces vamos a ejecutar con Step Into, seleccionamos y se va able, que suma los dos float tipo auto

185
00:12:45,590 --> 00:12:47,150
compatible, el más cercano.

186
00:12:47,660 --> 00:12:48,470
Continuamos.

187
00:12:50,220 --> 00:12:56,490
El siguiente, el que suma el 10 con el arroba, pone carretera година que corresponde al número 64,

188
00:12:56,700 --> 00:12:59,430
así que el resultado debería ser setenta y cuatro.

189
00:13:00,740 --> 00:13:01,400
Sumar.

190
00:13:02,610 --> 00:13:05,210
Ahí sí y recibe dos entero.

191
00:13:06,030 --> 00:13:06,930
Y el valor bueno.

192
00:13:07,770 --> 00:13:08,910
Maffia 74.

193
00:13:10,690 --> 00:13:13,240
Lo ejecutamos, se fijan 74.

194
00:13:13,420 --> 00:13:17,040
Ahí está del último lo mismo, pero float.

195
00:13:18,430 --> 00:13:23,230
Stepp Pinto Seleccionamos Sumar con un clic float y entero.

196
00:13:24,190 --> 00:13:26,200
Ejecutamos y ejecutamos.

197
00:13:26,740 --> 00:13:34,710
Acá sería un 74 punto, será porque flotante faltó dos puntos espacio y eso sería nada más.

198
00:13:34,720 --> 00:13:36,660
Continuamos en la siguiente clase.