Saltar navegación

20250923-ProgEstr-Variables_9 - 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 24 de septiembre de 2025 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, antes de completar con los flow, add, double y los boolean básicos, vamos a revisar por encima lo que dijimos de char, que lo tenemos en el ejemplo de ayer, que fue cuando nos fuimos ya al final pitando, ¿verdad? Con lo de la letra mayúscula, minúscula, etcétera, etcétera, ¿vale? 00:00:00
Entonces, de char recordamos rápidamente que una variable char admite un único carácter. La asignación se puede hacer directa. 00:00:18
La asignación se puede hacer con el carácter entre comillas 00:00:33
o se puede hacer asignando un número entero 00:00:50
y entonces ya sabemos que en el char 00:00:55
se guardan el carácter de la tabla 00:00:58
así, silencio, ¿vale? 00:01:01
Entonces, el hecho de que en los char 00:01:04
puedan ir tanto, silencio, enteros 00:01:07
como char básicos, permite que podamos hacer sumas y restas 00:01:11
con char, porque también tiene enteros dentro, que es la codificación entera 00:01:15
del ASCII, y eso nos permite hacer, pues, tonterías 00:01:19
como esta, ¿vale? Si yo tenía una letra 00:01:23
a esta letra, como en realidad lo que tiene dentro es el 00:01:25
entero, que según la tabla ASCII codifica B 00:01:31
si le resto 32 00:01:34
lo que se queda 00:01:36
adentro es el 00:01:38
entero que en la 00:01:40
tabla ASCII codifica la mayúscula 00:01:42
porque entre minúscula y mayúscula hay una diferencia de 32 00:01:44
¿vale? 00:01:46
y lo comprobábamos 00:01:48
haciendo el system out println 00:01:49
y aquí fue cuando nos fuimos 00:01:52
ya deprisa y corriendo, vamos a 00:01:54
dejarlo para que no se quede así tan deprisa 00:01:56
y corriendo y luego ya vamos al float y al double 00:01:58
¿vale? recordáis esto de ayer 00:02:00
¿no? 00:02:02
Sí, sí, sí, tú puedes hacer, pero no sería next int, sería otra cosa, ¿vale? 00:02:07
Vamos, podemos incorporarlo aquí para que este programa sea poner en mayúscula la letra que tú quieras, ¿vale? 00:02:12
Pero vamos a completarlo antes. 00:02:18
Entonces, aquí, ¿qué dos problemillas nos encontrábamos para este programa? 00:02:20
¿Qué? 00:02:26
Para restar 32 a este char, yo tenía que hacer menos 32. 00:02:28
aquí otra vez 00:02:33
nos aparecía el problema 00:02:36
de esa conversión automática 00:02:38
entonces puse esa situación a propósito 00:02:41
a propósito 00:02:42
para que viéramos que es otra situación 00:02:43
en la que Java necesita 00:02:46
promocionar variables 00:02:47
aquí tenemos 00:02:49
esto que es char 00:02:50
al que yo puedo sumar y restar 00:02:52
porque en el fondo es un int 00:02:56
y aquí tengo el 32 00:02:58
Cuando la máquina virtual de Java ejecuta esto, recordad que cuando hay una sucesión de cifras, él construye un int, construye un int, vale, entonces como él aquí tiene char e int, el char le añade ceros para que sea ese mismo char pero en int, en 32 bits, con lo cual no nos dejaba guardarlo en letra mayúscula si letra mayúscula se guardaba como char, ¿verdad? 00:03:00
esto es lo que estábamos viendo cuando nos íbamos ayer 00:03:30
si lo guardamos 00:03:32
como char 00:03:34
no nos deja 00:03:35
porque 00:03:37
esto es un int 00:03:39
decíamos, no pasa nada 00:03:42
int y char son intercambiables 00:03:44
pues venga 00:03:46
como int ya si me deja 00:03:48
y ahora cuando mostrábamos 00:03:50
la letra 00:03:52
vamos a mostrar la letra mayúscula 00:03:53
ejecutábamos esto 00:03:57
no nos sacaba 00:03:59
lo último que nos muestra 00:04:10
el último system out 00:04:15
que es el último del programa, este 00:04:17
no nos muestra la B mayúscula 00:04:19
que fallaba aquí 00:04:21
pues fallaba lo que habíamos dicho 00:04:22
unas horitas antes 00:04:25
y es que yo una letra cualquiera 00:04:26
esta letra B 00:04:29
la puedo guardar en char o la puedo guardar en int 00:04:30
¿vale? es decir 00:04:33
yo a led 00:04:34
puedo hacer esto 00:04:36
y puedo hacer esto 00:04:37
¿vale? 00:04:39
las dos cosas son válidas 00:04:49
porque un char 00:04:50
también es el int dentro que codifica 00:04:52
esta b 00:04:55
la puedo guardar en char 00:04:57
o esta b la puedo guardar en int 00:04:59
me da lo mismo 00:05:01
¿qué implicación tiene guardarla 00:05:02
en char o en int? 00:05:05
cuando la voy a mostrar por consola 00:05:06
si nosotros ahora 00:05:08
mostramos letra 00:05:10
no lo voy a ejecutar 00:05:13
porque tenemos este programa, tantas cosas metidas 00:05:15
no se ve claro, si ejecutamos letra 00:05:16
creedme 00:05:19
si os digo que entonces mostrará la B 00:05:20
¿por qué? 00:05:23
porque el system out 00:05:25
mira como está declarada la variable 00:05:26
y está declarada como char 00:05:28
entonces tú 00:05:31
lo que te interesa es el char 00:05:32
y te muestra B 00:05:34
esto es de hace un par de días 00:05:36
pero sin embargo 00:05:38
yo ahora muestro letra 1 00:05:39
pues si yo muestro letra 1 00:05:41
no va a mostrar la B 00:05:46
va a mostrar el numerito entero 00:05:47
que según la tabla ASCII codifica la B 00:05:50
¿por qué? porque el system 00:05:52
out println mira esto 00:05:54
y dice esto como está declarado o como int 00:05:56
ah, entonces te interesa su versión 00:05:58
entera, entonces como te interesa 00:06:00
su versión entera, te muestro el numerito 00:06:02
que la tabla ASCII codifica la B 00:06:04
entonces esa es la diferencia entre 00:06:06
declarar como char 00:06:08
o como int y luego asignar un char 00:06:10
que a la hora de mostrar el valor 00:06:12
pues 00:06:14
me muestra o su versión 00:06:16
entera de la tabla ASCII 00:06:18
o su versión char de la tabla ASCII 00:06:20
que hay una 00:06:22
de cada, ¿verdad? 00:06:24
Vale, pues aquí nos está pasando 00:06:27
esto. 00:06:28
Aquí nos está pasando esto. 00:06:30
Que yo aquí, esta letra 00:06:34
menos 32 lo he tenido que guardar 00:06:35
obligatoriamente en int 00:06:38
obligatoriamente 00:06:39
porque si no la asignación no me dejaba 00:06:40
hacerla, si lo paso 00:06:43
al system out, él interpreta 00:06:45
que me interesa la versión int de este carácter 00:06:47
y por eso me saca 00:06:49
el 66 00:06:51
que es la versión int 00:06:54
de la B mayúscula 00:06:57
entonces, ¿cómo puedo 00:06:58
salvar esta situación? 00:07:01
ya lo ponemos ya todos juntos en un programa 00:07:03
¿cómo puedo salvarla? 00:07:05
poniendo el char delante 00:07:07
¿vale? 00:07:09
Entonces, si yo hago esto, esto es hacer una cosa que se llama 00:07:11
casting, que ya nos tendremos que meter en ella más adelante 00:07:19
cuando tengamos que usarla para otras cosas. 00:07:21
Pero que para los char no tendré que usar desde ya. 00:07:25
Si yo tengo un char en versión int y quiero mostrarlo. 00:07:28
Si yo tengo un char en versión int y quiero mostrarlo y quiero 00:07:32
que el system out me muestre la versión char, no la versión int, 00:07:36
Dejo ese in, claro 00:07:39
Y le digo, cuidado, pero no su versión 00:07:41
Como está declarada, no como está declarada 00:07:44
Sino su versión esta 00:07:46
Quiero su versión esta 00:07:47
Entonces, ahora ya sí 00:07:49
Si ejecutamos esto 00:07:51
Pues ahora ya sí que me saca 00:07:53
La B mayúscula, ¿vale? 00:07:55
Lo que tiene esto por dentro 00:07:57
Es lo mismo 00:08:00
Tiene 00:08:01
Lo que la tabla ASCII codifica 00:08:03
La B, tiene lo mismo 00:08:05
La diferencia es cómo me lo muestra el System.out, si como número o como char. 00:08:06
Y eso va a depender de cómo está declarado. 00:08:12
Si está como int y quiero su versión char, pues así, sí o sí. 00:08:15
¿Vale? 00:08:21
Entonces, vale, lo de los char más o menos, las cosas que hemos visto, está más o menos clara, ¿no? 00:08:22
Entonces, tenemos los cuatro tipos de datos de enteros. 00:08:36
El char 00:08:39
Conocemos más o menos 00:08:42
Las casuísticas más interesantes 00:08:44
De cada uno de ellos 00:08:47
En cuanto a promoción automática, etc 00:08:48
Nos falta 00:08:50
Float, Double y Boolean 00:08:51
Pues venga 00:08:54
Vamos a hacer aquí otra clase 00:08:55
Para trabajar con números decimales 00:08:58
Si la vais haciendo vosotros 00:09:02
Pues tendréis ese 00:09:06
Claro, para irlo practicando vosotros es lo mejor, ¿no? 00:09:07
Uy, va, eso está a punto de irse al suelo. 00:09:11
¿Vale? 00:09:14
Venga, pues ahora queremos hacer un programa que haga eso mismo. 00:09:20
A lo mejor multiplicar por 2 un número que yo te dé, pero quiero, ya que trabajé con decimales, no solo con enteros, con decimales. 00:09:27
Pues entonces, ¿qué dos tipos de datos tengo para guardar un número decimal? 00:09:35
Hemos dicho que teníamos dos, el float y el dabble, ¿vale? 00:09:44
Float usa 32 bits para guardar el dato y dabble usa 64 bits. 00:09:52
¿Cuál es la diferencia entre usar 32 o 64? La cantidad de cifras decimales que caben, ¿vale? 00:10:05
el float, no sé si son 7 cifras 00:10:14
decimales, 7 u 8 00:10:17
y el dabble pues 00:10:18
son unas cuantas más 00:10:20
¿vale? la precisión 00:10:22
¿se incluye la parte entera? 00:10:24
si hombre, claro, claro 00:10:26
un millón 00:10:28
a ver, es que esto va con el complemento 00:10:34
a 2, la forma 00:10:37
de, que no sé cuál es 00:10:38
vamos a ver si tuviera 00:10:40
una constante java 00:10:41
para darte el máximo 00:10:44
y el mínimo de 00:10:46
a ver 00:10:48
mira, si que tiene 00:10:50
max value 00:10:55
max value 00:11:19
esto lo hago 00:11:23
solo para ver el mayor y menor 00:11:26
número que se puede 00:11:28
codificar con estos valores 00:11:30
vale, esto me va a 00:11:32
mostrar, esto es un valor que tiene ya java 00:11:34
configurado, que es el mayor valor 00:11:36
float posible y este es el 00:11:38
menor valor float posible 00:11:40
y este es un valor que tiene ya configurado 00:11:41
que es el mayor valor float 00:11:44
double posible y el menor 00:11:46
entonces si ejecutamos esto 00:11:47
para ver cuáles son estos valores 00:11:50
vale 00:11:51
pues el mayor float es 00:11:57
3, esto 00:12:03
por 10 elevado a 38 00:12:05
o sea 00:12:08
mucho 00:12:09
pero como veis solo admite estas cifras 00:12:10
decimales que son 00:12:14
sin embargo 00:12:16
el mayor número 00:12:19
de Abel posible 00:12:20
es 1, no sé cuántos 00:12:21
por 10 elevado a 308 00:12:24
que es una barbaridad 00:12:27
como lo está diciendo ahí 00:12:28
lo estoy leyendo de ahí 00:12:31
la anotación científica no la conocéis 00:12:31
la E significa 00:12:34
10 elevado a 00:12:37
¿vale? 00:12:37
¿pero qué mates habéis estudiado vosotros? 00:12:41
¿qué bachillerato habéis estudiado? 00:12:43
¿qué bachillerato habéis estudiado? 00:12:45
es un 10 elevado 00:12:47
es un 10 elevado 00:12:49
y ya está calculado 00:12:50
pero a ver, hay una cultura científica 00:12:51
mínima 00:12:57
el 10 elevado a 00:12:58
pero a ver, en realidad 00:13:00
no nos importa especialmente 00:13:02
pero hombre 00:13:07
si vais a ser programadores 00:13:07
y os vais a meter de lleno en el mundo 00:13:11
la inteligencia artificial y los números 00:13:12
y todo eso 00:13:14
Pues hay ciertas notaciones que si vais conociendo mejor 00:13:15
¿Vale? 00:13:19
Si vais conociendo mejor 00:13:21
Pues esto es un número tocho 00:13:22
10 a la 38 00:13:28
Y este es muy pequeñajo 00:13:29
Porque es 10 elevado a menos 45 00:13:31
Y este es por 10 elevado a menos 324 00:13:34
O sea, es muy enano 00:13:39
Muy enano, ¿vale? 00:13:41
Y como veis, la precisión del float son siete cifras y la del dabble son muchas más. 00:13:43
A ver, no nos importan los detalles. 00:13:50
Lo único que nos importa es que tanto float como dabble son para guardar números con decimales. 00:13:53
Si yo necesito muchísima precisión en mis números, dabble. 00:13:59
Si no necesito tanta precisión con siete cifras, pues floa. 00:14:04
en general no lo sé, la verdad es que esto no sabría 00:14:09
decirlo con mucho criterio 00:14:12
a mí me gusta más el dabble 00:14:14
y supongo 00:14:16
que porque por tradición lo he visto 00:14:18
más, no sé si significa que se usa más 00:14:20
da un poco 00:14:23
igual, igual que sí que os digo que cuando uno 00:14:25
tiene que usar un entero, pone int siempre 00:14:28
por sistema, pues floato dabble 00:14:30
da un poco 00:14:32
igual 00:14:34
¿vale? venga pues entonces 00:14:35
esto que estaba aquí, vamos a quitarlo 00:14:38
ahora 00:14:41
si yo tengo por ejemplo 00:14:43
un número 00:14:46
decimal 00:14:48
lo declaro poniendo el double delante 00:14:49
lógicamente si quiero que sea double 00:14:55
y le puedo asignar un valor 00:14:56
exactamente igual que a los enteros 00:14:59
pues por ejemplo 00:15:01
la 5.7 00:15:04
luego 00:15:09
la coma decimal para java 00:15:11
es el punto 00:15:13
como para la mayoría de los lenguajes de programación 00:15:13
para la mayoría de los lenguajes de programación 00:15:16
la coma decimal es el punto 00:15:19
en realidad 00:15:20
¿vale? y también podría usar 00:15:21
un float para un numerito decimal 00:15:26
¿vale? 00:15:28
pero 00:15:34
aquí pasa 00:15:35
algo similar a lo que nos encontramos 00:15:36
con los indios y los dabels, aquí me ha dado error, ¿por qué? 00:15:39
cuando yo a java 00:15:42
le doy un numerito con un punto 00:15:43
un número decimal, él asume 00:15:46
que por defecto es dabel 00:15:48
entonces aquí lo ha 00:15:49
clavado en dabel, perfecto 00:15:51
dabel cabe en dabel 00:15:54
yo aquí le he dado 7.8 00:15:56
él asume que por defecto es dabel 00:15:58
y lo codifica en 64 00:16:00
pero al revés 00:16:01
porque en los números enteros 00:16:04
él le das 37 00:16:06
y por defecto asume que sí 00:16:08
que es más pequeño que el long 00:16:09
Pues aquí al revés 00:16:11
Si tú das un número decimal 00:16:12
Por defecto asume que es la versión más grande 00:16:14
Que es la label 00:16:16
Por defecto asume que es la grande, la label 00:16:16
Entonces, yo aquí le he puesto 00:16:19
7.8 00:16:22
Él lo construye con 64 bits 00:16:23
¿Y qué ocurre? Que no cabe en float 00:16:26
Pues por eso me da error 00:16:28
De compilación, me dice no cabe 00:16:30
¿Cómo le digo yo? No, no, no 00:16:32
Por favor, construyelo en 00:16:34
Pues poniendo una F 00:16:37
poniendo una F 00:16:39
¿vale? 00:16:42
pongo ahí una F 00:16:43
y con esto digo 00:16:44
ojo, construye el número en 32 00:16:46
como cuando le damos una L 00:16:50
a un número entero 00:16:54
le damos una L y le decíamos 00:16:54
construye en 64 00:16:56
porque si no le damos nada 00:16:57
lo construye en 32 00:16:59
pues aquí si no le damos nada 00:17:00
lo construye en double, 64 00:17:03
y si le queremos decir 00:17:05
que lo construya en 32 00:17:07
que es el más pequeño, hay que decirlo en f 00:17:08
hay que ponerle en f 00:17:10
ya sabía yo que había alguna razón 00:17:11
por la que siempre usamos dabel 00:17:16
para no arrastrar la f 00:17:18
yo le quiero dar un valor calcado 00:17:22
bueno, para no ocupar tanta memoria 00:17:23
imagínate que tuvieras una aplicación 00:17:28
crítica con tropecientos mil números 00:17:32
pues es que es la mitad de memoria 00:17:34
tal cual, porque son 32 bits 00:17:36
por cada número en lugar de 64 00:17:38
¿Vale? Entonces 00:17:40
Ya no solo que el número ocupe menos 00:17:42
Sino que la operativa con esos números 00:17:44
Va a ser más rápida 00:17:47
Entonces, por cuestiones de rendimiento 00:17:48
El float rinde mejor 00:17:50
Por lo que ocupa 00:17:53
Pero a la hora de escribir código 00:17:54
Es más cómodo 00:17:58
Cuando tienes que arrastrar la F 00:17:59
¿Es crítico el rendimiento? 00:18:00
Depende, si en tu aplicación lo es 00:18:02
Y en tu hardware lo es 00:18:04
Pero si no lo es, pues es más cómodo 00:18:06
Trabajar con W 00:18:09
Bueno, pues igual que hemos hecho con los enteros 00:18:09
Uno puede operar 00:18:17
Y asignar 00:18:18
Por ejemplo, vamos a 00:18:20
A otro numerito 3 00:18:23
Le vamos a dar el resultado de 00:18:25
Dividir num1 entre num2 00:18:28
Vale 00:18:32
Estupendo 00:18:33
Num1 entre num2 00:18:35
Ahora este operador 00:18:37
Ya no es el cociente 00:18:39
porque el cociente 00:18:41
entre números decimales no existe 00:18:44
el cociente es sólo entre enteros 00:18:46
tú un entero 00:18:48
tienes cociente y resto 00:18:50
por toda la vida 00:18:52
pero entre números decimales no hay cociente 00:18:53
entre números decimales hay división con sus decimales 00:18:56
entonces si 00:18:58
dividimos esto 00:19:01
pues nos dará el numerito con decimales 00:19:02
que nos dé 00:19:05
pues este es la división entera 00:19:06
mogollón de cifras decimales 00:19:15
porque es un dabble 00:19:17
porque es un dabble 00:19:19
¿vale? fijaos 00:19:21
he mezclado 00:19:27
variables de diferente 00:19:29
tipo en la expresión 00:19:31
esta es dabble, esta es float 00:19:32
igual que en expresiones 00:19:34
con números enteros 00:19:37
en el ejemplo de antes hemos mezclado int y long 00:19:38
no pasa nada, lo que hace 00:19:41
con el int es subirlo a long, ya está 00:19:43
no pasa nada, pues aquí 00:19:45
lo mismo, lo que hace con este 00:19:47
es subirlo a dabel, no pasa nada 00:19:49
se puede promocionar 00:19:53
de float a dabel, añades ceros 00:19:54
como cifra decimal 00:19:56
promocionar 00:19:57
yo tengo, o yo no 00:20:00
la máquina virtual 00:20:02
este numerito 00:20:03
a lo mejor es 00:20:07
7,82, está guardado como 00:20:07
float, lo quiero 00:20:10
como dabel, la máquina virtual lo tiene que promocionar 00:20:12
a dabel para irlo con este dabel 00:20:15
no pasa nada 00:20:16
mogollón de ceros 00:20:18
ala, ya está promocionado a dabel 00:20:20
a la inversa sin embargo no 00:20:22
tengo un numerito dabel 00:20:25
7,81569324675 00:20:27
este es un dabel 00:20:34
para cambiarlo a float 00:20:35
¿qué tendría que hacer? 00:20:37
esto a la basura 00:20:39
porque el float solo me admite 7 cifras 00:20:40
eso a la basura, hombre eso no 00:20:43
eso no lo podemos hacer porque 00:20:45
perdemos información. 00:20:47
Toda esta precisión la estamos tirando 00:20:49
a la basura. Luego de 00:20:51
dabel, perdón, de float 00:20:53
a dabel, 00:20:55
la máquina virtual lo hace automáticamente 00:20:57
porque se trata de añadir ceros. 00:21:00
No se pierde información. 00:21:04
De dabel 00:21:07
a float no te deja 00:21:07
porque, claro, que estás 00:21:09
perdiendo información, estás perdiendo precisión. 00:21:11
Aquí, por tanto, 00:21:15
teníamos el dabble 00:21:15
el float 00:21:17
¿qué ha hecho? 00:21:19
ha cogido el float 00:21:21
le añade ceros, no pasa nada 00:21:23
con lo cual lo ha promocionado 00:21:25
a dabble y la operación 00:21:28
cae en un dabble, ya está 00:21:30
no pasa nada 00:21:31
sí que habría sido un problema 00:21:32
el siguiente 00:21:42
float num3 00:21:43
igual a num1 00:21:46
entre 00:21:48
num4 00:21:49
que num3 ya lo tengo 00:21:52
num1 00:21:53
entre num2 00:21:56
esto 00:21:58
si habría sido un problema 00:22:00
esta sí, esta no 00:22:01
esta no 00:22:07
porque claro 00:22:09
aquí la máquina virtual primero evalúa la expresión 00:22:10
luego ya después se mete 00:22:13
a ver a qué variables lo das 00:22:15
float double 00:22:16
al revés 00:22:19
el float 00:22:20
lo estiro con ceros al double 00:22:22
hago la división 00:22:25
me queda el double 00:22:27
¿un double puede ir a un float? 00:22:28
¿un float puede ir a un double? sí 00:22:32
exactamente igual que 00:22:34
¿un int puede ir a un long? sí 00:22:36
¿un long puede ir a un int? no 00:22:38
pues aquí aplican los mismos 00:22:40
principios, dime 00:22:43
te lo va a truncar a la precisión que sea 00:22:44
si es double te lo truncará 00:22:52
a las 14 cifras decimales 00:22:54
que tenga, que no recuerdo cuantas son 00:22:56
te lo trunca 00:22:58
siempre te lo va a truncar 00:22:59
si el resultado te da un número periódico 00:23:06
la operación te da un número periódico 00:23:08
te va a obtener un resultado 00:23:09
pero truncando solo 00:23:12
a los decimales que admite 00:23:14
el resto no 00:23:16
el resto no te lo va 00:23:18
por ejemplo 00:23:19
a ver esto 00:23:21
no se puede hacer, aquí podríamos 00:23:24
vamos a 00:23:26
entonces aquí haría 00:23:29
Vamos a dejar esto 00:23:31
Promoción automática 00:23:34
De Float a Dabble 00:23:36
Esta se puede 00:23:39
Esto si se puede y no hay problema 00:23:40
Sin embargo 00:23:45
De Float a Dabble 00:23:46
La promoción automática se puede 00:23:51
Sin embargo 00:23:53
No se puede 00:23:54
Promocionar 00:23:56
De Dabble a Float 00:23:59
Eso no 00:24:01
Porque perderíamos información 00:24:02
¿Vale? Esto no se puede y me daba error 00:24:05
Vale, entonces 00:24:07
Vamos a crear un número periódico 00:24:09
Para ver cómo te lo muestra 00:24:11
Por ejemplo, num3 00:24:12
Igual a 00:24:14
1 entre 3 00:24:17
¿No? Es 0,33333 00:24:22
¿No? 00:24:23
1 entre 3 00:24:25
Y vamos a mostrar 00:24:27
Num3 00:24:29
Ah, perdón 00:24:32
Ah, mira, qué 00:24:44
Buen ejemplo, nos ha salido antes de 00:24:45
De tiempo, vale 00:24:48
Porque además viene al pelo 00:24:50
Justo de lo que teníamos que contar ahora 00:24:54
Vale, generando el ejemplo suyo 00:24:56
Este de número periódico 00:24:58
Vale, hemos dicho 00:25:00
1 entre 3 00:25:01
Es 0,333333 00:25:03
Hasta el infinito, ¿verdad? 00:25:06
Lo hemos 00:25:10
Hemos hecho la división 00:25:11
La hemos guardado en este numerito de Abel 00:25:12
Y vamos a mostrar este número 00:25:14
¿Cuál es? 00:25:16
Esperábamos encontrar 0.3333 00:25:18
Así hasta las cifras decimales 00:25:21
Que quepan en Abel 00:25:23
Que son las que me han salido 00:25:24
Antes ahí que no las he contado 00:25:26
12 o 13 serán 00:25:27
Vale, entonces lo hemos ejecutado 00:25:30
¿Y qué corte? 00:25:32
Nos ha salido 0 00:25:35
En lugar de 0,33333 00:25:36
Vale, pues en realidad 00:25:39
¿sabemos por qué? 00:25:41
si lo pensamos 00:25:44
¿sabemos por qué? 00:25:44
¿vale? a ver 00:25:49
cuando 00:25:51
estamos viendo enteros, yo os he dicho 00:25:54
cuando la máquina virtual 00:25:56
ve una sucesión 00:25:57
de cifras 00:25:59
lo construye como IN 00:26:03
es justo lo que ha visto aquí 00:26:06
una sucesión de cifras 00:26:08
lo ha construido como IN 00:26:09
vale 00:26:12
ahora ve aquí un 3 00:26:13
lo ha construido como int 00:26:15
porque es una sucesión de cifras normal y corriente 00:26:18
int 00:26:20
barrita int 00:26:20
lo interpreta como cociente 00:26:23
porque cuando esta barra 00:26:26
mezcla números enteros 00:26:28
entonces es el cociente 00:26:30
no es la división entera 00:26:33
es el cociente, otra cosa que también sabemos 00:26:35
cociente de dividir 1 entre 3 00:26:38
Ahora, le ha salido el numerito int 0 00:26:43
Lo tiene que guardar en double 00:26:46
Porque en un 3 es double 00:26:49
No pasa nada 00:26:51
Un int en double cabe 00:26:51
Le pongo 0.0 y ya está 00:26:54
Como si hubiera salido 3 00:26:56
Un 3 en double cabe 00:26:59
Le pongo 3.0 y ya está 00:27:00
A la inversa no 00:27:03
Un double en int no 00:27:05
Porque un double podría 3.7 00:27:06
Para que cupiera en un int 00:27:08
Tendría que quitarle el .7 00:27:10
Eso es perder información, eso nunca se puede hacer 00:27:12
Pero un int en un double 00:27:15
Ningún problema, le pones el .0 y ya está 00:27:17
Pues eso es lo que ha pasado 00:27:19
Esto es un int 00:27:21
Esto es un int 00:27:22
Esto por tanto es división entera 00:27:24
Me da 0, como tiene que ir a un double 00:27:26
Le pongo 0.0 00:27:29
Que es justo 00:27:30
Lo que nos ha salido 00:27:31
Luego entendemos lo que ha pasado 00:27:33
Ahora 00:27:36
Perdona, yo no quiero que me interpretes 00:27:37
Esto como 00:27:41
int, sino como dable 00:27:42
si os ocurre que podríamos poner 00:27:44
podríamos, pero no hace falta 00:27:46
más sencillo, punto cero 00:27:52
punto cero 00:27:54
claro, ya está, ahora ya 00:28:01
la máquina virtual no se encuentra 00:28:03
unas cifras enteras y más 00:28:05
se encuentra una parte entera 00:28:07
punto una parte decimal 00:28:09
que la parte decimal es cero, me da igual 00:28:11
esto ya jamás lo va a construir como un entero 00:28:13
porque se ha encontrado el carácter clave de los decimales 00:28:16
que es este 00:28:19
entonces 00:28:20
al encontrarse 00:28:21
el carácter clave de los decimales 00:28:25
que es el puntito 00:28:26
dice, ah, hay que construir un double 00:28:28
genial, se ha construido 00:28:31
el double 1.0 00:28:33
y aquí el double 3.0 00:28:34
ahora ya son dos doubles 00:28:37
esto ya por tanto 00:28:38
ya no es cociente 00:28:40
eso ahora es división con decimales 00:28:41
porque lo que tienen los dados 00:28:44
son dabel 00:28:46
luego poniendo 00:28:47
el punto cero 00:28:50
ya forzamos a que la máquina virtual 00:28:51
lo construya como dabel 00:28:54
porque le estamos dando el puntito 00:28:55
si no le damos esto 00:28:57
una sucesión de cifras 00:29:01
en este caso solo una 00:29:03
y para él eso es un número entero 00:29:05
y lo construye como entero 00:29:08
entonces ahora sí 00:29:09
ejecutamos este programa 00:29:12
ahora ya esto 00:29:16
lo ha truncado 00:29:20
a las cifras decimales 00:29:23
que admite de Abel 00:29:25
que son 5 00:29:26
¿vale? si fuera 0, 7, 7, 7 00:29:34
7, 7, 7, al truncarlo veríamos 00:29:39
que la última es 8, porque al redondearlo 00:29:41
pues 00:29:43
lo va a redondear a 8 porque tiene muchos 7 detrás 00:29:44
pero bueno, en este caso el redondeo es a 3 00:29:47
Sí, pero esos son castings 00:29:49
Que no nos ha quedado más remedio 00:29:54
Que hacer aquí 00:29:56
Porque ahí tenemos que hacerlo sí o sí 00:29:57
Pero los castings vamos a evitarlos 00:29:59
Hasta que, lo que tú me estás diciendo 00:30:01
Pon el label entre paréntesis 00:30:03
Vamos a evitarlos hasta que no 00:30:05
Tengamos que usarlos sí o sí 00:30:06
Y hasta que no entendamos muy bien lo que significan 00:30:09
Y aquí le has puesto 00:30:11
Esta variable está declarada como 00:30:16
Double, bueno es que si no te daría error de compilación 00:30:18
Y esto es un 00:30:20
¿Has puesto el punto cero y el punto cero? 00:30:22
No, lo he puesto sin punto cero 00:30:25
Ah, entonces no 00:30:26
Claro, claro, es que si no son enteros 00:30:27
Pasa lo que hemos dicho antes 00:30:30
Si no se lo pones son entero 00:30:32
Cociente entero 00:30:35
Si se lo pones solo en uno de los dos 00:30:36
También funciona 00:30:39
Porque aquí haría entonces la promoción automática 00:30:40
Entero entre double 00:30:42
Lo que hace es 00:30:44
Promocionar el entero a double poniendo punto cero 00:30:46
No hace falta ponérselo a los dos 00:30:48
vale 00:30:50
vale, o sea en general 00:30:52
cuando tenemos una expresión aritmética 00:30:55
que involucra valores 00:30:58
de diferente tipo 00:30:59
él intenta promocionar 00:31:00
unos a otros si es que se puede 00:31:03
y esas reglas de promoción 00:31:06
están claras 00:31:10
vamos a recopilarlas aquí 00:31:11
con versiones 00:31:13
que puede hacer 00:31:18
la máquina virtual 00:31:19
directamente sin ningún problema 00:31:21
Pues puede hacer, está claro 00:31:23
Byte lo puede llevar 00:31:29
A short 00:31:31
Lo puede llevar a int 00:31:35
Si hace falta, lo puede llevar a long 00:31:37
¿Vale? 00:31:39
Short 00:31:42
Lo puede llevar 00:31:42
A int, sin ningún problema 00:31:44
Y lo puede llevar a long 00:31:47
Int 00:31:48
Lo puede llevar a long, sin problema 00:31:51
Si la máquina virtual lo necesita 00:31:54
¿Vale? 00:31:55
Float 00:31:58
lo puede llevar a double 00:31:59
no hay ningún problema 00:32:01
es añadir ceros en la cifra decimal 00:32:04
pero lo que es más 00:32:06
int 00:32:08
también lo puede llevar a float 00:32:09
poniendo .000 00:32:12
e int 00:32:13
también lo puede llevar a double 00:32:15
poniendo el .0000 00:32:18
todas estas conversiones 00:32:21
se pueden hacer, las hace automáticamente 00:32:24
si ve valores 00:32:26
de tipos mezclados en una expresión 00:32:28
él 00:32:30
convierte lo que 00:32:32
necesite siempre y cuando pueda 00:32:34
estas conversiones se pueden hacer porque no pierde 00:32:36
ninguna información 00:32:38
para esta pone .0 00:32:40
y ya está, para esta también pone .0 00:32:42
he puesto solo in, pero de long a double 00:32:44
sería igual, van a agarrarme 00:32:46
un long puede un double, pone .0 00:32:47
y ya está, ¿vale? 00:32:50
este ya lo sabemos, de un in 00:32:53
puede un long, pone ceros en los bits 00:32:54
significativos y ya está 00:32:56
Sin embargo, las inversas 00:32:58
No las puede hacer automáticamente 00:33:00
Y por eso hay un error de compilación previo 00:33:03
Las inversas no puede 00:33:05
El si necesitara cambiar de double a int 00:33:06
Eso no puede hacerlo 00:33:10
Ni de double a float 00:33:11
Eso no puede 00:33:13
Porque tiene que quitar cifras decimales 00:33:14
Ni de long a int 00:33:16
No puede 00:33:18
Porque tiene que quitar bits que tienen valor 00:33:18
Vale, a ver 00:33:21
Vamos a incorporar 00:33:36
Leer un decimal por teclado para poder hacer algo. 00:33:42
Igual que ya sabemos leer números por teclado, 00:33:47
pues podemos también, números enteros por teclado, 00:33:51
podemos también leer decimales por teclado. 00:33:55
Y lo haríamos igual. 00:33:58
Tendríamos que hacer el objeto lector. 00:34:00
Y ahora, por ejemplo, yo quiero leer un dabel, 00:34:04
un numerito dabel del teclado. 00:34:25
Pues doy la orden 00:34:28
Pero la orden ahora no es next in 00:34:32
La orden como nos podíamos imaginar es next double 00:34:34
Entonces 00:34:36
Cuando la máquina virtual llega aquí 00:34:40
Se queda ahí quieta esperando 00:34:42
Que alguien meta un número 00:34:44
Variable double 00:34:47
Vale, mete un decimal para variable double 00:35:05
Y vamos a hacer lo mismo con el float 00:35:08
Mete un decimal 00:35:10
Para variable float 00:35:17
Num6 00:35:19
Ahora no será 00:35:25
float 00:35:26
ahora no será next double 00:35:28
sino como nos podíamos imaginar 00:35:31
next float 00:35:33
entonces vamos a probar estas dos lecturas 00:35:34
vamos a leerlo y mostramos el número leído 00:35:41
y aquí lo mismo 00:35:45
vamos a leerlo y vamos a mostrar 00:35:53
el número leído 00:35:55
entonces estos dos códigos 00:35:56
primero este te mostrará el mensajito 00:35:59
se quedará a la espera 00:36:03
de que le metas un double 00:36:05
y lo guardará en un 5 00:36:06
y luego te lo muestra 00:36:08
y aquí lo mismo, te muestra el mensajito 00:36:10
se queda esperando que le metas 00:36:13
un número decimal, lo guarda en este float 00:36:14
y te lo muestra 00:36:16
vamos a ejecutarlo 00:36:17
bueno, esto es lo que ha hecho antes 00:36:20
como veis ahí está esperando 00:36:25
ahí está esperando 00:36:27
cada vez que hay un next 00:36:29
lo que sea 00:36:31
el programa se queda ahí esperando 00:36:32
vale 00:36:36
Pues aquí cuidado, porque aquí el next double no funciona con el punto, el next double si yo le meto 76.8 no funciona con el punto, hay que poner una comita, es lo único que tenemos que recordar, ¿vale? 00:36:37
Entonces, si yo quiero meter a través del teclado 76,8, pues tengo que poner coma, no punto, coma. 00:36:56
Luego no es igual cuando lo asigno directamente por código que cuando lo meto por teclado con Nextavel. 00:37:06
Por código es punto, como toda la vida de Dios en matemáticas. 00:37:12
Por teclado es coma, porque el Nextavel lo tiene así porque cree que es más intuitivo. 00:37:16
Vale, efectivamente 00:37:21
Lo ha leído 00:37:23
Y luego me lo ha mostrado 00:37:25
El numerito que yo he leído es 76.8 00:37:27
Muy bien 00:37:30
Vamos a meter un decimal para variable flow 00:37:30
76.8 otra vez 00:37:33
Vale 00:37:35
Lo ha leído 00:37:38
No te obliga a poner la F 00:37:39
Porque esto es para que un usuario lo escriba 00:37:42
Y necesita que sea intuitivo 00:37:44
Entonces 00:37:46
Te lo lee y luego te muestra 00:37:48
la variable float, vale 00:37:51
vamos a ejecutarlo otra vez poniendo 00:37:52
aquí un número que tenga 00:37:58
muchas cifras decimales que no quepan en double 00:38:00
a ver si redondea o peta 00:38:02
mete un decimal 00:38:05
para double, pues 4,6 00:38:08
4,6, mete un decimal 00:38:09
para float 00:38:12
8, en float 00:38:12
solo cabían, eran 7 00:38:18
creo, 1, 2, 3, 4, 5, 6 00:38:20
7, 8, 9 00:38:22
vale 00:38:23
Como no admite esa precisión 00:38:25
Fijaos lo que ha hecho el next flow add 00:38:28
Como tanta precisión no admite 00:38:31
Te lo redondea 00:38:33
Al double más cercano 00:38:34
En este caso es esto 00:38:36
Perdón, al flow add más cercano 00:38:39
Te lo redondea a esto 00:38:41
Porque no admite esa precisión 00:38:43
Sin embargo, si yo 00:38:46
Le dijera 00:38:48
78,9 00:38:51
Y ahora meto uno para variable flow add 00:38:53
7, 1, 2, 3, 4, 5, 6, 7. 00:38:56
7 si las coge, ¿verdad? 00:38:59
Bueno, me ha redondeado a 6. 00:39:02
Esos son ya matices internos de cómo funciona esta sentencia de leer del teclado. 00:39:04
Pero vamos, lo que nos importa ahora es que cada vez que tengamos que hacer programas 00:39:09
que necesiten datos de entrada del teclado, 00:39:14
con estas tres sentencias que hemos visto, 00:39:18
esta next in de aquí, 00:39:22
Que no sé dónde estaba 00:39:23
Aquí 00:39:26
Y estas dos 00:39:27
NextW y NextFloat 00:39:32
Podemos meter números enteros y decimales 00:39:33
Si metemos decimales 00:39:35
Ojo con coma 00:39:38
Acordémonos de con coma 00:39:39
Porque si no va a salir error 00:39:40
Ya está 00:39:41
Teclado con coma 00:39:42
En lugar de con punto 00:39:58
¿Vale? 00:40:00
Pues todavía podemos hacer muy 00:40:28
Poquitas cosas 00:40:31
Pero bueno 00:40:32
Si del aula virtual 00:40:34
A ver 00:40:40
Vale, bueno, todo esto 00:40:51
Todavía no lo hemos visto 00:41:17
Aquí están algunos resúmenes que he subido 00:41:18
Para que esté un poco más organizado 00:41:23
Pues si abrís el PDF 00:41:24
Este 00:41:27
Esto es una chorradita 00:41:28
Pero es que no podemos hacer más que esto 00:41:37
Haced estos dos primeros 00:41:39
Más que nada para asegurarnos todos 00:41:41
de que tenéis conocido 00:41:43
toda la dinámica. 00:41:46
Sí, sí, en el aula virtual. 00:41:48
Sí, a ver, cada ejercicio 00:41:52
que hagáis, hacedlo en una clase. 00:41:53
¿Vale? 00:41:56
Entonces... 00:41:58
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
24 de septiembre de 2025 - 18:07
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
42′
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
156.99 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid