Saltar navegación

20240920 ProgrEstruct-Variables_7 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 21 de septiembre de 2024 por Raquel G.

19 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, hay veces que nuestros datos no se adaptan a un número entero, obviamente, ¿no? 00:00:00
El precio de algo, 3,7. 00:00:07
Pues con un número entero no puedo guardar el precio de algo. 00:00:11
Y así como tantas cosas. 00:00:13
Las medidas de una casa. 00:00:15
Una casa no mide 3 por 4, sino mide 3,7 por 4,8. 00:00:17
Entonces necesitamos variables decimales en todos los lenguajes de programación, también en el nuestro. 00:00:21
Vale, todos sabéis lo que es un número decimal. 00:00:26
Obviamente tiene parte entera, parte decimal. 00:00:27
Y para guardar ese tipo de números nosotros tenemos dos tipos primitivos que los incluimos en la lista ya, el primer día que son float y double, ¿vale? Única diferencia entre ellos, la precisión, la cantidad de precisión que dan para las cifras decimales, ¿vale? 00:00:30
dabel da doble precisión 00:00:48
float simple precisión 00:00:51
que se llama, esos detalles numéricos matemáticos 00:00:52
tampoco nos importan mucho 00:00:54
solo nos importan que si declaramos 00:00:55
un número decimal dabel 00:00:58
pues ya está, lo declaramos con el 00:01:00
con su nombre de tipo primitivo 00:01:02
y ya está 00:01:07
y ahora yo cuando le asigno un valor 00:01:08
le asigno un valor 00:01:10
que si quiero puede tener decimales 00:01:15
si quiero 00:01:17
yo puedo hacer esto 00:01:19
Y como veis lo ha cogido perfectamente 00:01:20
Y no hay ningún problema 00:01:23
Y si ahora lo muestro 00:01:24
En un decimal, vamos a poner aquí 00:01:30
System.app para que la consola 00:01:34
Sabe donde llegamos a 00:01:36
Pruebas 00:01:37
Con decimales 00:01:40
Vale 00:01:42
A ver, para ejecutar este código 00:01:43
Voy a quitar este errorcito 00:01:46
Cuando pusimos el ejemplo de byte 00:01:47
Vale, pues si ejecutamos 00:01:49
este código, esto de aquí 00:01:53
vale, él me lo ha mostrado 00:01:57
¿y qué ha ocurrido? 00:02:07
silencio 00:02:10
yo le he puesto 8, pero como 00:02:11
él lo tiene que guardar en un decimal 00:02:13
aquí es como si hiciera una promoción automática 00:02:14
rápidamente, le pone el punto 0 00:02:17
le pone el punto 0 porque lo guarda en decimal 00:02:19
y este número es decimal a todos los 00:02:21
efectos, ¿vale? 00:02:23
entonces 00:02:26
si yo quiero ponerle ya los decimales 00:02:27
pues se los pongo 00:02:30
pero separados con el punto 00:02:31
no con la coma, ¿vale? 00:02:34
por ejemplo 7.9 00:02:36
pues ya está, la variable 00:02:38
double me coge el 7.9 00:02:40
entonces el separador 00:02:43
de la parte anterior a la decimal 00:02:44
es el punto, no es la coma 00:02:45
¿vale? 00:02:48
vale, pues ya está y uno ya 00:02:50
puede sumar números decimales 00:02:52
entre sí, lo que sea 00:02:54
que quiere incrementar en 1 00:02:55
el contenido de este numerito decimal 00:02:57
bueno pues 00:03:01
por ejemplo con esto lo he incrementado 00:03:05
en 1, aquí estoy 00:03:07
haciendo una suma 00:03:09
estoy sumando 00:03:11
el número decimal este que es 7.9 00:03:12
le estoy sumando 1 00:03:16
aquí la máquina virtual ve 00:03:17
que está sumando un double 00:03:19
un entero para guardar en un double 00:03:21
pues este 1 00:03:23
le hace también la promoción automática 00:03:24
y le pone el punto cero 00:03:27
él automáticamente por dentro, le pone el punto cero 00:03:29
¿vale? 00:03:31
es decir, este operador está mezclando en realidad 00:03:33
un entero con un double 00:03:35
pero este entero le pone el punto cero detrás 00:03:36
porque no afecta 00:03:39
¿vale? entonces con números decimales 00:03:40
podemos hacer 00:03:43
sumas, restas, multiplicaciones y divisiones 00:03:45
igual que con los enteros 00:03:47
aquí lo único que la división 00:03:49
ahora ya no tendrá 00:03:52
significado de cociente, sino 00:03:53
la división con decimales, ¿vale? 00:03:55
Por ejemplo, si nos hacemos aquí un 00:03:57
num decimal 00:03:59
2 igual a 00:04:00
igual a 5.9 00:04:08
por ejemplo, ¿vale? 00:04:17
Y no lo he declarado, con lo cual 00:04:18
muy mal. 00:04:20
Vale, pues entonces 00:04:22
yo ahora puedo pues hacer esto 00:04:23
tranquilamente 00:04:26
y si hacéis el system out para 00:04:27
ver el resultado, pues habrá sumado 00:04:39
8 con 9 00:04:41
porque 7 con 9 al sumarle 1 00:04:43
se habrá quedado en 8 con 9 00:04:45
habrá sumado 8 con 9 00:04:47
a 5 con 9 y el resultado que dé 00:04:49
pues habrá dado 00:04:51
14 con algo, supongo, 14 con 8 00:04:53
lo que sea, para no hacer 00:04:55
el system todo el rato 00:04:57
vale, entonces 00:04:58
el operador suma y resta 00:05:00
y multiplicación 00:05:03
con números decimales, pues sabemos cómo funciona 00:05:05
porque estamos multiplicando 00:05:07
sumando y restando 00:05:09
números decimales en la calculadora todo el rato 00:05:11
la división 00:05:13
la división en este caso 00:05:16
no es el cociente entero 00:05:18
como era en el caso de números enteros 00:05:19
recordad que aquí, cuando hacíamos esta división 00:05:21
esta división era 00:05:24
entre números enteros 00:05:25
el 7 00:05:26
entre el n, el que fuera 00:05:28
o aquí, se ve más claro 00:05:31
aquí el operador división, este de aquí 00:05:33
dividía el número entero 7 00:05:35
entre el número entero 3 00:05:37
entonces aquí el operador significa 00:05:38
cociente 00:05:41
luego cuando lo mostrábamos ponía 2 00:05:42
porque el cociente de 73 es 2 00:05:45
el resto se ignora 00:05:48
y todo eso 00:05:50
¿qué queremos el resto? 00:05:50
pues tenemos este operador 00:05:52
¿qué ocurre cuando 00:05:53
utilizamos el operador 00:05:58
de división entre números decimales? 00:05:59
que ahí no es cociente 00:06:01
ahí es la división decimal 00:06:03
y ya está 00:06:04
por ejemplo si ahora vamos a guardar 00:06:05
en numDecimal vamos a guardar la división 00:06:08
de sí mismo, de lo que él tiene 00:06:11
dividido entre numDecimal2 00:06:13
¿vale? 00:06:16
entonces cogerá lo que tenga numDecimal 00:06:19
que va a ser 8,9 00:06:21
porque es este más lo que le hemos sumado, 8,9 00:06:22
lo dividirá entre lo que contenga esto 00:06:24
que es 5,9 00:06:28
hará la división con decimales, lo que le dé 00:06:28
y lo guardará en double 00:06:31
luego 00:06:32
este es un operador que hace una cosa 00:06:34
o hace otra en función 00:06:37
de los operandos que tenga 00:06:39
a los lados. Y eso le pasa 00:06:41
a otros operadores. 00:06:43
¿A la suma, la resta y la multiplicación? 00:06:45
No. Perdón, la suma sí, porque 00:06:48
ya dijimos ayer, aunque volveremos a ello, 00:06:49
que la suma, si tienes 00:06:52
dos cadenas, recordáis que acabamos 00:06:53
ayer así, si la suma 00:06:55
tienes a los lados dos 00:06:58
cadenas entre comillas, la suma 00:06:59
interpreta que lo que tiene que hacer es concatenar. 00:07:01
Pero si lo que tiene son números, 00:07:04
entonces interpretar lo que tienes que hacer es sumar 00:07:05
entonces la suma también es un operador 00:07:08
bipolar 00:07:11
que puede hacer 00:07:12
lo que 00:07:14
una cosa puede hacer otra 00:07:15
es polimórfico como lo queréis llamar 00:07:18
en función de los operandos 00:07:20
la resta no 00:07:21
la resta siempre trabaja 00:07:24
con números 00:07:26
y lo que hace es restar 00:07:27
me da igual que sean decimales que sean enteros 00:07:30
pues la división es como la suma 00:07:32
otro operador polimórfico, 00:07:34
si lo que tiene alrededor 00:07:37
son enteros, 00:07:38
te hace el cociente. 00:07:40
Si lo que tiene alrededor son decimales, 00:07:42
te hace la división con decimales. 00:07:44
Ni cociente ni nada. De hecho, 00:07:46
si mostramos aquí num decimal, 00:07:48
pues la última línea que nos va a mostrar este código 00:07:54
efectivamente 00:07:56
es eso, esa división. 00:07:58
¿Vale? 00:08:01
Es la división decimal de eso. 00:08:02
Que a uno le parece feo 00:08:04
que lo muestre con tantos decimales 00:08:09
él te muestra el número como es 00:08:11
te muestra el número como tal 00:08:13
que es este número, ahora hay otra cosa 00:08:14
es que cuando tú lo miras 00:08:17
físicamente, pero solo para verlo desde fuera 00:08:19
quieras redondearlo, truncarlo 00:08:21
porque el cliente de tu aplicación 00:08:23
quiere el precio, no quiere el precio 00:08:25
con 2000 decimales, a lo mejor ahí te han 00:08:27
pedido, se me va a ir 00:08:29
la batería ya 00:08:30
vale, entonces a lo mejor 00:08:32
ahí te han pedido una aplicación 00:08:50
oye, yo necesito en mi caja de mi tienda 00:08:51
meter un precio y un descuento en el producto que han cogido 00:08:55
y que me muestre rápidamente lo que le tengo que cobrar al tío 00:08:58
bueno, no te preocupes, yo te hago un programa 00:09:00
tú metes el precio y el descuento 00:09:02
y rápidamente vas a ver lo que le tienes que cobrar 00:09:04
al tío que tienes delante 00:09:07
vale, si le hacemos un programa 00:09:08
con lo que nosotros sabemos hasta ahora 00:09:09
hacemos la división y la mostramos 00:09:11
el tío que te ha pedido el programa y lo está ejecutando 00:09:12
pues efectivamente va a ver esto 00:09:15
y a lo mejor te dice 00:09:19
Hijo, hombre, la verdad, yo lo que quiero es que tú me muestres el precio 00:09:22
con dos cifras decimales, truncado, 2,5, o lo que sea, 00:09:25
no me lo muestres así para que yo tenga que hacer el esfuerzo 00:09:29
de quitar la parte decimal. 00:09:31
Vale, eso es simplemente una cuestión de dar formato a la salida, nada más. 00:09:33
Porque el número es el que es, y ahí no hay tu tía. 00:09:37
Y el número que está guardado aquí, 00:09:40
el número este en un decimal es ese, 00:09:45
y tiene esas cifras decimales 00:09:49
y ese es el número que está en memoria RAM 00:09:52
otro aspecto ya es 00:09:54
si yo lo quiero mostrar en la consola 00:09:56
cambiando el formato y truncando 00:09:58
¿vale? entonces 00:10:00
para eso, a esta 00:10:02
sentencia de aquí, se le pueden 00:10:04
pasar cositas que no vamos a ver ahora 00:10:06
porque no vamos a meter estos rollos 00:10:08
que se pueden buscar en cualquier lado 00:10:10
se le pueden pasar cositas para que 00:10:11
te lo muestre, a la hora de mostrarte en consola 00:10:14
te lo muestre truncado 00:10:16
pero eso ya son detalles 00:10:17
que si uno quiere investigar 00:10:19
oye, mostrar en consola con formato 00:10:20
pues se va 00:10:23
¿cómo se muestra en consola con formato? 00:10:24
pues se dice, ah, pues pones por ciento F 00:10:28
o pones no sé qué, el F patatín patatán 00:10:29
y ya está, esa es la típica cosa 00:10:31
que uno le puede preguntar a CharGPT 00:10:33
¿vale? pero porque 00:10:35
sabe exactamente qué es lo que quiere 00:10:37
y qué es lo que hay de fondo 00:10:39
y qué hay de fondo 00:10:42
yo tengo una variable, y esta variable 00:10:42
tiene ese valor, y lo tiene 00:10:45
y es inamovible, tiene ese valor 00:10:47
mi problema no es otro, mi problema no es 00:10:49
mostrarlo en una pantalla para un tío 00:10:51
que lo ve, pues le sea fácil 00:10:53
visualizar lo que 00:10:55
contiene ese numerito y redondearlo 00:10:57
mi problema no es mostrarlo en pantalla, pues entonces ya busco 00:10:58
en chat GPT, mostrar 00:11:01
por consola en Java 00:11:03
un double con la parte decimal 00:11:05
truncada, pues hemos apotado 00:11:07
el problema, queremos eso, pues chat GPT 00:11:09
como eso ya es muy sencillo, es 00:11:11
mirarse a la web y decir, ah pues pones aquí un no sé qué 00:11:13
lo trunca. Pues es probable 00:11:15
que acierte. ¿Vale? Entonces 00:11:17
ese problema, pues sí, lo puede resolver el chargePT. 00:11:19
Pero claro, uno sabe 00:11:21
qué es lo que está haciendo. 00:11:22
Claro, entonces, ¿qué sería un ejemplo de no saber? 00:11:25
Pues que vosotros pensarais 00:11:27
que por poner eso así, 00:11:29
el número decimal es el que se queda truncado. 00:11:31
No, esta variable no se queda truncada, 00:11:33
esta variable es la que es, y está en memoria RAM 00:11:35
con ese valor. Estamos hablando 00:11:37
de que la consola me lo muestre 00:11:39
más bonito. Nada más. 00:11:40
¿Vale? Bueno, pues si uno 00:11:43
quiere mostrar las cosas más bonitas 00:11:44
se va a buscar, yo recomiendo 00:11:46
que no porque no quiero que nos liemos ahora 00:11:49
con esto, vale 00:11:50
pues se va a buscar que cositas puede poner aquí 00:11:52
para que le quede la parte decimal 00:11:55
en dos cifras en vez de en varias 00:11:56
lo digo porque hay veces 00:11:58
por si uno a lo mejor se ve un tutorial de Java o no sé que de Java 00:12:00
pues muchas veces los vídeos de Java 00:12:03
o los tutoriales son como muy en plan chorizo 00:12:04
para hacer esto, para hacer esto, para hacer esto 00:12:07
y de repente llegas para mostrar por consola esto 00:12:08
y te sueltan aquí un chorizo para mostrarlo con decimales 00:12:10
y ves ahí un chorizo de cosas y dices 00:12:12
esto para qué lo quiero y qué me interesa 00:12:14
y te pueden llevar incluso a confusión 00:12:16
sobre lo que estás haciendo 00:12:18
entonces nosotros no nos vamos a meter 00:12:19
en mostrarlo más bonito, porque nos da igual 00:12:22
vale, pues entonces 00:12:24
lo que sí que nos interesaba era 00:12:26
tener claro 00:12:28
que el operador este de división 00:12:31
opera de forma distinta 00:12:32
si mezcla números enteros o decimales 00:12:34
entonces ahora le podríais decir 00:12:36
y si yo pongo un entero aquí 00:12:38
y un decimal aquí 00:12:40
¿quién gana? 00:12:42
¿El cociente o el decimal? 00:12:44
Y no solo quién gana, sino ¿puedo? 00:12:46
¿Me permite el compilador mezclar aquí un número? 00:12:50
Vamos a verlo. 00:12:54
Desde luego con la suma sí. 00:12:56
Por ejemplo, si yo sumo, vamos a hacer ahora. 00:12:57
Vamos a poner aquí para que luego cuando lo ejecutemos. 00:13:02
Pruebas mezclando. 00:13:07
Ah, no, era un sí, se lo quería poner. 00:13:08
Pruebas mezclando 00:13:12
Decimales 00:13:19
Y enteros 00:13:20
Enteros 00:13:23
Vale 00:13:25
Vale 00:13:26
La suma está clara que lo permite 00:13:30
Por ejemplo 00:13:32
Yo en mi numerito decimal 00:13:32
Num decimal 00:13:36
Voy a declararme otra variable 00:13:36
Número entero 00:13:41
Y le voy a asignar el 9 00:13:42
Vale, tengo mi número entero 9 00:13:45
Y ahora a mi variable número decimal le voy a asignar el resultado de sumar numDecimal1 más numEntero, ¿vale? 00:13:48
numDecimal1 lo he debido escribir mal porque, ah, es que no existe, era 2, vale. 00:14:06
Yo he hecho una suma en la cual estoy sumando un double y un int, no hay ningún problema. 00:14:14
la máquina virtual dice, no pasa nada. ¿Por qué? 00:14:22
¿Qué es lo que ha hecho? 00:14:24
Al número entero lo promociona poniéndole 00:14:26
el punto cero. 00:14:28
Hace la suma y lo guarda aquí. 00:14:30
No. Vamos a verlo ahora. 00:14:38
Está claro que esto funciona porque le pone 00:14:40
el número entero. Cuidado, eso no significa 00:14:42
que la variable num entero 00:14:44
haya cambiado a double. No. 00:14:45
La variable num entero sigue siendo 00:14:47
una variable int. Una variable int 00:14:49
en la que yo solamente puedo poner int. 00:14:51
No es que 00:14:54
el operador más haya decidido 00:14:55
promocionar número entero a dabble 00:14:57
y ahora yo pueda hacer esto 00:14:59
no, numentero 00:15:00
sigue siendo una variable entera y en ella 00:15:03
solo caben números enteros 00:15:05
pero, vale 00:15:06
y nume, bueno 00:15:09
que no he puesto el 00:15:11
nombre, ahí 00:15:15
perdón, vale 00:15:18
vale 00:15:20
entonces, numen, un segundito 00:15:22
termino esta, numentero 00:15:25
no lo ha cambiado a dabble 00:15:27
NUM entero sigue siendo entero 00:15:28
y solamente puede recibir enteros 00:15:31
Simplemente lo que ha ocurrido es que para hacer la operación 00:15:32
el valor que tenía NUM entero 00:15:35
el valor lo ha cogido 00:15:37
a ese valor una vez que lo ha sacado de la caja 00:15:38
una vez sacado de la caja 00:15:41
que la caja sigue siendo para enteros 00:15:42
el valor le ha puesto el punto cero 00:15:44
y ahora ya ha hecho la suma con NUM decimal 2 00:15:46
y ya con la suma con decimales 00:15:49
lo guarda en NUM decimal 00:15:51
¿Vale? Hasta ahí claro 00:15:52
¿Pero qué ocurre? 00:15:53
Ahora 00:15:57
Ahora, si intentamos hacer esta misma suma, pero esta misma suma, ¿qué va a funcionar así? 00:15:58
Este voy, cojo el valor y le pongo el punto cero. 00:16:08
Lo sumo en un decimal 2, que será 7.9, lo que sea. 00:16:12
Y ahora voy a guardarlo en este otro. 00:16:15
Aquí no me deja. 00:16:21
¿Por qué? 00:16:22
Porque aquí este numerito me ha dado con decimales, porque es dabel. 00:16:22
Este le ha puesto el punto cero 00:16:27
Este tendrá el decimal que sea 00:16:29
Punto no sé cuántos 00:16:32
La suma tendrá los decimales que sean 00:16:33
Y ahora el copiador dice 00:16:36
¿Eh? ¿Decimal en entero? 00:16:37
No, porque tendría que truncar la parte 00:16:39
Y no se puede quitar información 00:16:42
Sí, pero 00:16:44
Lo vemos un poquito más adelante 00:16:45
¿Vale? Pero él no te lo hace automáticamente 00:16:47
Porque te está quitando información 00:16:50
Te está quitando la parte decimal 00:16:52
Y hombre, no te va a quitar información así por las buenas 00:16:53
Él automáticamente no te lo puede hacer 00:16:55
Tú puedes forzarlo, puedes forzar a quitar la parte decimal, pero lo aparcamos ahora mismo, ¿vale? Entonces es lo mismo que ocurre si yo en mi num entero quisiera guardar en un decimal 2 hacia palo seco, decimal, ¿me diría lo mismo? 00:16:57
me diría, eh, oye 00:17:17
este tiene 00:17:20
aunque sea punto cero, me da igual 00:17:22
aunque sea punto cero, pero ese tiene sus decimales 00:17:23
aunque sea el punto cero, te dice, no 00:17:26
yo no voy a truncar la parte decimal 00:17:27
para que la metas aquí, aunque 00:17:30
en este caso en particular pudiera ser 00:17:31
punto cero, me da igual, no la voy a truncar 00:17:34
no puedes hacerlo 00:17:36
pero al revés, claro que puedes 00:17:37
por ejemplo esto 00:17:39
sí que lo podríamos hacer 00:17:41
esto sí nos deja 00:17:43
porque esta parte no quita 00:17:49
información, él dice 00:17:51
cojo el valor que hay en un 00:17:53
entero de la caja, lo cojo 00:17:55
que será 7, el que sea 00:17:57
una vez que tengo el valor ya metido aquí 00:17:58
fuera de la variable, le pongo el punto 00:18:01
0 y ahora ya con ese 00:18:03
punto 0 va aquí 00:18:05
luego a un double se le puede asignar un 00:18:06
int pero al revés no 00:18:09
y tiene todo el sentido porque al revés 00:18:10
perdemos información y el programa no puede 00:18:12
tirar información de la basura ahí sacándose 00:18:14
de la manga 00:18:17
¿Vale? 00:18:17
Entonces esto 00:18:19
Un int cabe en un double 00:18:20
Ampliando la parte decimal a punto cero 00:18:24
Y un double no cabe en un int porque tienes que quitar 00:18:26
¿Vale? 00:18:28
Vale, pues entonces 00:18:30
Esto 00:18:32
Igual que, es lo mismo que cuando decíamos 00:18:34
Que un int cabe en un long 00:18:36
Y decíamos, a un long le puedes asignar un int 00:18:37
Y él hace una cosa que llamábamos 00:18:40
Promoción automática 00:18:42
Pues esto es lo mismo, también se llama promoción automática 00:18:43
un int cabe en un double 00:18:46
y la máquina virtual lo promociona 00:18:48
automáticamente a double poniendo el punto cero 00:18:50
y ya está, no pasa nada 00:18:51
¿y qué pasa con los float? 00:18:53
los float 00:18:58
funcionan igual en realidad 00:18:59
lo único es que ahora 00:19:00
el float es un número decimal 00:19:02
que admite menos cifras decimales 00:19:03
entonces 00:19:08
aproximadamente 00:19:09
¿ahora hacemos una prueba con la consola? yo creo que sí 00:19:13
creo que sí, pero no estoy segura 00:19:16
vale, yo tengo un número float este de aquí 00:19:18
entonces 00:19:21
admite menos precisión en decimales 00:19:22
lo único 00:19:25
a tener en cuenta es 00:19:27
cuando 00:19:28
le asignáis un valor 00:19:30
le asignáis un valor 00:19:32
para que la máquina 00:19:35
virtual lo entienda 00:19:37
aquí no es 00:19:38
el punto sin más para la parte decimal 00:19:41
como veis me lo he puesto en rojo 00:19:43
porque si vosotros ponéis 00:19:45
8.9 00:19:47
para la máquina virtual 00:19:48
8.9 lo coge y lo interpreta 00:19:50
como un número double 00:19:53
y lo guarda temporalmente en 34 bits 00:19:54
es como cuando hacíamos 00:19:57
¿os acordáis? cuando yo decía 00:19:58
por ejemplo 00:20:01
esto 00:20:04
si, eso es lo que iba a decir ahora 00:20:06
sois muy listillos 00:20:12
un momento, ahora lo digo 00:20:13
esto es como yo decía 00:20:16
si la máquina virtual ve ahí un 7 00:20:18
un 7 sin más 00:20:21
temporalmente 00:20:23
lo almacena como int 00:20:26
y luego ya 00:20:27
hace con él lo que haya que hacer 00:20:29
si yo quiero 00:20:31
¿vale? por ejemplo 00:20:32
esto era, ¿vale? 00:20:38
él, yo veo este numerito 00:20:45
temporalmente él lo 00:20:46
interpreta como int, lo interpreta como int 00:20:48
con lo cual, cuidado, esto no cabe 00:20:50
en int, entonces te lo ponía en rojo 00:20:52
¿Qué teníamos que hacer para que 00:20:54
Él cogiera este número 00:20:56
Y temporalmente lo pusiera en una caja de 64? 00:20:58
Pues le poníamos la L 00:21:01
¿Vale? 00:21:02
Minúscula o mayúscula 00:21:04
Yo la he puesto mayúscula 00:21:05
La puse mayúscula, pero bueno, minúscula también nos valdría 00:21:08
Pues esto es igual 00:21:10
Si vosotros ponéis 8.9 00:21:11
Él empieza a codificar eso 00:21:14
Y lo codifica como dable 00:21:17
Con lo cual, a la hora de 00:21:18
Ese número que acaba de codificar 00:21:21
Llevarlo a este, te dice el compilador 00:21:22
Uy, un DAB en un float no cabe 00:21:24
Entonces 00:21:26
¿Qué hay que hacer para que lo codifique 00:21:28
Internamente como float? 00:21:31
Pues efectivamente ponerle una F 00:21:32
Entonces 00:21:34
Si le ponemos una F 00:21:36
Lo codifica internamente como float 00:21:38
¿Vale? 00:21:40
O sea, igual que para crear el load 00:21:42
Para crear el float siempre tiene que ser 00:21:43
Claro, claro 00:21:45
Aquí no se ve 00:21:46
No, no se llega a ser 00:21:54
no llega a verse 00:21:56
no, hay que mostrarlo con la consola 00:22:00
para que se vea, vale 00:22:05
vale, bueno, pues este es el único matiz 00:22:06
en realidad, que si queréis 00:22:09
que asignar un valor así 00:22:11
directamente, un valor a un número 00:22:13
float 00:22:15
pues tenéis que ponerlo con el 00:22:16
F delante, porque si no va a decir que es 00:22:19
un W y no puede, vale 00:22:21
ahora, para poder usar los 00:22:22
números decimales como datos de entrada 00:22:25
y leerlos por teclado 00:22:28
bueno, antes de cerrar 00:22:29
esto y empezar a teclado 00:22:33
un float cabe en un double y al revés 00:22:35
no, ¿vale? es lo que acabo de decir 00:22:37
eso ya 00:22:39
perdona, creo que tuve que cogerlo 00:22:39
sabe, ¿eh? 00:22:44
¿eh? 00:22:51
sabe 00:22:51
sabe a la música 00:22:52
no es como eso que vendía 00:22:56
con una federación 00:22:58
¡Mierda! 00:23:00
Esta generación es muy biotecnológica en España. 00:23:02
Más con este, más. 00:23:06
Pero de todo que esta generación es materialista. 00:23:13
¿Cómo te acuerdas de ella? 00:23:16
Yo también. 00:23:17
Yo también. 00:23:18
Pero de todo que te acuerdas de ella. 00:23:19
¡Mierda! 00:23:21
¡Gracias! 00:23:30
vale, pues entonces 00:24:05
que float cabe en un double pero al revés no 00:24:19
es como lo mismo, que un int cabe en un long 00:24:21
pero al revés no, bueno, esas cosas ya no hace falta 00:24:23
que lo pongamos en ejemplo 00:24:25
entonces con la división 00:24:27
cuando uno mezcla en operadores 00:24:30
hace la suma de un float y un double 00:24:32
un double y un float, pues lo mismo 00:24:35
el float le puede promocionar 00:24:36
a double si luego el resultado va en un double 00:24:39
pero si el resultado va en un float 00:24:41
no, pero bueno, esas pruebas ya las podéis 00:24:43
hacer vosotros, es siempre lo mismo 00:24:45
como pauta general 00:24:46
normalmente, pues cuando 00:24:48
uno trabaja con decimales usa double siempre 00:24:51
y ya está, porque es 00:24:53
mucho más cómodo si tenemos que darle un valor 00:24:55
directamente, no tener que andar arrastrando la F 00:24:56
ni nada, y aparte tienes más precisión 00:24:58
y total de 32 a 64 00:25:01
tampoco es que vayas a consumir ahí una memoria bestial, ¿vale? 00:25:03
Como pauta general, un double y ya está. 00:25:07
Bueno, y a lo que íbamos. 00:25:08
Ahora, ¿cómo leemos por teclado números double para poder hacer programas? 00:25:10
En nuestra clasecita esta de leer por teclado, ¿vale? 00:25:17
En esta clase de aquí ya hemos visto cómo leer números int. 00:25:21
Nos hemos olvidado por ahora de los short, los byte, 00:25:26
porque para nuestros primeros programas leemos enteros y ya está, int. 00:25:29
¿vale? pues exactamente igual 00:25:33
que este objeto lector que yo os dije 00:25:35
este objeto, es un objeto 00:25:37
que yo me he creado 00:25:39
y al ser una variable objeto 00:25:40
es capaz de hacer cosas 00:25:42
a diferencia de una primitiva 00:25:44
de una variable primitiva que solo tiene un valor 00:25:46
no es capaz de hacer nada, pues esta es capaz 00:25:49
de hacer cosas, pues puede hacer cosas, y una tras otra 00:25:51
una vez tras otra, aquí ya he hecho 00:25:53
una, que es 00:25:55
leer un entero 00:25:57
del teclado, entregármelo 00:25:58
esto último y ya nos vamos 00:26:01
pues igual que este objeto lector 00:26:19
ha podido 00:26:22
leer un entero con esto 00:26:23
pues yo lo puedo seguir usando 00:26:26
y le puedo seguir encargando cosas 00:26:27
por ejemplo, ahora yo tengo aquí 00:26:29
mi numerito de Abel 00:26:31
y ahora me interesa a mí leer 00:26:32
este número por teclado, porque lo voy a usar 00:26:38
para hacer cualquier cosa 00:26:40
el porcentaje o lo que sea 00:26:42
bueno, pues entonces, le tengo que 00:26:43
asignar el resultado 00:26:46
darle una orden al lector 00:26:49
de leer por teclado 00:26:52
y así está, es esta 00:26:53
igual que esta 00:26:57
lee un número entero, pues esta 00:26:59
vale, vamos a 00:27:02
mostrarlo aquí, lo probamos para que 00:27:04
veáis una cosa por si queréis practicarlo en casa 00:27:06
y lo dejamos, vale 00:27:08
vale, a ver 00:27:12
curioseáis en los objetos 00:27:19
de clase scanner, si curioseáis 00:27:22
veréis que igual que tienen 00:27:24
next int, next double, tienen next short 00:27:26
next byte, next byte, next long 00:27:27
para hacer lo mismo pero leyendo 00:27:30
un número en tamaño byte 00:27:32
un tamaño long, un next float 00:27:34
vale, pero bueno 00:27:36
con next int para leer enteros 00:27:38
y next double para leer decimales 00:27:40
ya podemos hacerlo todo 00:27:41
bueno, pues entonces si probamos 00:27:43
esto, cuidado 00:27:46
porque el next double 00:27:48
es lo que te hace este objeto para leer 00:27:50
el numerito, pero él 00:27:52
no es java, él es un 00:27:54
tío que quiere que las cosas se las digas de otra 00:27:56
manera, entonces vamos 00:27:58
a ejecutar este código de aquí 00:28:00
bueno, esto era de arriba 00:28:01
que ya lo teníamos y ahora se me ha quedado aquí 00:28:09
esperando el double, yo lo tengo ahí esperando el double 00:28:11
le voy a poner 7.8 00:28:12
pum, no le ha gustado 00:28:15
7.8, vale, ¿por qué? 00:28:17
porque aquí no estoy escribiendo código Java 00:28:19
aquí estoy escribiendo 00:28:21
información para el tío 00:28:23
ese lector que está metido ahí dentro 00:28:25
esperando que yo le dé un numerito 00:28:27
con decimales 00:28:30
para con él guardarlo en una variable 00:28:31
y ese tío que está ahí dentro 00:28:33
esperando que yo le dé ese número con decimales 00:28:35
le gusta que se los dé con la cop 00:28:37
porque es a lo que está acostumbrado, porque es un señor 00:28:39
humano que está ahí metido 00:28:41
Pues entonces 00:28:42
Si yo vuelvo a ejecutar esto 00:28:44
Y le doy el numerito 00:28:47
8,8 00:28:50
Este ya sí que le ha gustado 00:28:52
¿Vale? Pero este 8,8 00:28:53
No es código Java, yo no lo puedo meter en Java 00:28:56
Y decir al numerito de Abel igual a 8,8 00:28:58
En Java lo que entiende es esto 00:29:01
De hecho cuando le he pedido que me lo vuelva a mostrar 00:29:02
Ya me lo ha mostrado con el punto 00:29:04
¿Vale? 00:29:06
Esto es porque 00:29:09
Esto está orientado a la interfaz con el usuario 00:29:09
Y de toda la vida 00:29:12
en matemáticas la coma 00:29:13
de la parte decimal hasta se va a poner una coma. 00:29:15
Entonces, se está viendo al usuario 00:29:18
que es el que mete las cosas. 00:29:19
Y el usuario es un humano 00:29:21
que está acostumbrado a la coma 00:29:22
para la parte decimal. Pues por eso 00:29:25
el next double funciona pidiéndote 00:29:27
que se lo pongas como coma. 00:29:29
Venga, y ahora sí que nos callamos 00:29:32
y nos vamos. 00:29:33
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
19
Fecha:
21 de septiembre de 2024 - 16:31
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
29′ 35″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
110.34 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid