Saltar navegación

20250929-ProgEstr-Operadores_2 - 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 29 de septiembre de 2025 por Raquel G.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

Pues esto de la concatenación nos permite obtener textos para el resultado un poquito ya más interesantes, ¿vale? 00:00:00
Es decir, el operador concatenación, este de aquí, no solo, ¿qué me estáis diciendo? 00:00:11
Vale, el operador este de concatenación no funciona solo con cadenas, una cadena a cada lado y entonces es la concatenación. 00:00:20
También funciona con una cadena a un lado 00:00:34
Y al otro lado cualquier otra cosa 00:00:37
¿Y qué hace la máquina virtual? 00:00:40
Pues ese cualquier otra cosa 00:00:42
Fuerza la conversión a cadena 00:00:44
Es decir, concatenación 00:00:47
El operador concatenación más 00:00:53
Funciona también 00:00:55
Entre una cadena 00:01:00
O un string, como lo queramos llamar 00:01:04
Es lo mismo 00:01:07
Y cualquier otra cosa 00:01:07
Que nos dé la gana poner 00:01:13
Ahora mismo para nosotros cualquier otra cosa 00:01:14
Son números 00:01:16
Y cualquier otra cosa 00:01:17
Por ejemplo 00:01:21
Yo tengo mi numerito n 00:01:24
Igual a 6 00:01:28
Y tengo mi cadena nombre 1 00:01:29
Que la tengo ya declarada arriba 00:01:33
Pues por ejemplo 00:01:34
Puedo concatenar 00:01:36
Nombre 1 00:01:39
Que es un string 00:01:40
lo puedo concatenar con algo que no sea un string 00:01:42
como por ejemplo un numerito 00:01:46
y no pasa nada 00:01:48
ahora hacemos la asignación 00:01:49
entonces cuando el operador 00:01:51
cuando la máquina virtual se encuentra 00:01:55
que un operador más 00:01:57
y uno de los dos es una cadena 00:02:00
uno de los dos es una cadena 00:02:03
automáticamente interpreta 00:02:05
que lo que quieres hacer es concatenar texto 00:02:07
interpreta que quieres concatenar texto 00:02:10
si los dos fueran números 00:02:12
no hay duda, interpreta que quieres sumar 00:02:15
si los dos son cadenas 00:02:17
no hay duda, interpreta que quieres 00:02:19
concatenar 00:02:21
el problema es, y si uno es cadena 00:02:22
y otro es cualquier otra cosa 00:02:25
por ejemplo, número en nuestro caso 00:02:27
porque es lo que estamos usando 00:02:30
pues interpreta 00:02:31
que lo que quieres también es 00:02:33
concatenar, es decir, la concatenación 00:02:35
tiene más peso que la suma 00:02:38
¿vale? entonces 00:02:39
en este caso como estamos 00:02:44
cadena string 00:02:45
suma numerito 00:02:47
pues automáticamente la máquina virtual 00:02:49
interpreta que quieres concatenar 00:02:52
pues que hace 00:02:54
coge lo que no es cadena 00:02:56
lo que no es cadena 00:02:58
y fuerza su conversión 00:03:00
a cadena 00:03:02
que significa 00:03:02
forzar la conversión a cadena de un 00:03:05
número 6 pues que es como 00:03:08
si estuviéramos 00:03:10
Concatenándolo con esto 00:03:10
Sería como si estuviéramos haciendo esto 00:03:14
Nombre 1 más 00:03:16
Es decir 00:03:19
Cuando él tiene que forzar el numerito 6 00:03:20
Él va a ver la n 00:03:22
Y ve que tiene el 6 00:03:23
Pues para forzar la conversión a cadena 00:03:25
Lo que está haciendo 00:03:28
Es convertirlo directamente 00:03:30
En la cadena 6 00:03:32
El resultado será 00:03:33
Un string, una cadena y tendrá que ir a una cadena 00:03:36
Lógicamente 00:03:38
Pues yo que sé, a esta mismo, por ejemplo 00:03:39
Que ya la tengo declarada 00:03:42
¿Vale? A esta misma 00:03:44
¿Vale? 00:03:46
Luego entonces, todo eso está en el texto 00:03:50
Que os he pasado 00:03:52
Cuando el operador más va 00:03:53
Repetimos 00:03:56
Entre una cadena 00:03:58
Uh, le he dado tan fuerte 00:04:00
Que la he roto 00:04:02
Pues sí, cuando le das fuerte se apaga 00:04:05
Ah, pues no 00:04:12
Bueno 00:04:14
vale, cuando el operador 00:04:15
más va con una 00:04:18
cadena y cualquier otra cosa 00:04:20
automáticamente dice, ah, quieres 00:04:22
concatenar, pues coja ese cualquier 00:04:24
otra cosa y lo convierte 00:04:26
en texto, ¿cómo? 00:04:28
depende de cómo seas a cualquier 00:04:31
otra cosa, ya íbamos viendo cómo funciona 00:04:32
lo de convertir en texto, porque no es trivial 00:04:34
pero en el caso del número 00:04:36
que es lo que estamos usando ahora, numeritos 00:04:38
convertir en texto 00:04:40
es convertir en una cadena 00:04:41
ASCII con las cifras, ya está 00:04:44
este como es 6 00:04:46
pero vamos a probar por ejemplo con un 00:04:48
dabble que es más raro, por ejemplo 00:04:50
dabble 6.98 00:04:57
pues en realidad sería 00:05:00
convertirlo a cadena 00:05:03
lo convertiría en la cadena 00:05:07
de caracteres ASCII 00:05:09
el 6, el carácter ASCII punto 00:05:10
el carácter ASCII 9, el carácter ASCII 8 00:05:13
es decir, deja de ser un número 00:05:15
y se convierte en una cadena 00:05:17
y lo concatenaría 00:05:19
a esto, de nuevo 00:05:22
esto lo doy por sentado, claro 00:05:26
que esta conversión se hace 00:05:28
para hacer la operación, lógicamente 00:05:30
para hacer la concatenación, no es que 00:05:32
luego esta variable n 00:05:36
se convierta a string, no, no 00:05:38
la máquina virtual 00:05:40
ve que quieres usar n, dice 00:05:42
uy, n es un dable y tiene 6.98 00:05:44
cojo su valor 00:05:46
cojo su valor 00:05:48
lo convierto en cadena, lo concateno 00:05:50
pero lógicamente la variable n original 00:05:52
sigue siendo n, y no le pasa nada 00:05:54
todo esto 00:05:56
lo hacemos para hacer la operación 00:05:58
pues entonces este operador 00:06:00
recordad que tiene también esa función de concatenar 00:06:05
cadenas y va a concatenar 00:06:07
siempre y cuando 00:06:09
alguno de las dos 00:06:10
cosas sea un string, me da igual que el string sea 00:06:13
la segunda, me da igual 00:06:15
con que una de las dos sea un string 00:06:16
me da igual que sea la que está en primer lugar o la que está 00:06:19
en segundo lugar, cuando una de las dos sea un string 00:06:21
es una 00:06:23
concatenación, vale 00:06:24
de hecho si ejecutamos esto 00:06:28
pues tendremos que ver al final 00:06:30
esto de aquí 00:06:32
este programa 00:06:34
me pide primero el número de usuarios 00:06:47
8 bla bla bla 00:06:49
ah bueno es que no lo he mostrado 00:06:53
lo he guardado pero ahora no lo he mostrado 00:06:55
vamos a mostrarla 00:06:57
veis 00:06:58
ha hecho una concatenación 00:07:12
Ha hecho una concatenación entre el nombre 1 00:07:15
Que era Ana 00:07:19
Y ha forzado la conversión a cadena de este 00:07:21
Que le ha dado la cadena 6.98 00:07:26
Ha concatenado los dos 00:07:30
Y lo ha guardado en el string nombre 2 00:07:33
Que es el que hemos mostrado después 00:07:35
¿Vale? 00:07:38
Entonces, bueno, esto de la concatenación 00:07:44
Nos es muy útil cuando queremos 00:07:46
ahora ya pues mostrar avisos 00:07:48
un poquito más sofisticados, por ejemplo 00:07:52
nos vamos aquí arriba cuando estábamos incrementando los usuarios 00:07:55
introduzca número de usuarios, lo leemos, ¿cuántos más? estos 00:08:01
hacíamos la operación de a los usuarios antiguos 00:08:05
le sumamos los nuevos y el resultado final 00:08:09
actualiza la variable, que es lo que vimos 00:08:11
que lo podíamos 00:08:15
abreviar con el más igual 00:08:17
vamos a hacer ahora que me muestre 00:08:19
la nueva cantidad 00:08:22
de usuarios es 00:08:25
entonces el system out 00:08:27
¿qué le pasamos? 00:08:29
le vamos a pasar una cadena 00:08:31
vale, pues le vamos a pasar 00:08:32
el nuevo número 00:08:35
usuarios es 00:08:37
y ahora esta cadena 00:08:45
la quiero concatenar yo 00:08:48
Con el contenido de esta variable 00:08:51
Porque quiero que me muestre 00:08:54
El nuevo número de usuarios es 00:08:56
Y el valor de esa variable 00:08:58
Pues la concateno 00:08:59
Con esta variable 00:09:03
Usuarios 00:09:04
¿Vale? 00:09:07
Entonces esta tontería de la concatenación 00:09:09
Me permite mostrar texto un poquito 00:09:11
Que tenga variables dentro 00:09:14
Que tenga valores de variables dentro 00:09:16
¿Vale? 00:09:18
porque esto ahora mismo, esto es una cadena enterita, 00:09:21
que es el resultado de concatenar esta cadena, 00:09:30
concatenada con el contenido de esta variable. 00:09:40
Bueno, pues este mensaje de resultado ya será más bonito, 00:09:45
porque me dirá, el nuevo número de usuarios es, 00:09:48
y me pondrá después la conversión a cadena de lo que contenga esta variable. 00:09:51
Si contiene 7, pues el carácter 7 00:09:55
Si contiene 28, pues 2 y 8 00:09:58
Entonces, concatenando 00:10:01
Podemos hacer, escribir texto 00:10:06
Para el usuario 00:10:08
Que tenga valores de variables 00:10:10
Dentro del texto 00:10:12
Lo voy concatenando con las variables 00:10:13
Y ya está 00:10:15
Si lo ejecutamos aquí 00:10:16
Introduzca el número de usuarios 00:10:28
¿Cuántos usuarios más han llegado? 00:10:32
El nuevo número de usuarios es 206 00:10:34
¿Vale? Sumo esto, sumo esto 00:10:38
Y yo luego hice una cadena que era la concatenación de 00:10:41
El nuevo número de usuarios es no sé qué 00:10:45
Concatenado con la nueva variable convertida a string 00:10:47
54 más 76 es 206 00:10:52
Forzamos la conversión a string 00:10:55
2, 0, 6 00:10:58
La concatenación es este mensajito 00:10:59
Este mensajito es la concatenación 00:11:02
Que es el que me ha mostrado aquí 00:11:06
Vale 00:11:09
Vamos aquí, concatenación de string 00:11:10
Bueno 00:11:34
Pues aquí lo tenéis 00:11:35
Bueno, esto de aquí 00:11:37
Dime 00:11:58
Es que le he puesto un espacio 00:11:59
Claro, aquí en la cadena le he metido un espacio 00:12:10
El nuevo usuario es 00:12:13
Y le he metido este espacio 00:12:19
Bueno, te sale junto 00:12:20
Si la cadena no tiene un espacio 00:12:37
Es que aquí el nombre 00:12:40
O sea, te refieres aquí, por ejemplo 00:12:42
Nombre 3, que me salía 00:12:44
Claro, pero porque es que el nombre 00:12:45
O sea, aquí estoy 00:12:47
A ver si te refieres a eso 00:12:49
Tengo... ¿Te refieres a esta situación? 00:12:50
O a esta 00:12:56
Que yo tengo nombre 1, que aquí me salía todo junto 00:12:57
El nombre pegadito al 6 00:13:00
Claro, pero porque nombre 1 00:13:01
no tiene ningún espacio aquí, entonces 00:13:04
él lo concatena, si yo pongo aquí un espacio 00:13:06
pues ya no me sale junto 00:13:08
o sea, concatena tal cual 00:13:10
lo concatena, lo deja pegado 00:13:12
claro, la cadena y el número 00:13:14
lo que pasa es que 00:13:16
yo aquí cuando he hecho el 00:13:18
system.out.println para concatenar 00:13:20
este texto con el otro 00:13:22
pues le he puesto aquí un espacio 00:13:24
para que esta 00:13:28
variable vaya pegada 00:13:30
al espacio de después 00:13:32
para que vaya pegada al espacio 00:13:33
porque si no queda muy apiñado, claro 00:13:36
el espacio es un carácter así más, lo puedo poner dentro de las cadenas 00:13:37
esto ya lo hemos mencionado 00:13:40
los operadores aritméticos ya lo hemos mencionado 00:13:49
sabéis que en matemáticas 00:13:53
hay un acuerdo 00:13:55
que los operadores de multiplicación y división 00:13:57
tengan precedencia 00:14:01
frente a los de suma y resta 00:14:03
entonces si en una expresión están todos puestos sin paréntesis 00:14:04
primero se hacen las multiplicaciones y divisiones 00:14:07
luego las sumas y restas, ya lo sabéis 00:14:09
pero si hay paréntesis entonces no 00:14:11
se hacen los paréntesis primeros 00:14:13
pero bueno, esto es lo de mates de siempre 00:14:15
pues es lo que mencionamos aquí y ya está 00:14:17
¿vale? 00:14:19
esto de conversión automática 00:14:23
y promoción casting 00:14:24
también lo hemos usado en algunos ejemplitos 00:14:27
la conversión automática 00:14:30
es lo que hemos dicho 00:14:32
promocionar un entero 00:14:33
a un double cuando están mezclados 00:14:36
en la misma operación 00:14:38
¿vale? aquí tenemos mezclados 00:14:39
un entero 00:14:42
está sumado 00:14:44
a un decimal, pues entonces 00:14:45
la máquina virtual, el entero 00:14:48
le pone el punto cero y eso es la 00:14:49
promoción automática 00:14:51
¿vale? esto ya lo hemos 00:14:53
mencionado, está 00:14:55
aquí todo 00:14:57
explicado de nuevo 00:14:59
¿vale? 00:15:01
entonces, lo del 00:15:07
casting es 00:15:19
forzar la conversión interna. 00:15:21
No lo vamos a usar ahora 00:15:25
porque el casting es peligroso y no 00:15:27
aquí está mencionado para completar el apartado 00:15:29
para que el apartado no se quede a medias. 00:15:33
Entonces, si leéis todo esto 00:15:35
para hacer el repaso de todo, lo deberíais leer 00:15:37
para hacer el repaso de todo y aseguraros de que 00:15:39
lo tenéis. Vale. 00:15:41
Pues si hacéis la lectura, 00:15:43
¿qué es lo que explica aquí? 00:15:44
Bueno, nosotros ya sabemos 00:15:47
lo que hemos dicho antes, que si tenemos 00:15:48
un numerito dabel, que es la suma de un entero 00:15:52
que estaba por aquí declarado, n igual a 7 00:16:00
por ejemplo, n más 00:16:04
4.3, imaginaos esta sentencia 00:16:08
ningún problema, está mezclando el operador 00:16:12
sumas, un decimal que es 4.3 00:16:16
con este que es entero 00:16:20
porque está en una variable entera 00:16:22
no hay ningún problema 00:16:24
coge el que es entero 00:16:26
lo promociona dabel 00:16:28
que sería como coger el 7 que está aquí 00:16:29
y una vez que ha cogido el 7 00:16:32
le pone el punto 0 00:16:34
¿vale? esta variable 00:16:36
lógicamente se queda intacta 00:16:38
no se entera, sigue con su 7 00:16:40
pero la máquina virtual ha cogido el valor 00:16:41
le ha puesto el punto 0 00:16:44
para poder hacer la suma 00:16:46
y ahora ya le queda pues 00:16:48
11.3, que es un double 00:16:50
y una vez que tiene el resultado 00:16:52
dice, ¿y ahora qué hago con esto? Pues ahora ya 00:16:54
cuando tenga el resultado, ya al final de todo 00:16:56
se va a mirar aquí 00:16:57
y dice, a ver, aquí que tengo 00:16:59
una variable double, menos mal 00:17:02
porque esto 00:17:04
si no, no cabría, menos mal que tengo 00:17:06
una variable double, con lo cual 00:17:08
lo guarda en double y listo 00:17:09
¿vale? 00:17:12
Ya sabemos, porque lo hemos probado 00:17:14
que si 00:17:16
esta variable 00:17:18
Resulta 00:17:19
Que no la hubiéramos declarado dabel 00:17:20
Sino que la hubiéramos 00:17:24
Declarado int 00:17:26
Sabemos que aquí hay un problema 00:17:27
Dime 00:17:31
Sabemos que aquí hay un problema 00:17:31
Porque me diría 00:17:36
Eh, ojo, ojo 00:17:37
Esto me va a dar dabel 00:17:38
Dabel en int no cabe 00:17:40
¿Vale? Esto ya lo vamos 00:17:43
Lo tenemos ya, lo van metiendo en la cabeza 00:17:45
Int en dabel cabe 00:17:47
Digo int y dabel 00:17:49
porque son los más estándar, podría ser int y float 00:17:51
son los mismos, float y double son decimales 00:17:53
int en double cabe 00:17:55
pero 00:17:57
perdona, double en 00:17:59
int no, luego aquí 00:18:01
ya el compilador ya te marcaría 00:18:03
un error y te diría, no te voy 00:18:05
a dejar que compiles esto y por tanto 00:18:07
lo ejecutes 00:18:09
¿por qué? 00:18:10
convertir de double a int 00:18:13
sí que implica 00:18:15
perder información, convertir de double 00:18:17
a int sería 00:18:19
quitar el punto 3 00:18:20
quedarse con 11 00:18:22
y eso es alterar el número completamente 00:18:23
pasar de 7 00:18:26
a 7.0 00:18:28
no altera la información 00:18:29
tenemos 7 unidades 00:18:31
no altera el número para nada 00:18:33
la cantidad es la misma 00:18:36
hay la misma cantidad en 7 que en 7.0 00:18:37
la cantidad es la misma 00:18:40
pero pasar de 11.3 00:18:40
a 11 00:18:44
esto claro que altera la información 00:18:45
porque estoy perdiendo 00:18:47
cero con tres, que es una cantidad 00:18:49
real, cero con tres 00:18:52
luego por eso el compilador no nos deja 00:18:53
hacer esas cosas 00:18:56
pero imaginémonos que aún así 00:18:56
nosotros queremos decir 00:18:59
me da lo mismo, yo necesito que este 00:19:02
número sea entero, entonces si hay 00:19:03
que quitar la parte decimal, que se quite 00:19:06
pero tú mete esto en un entero 00:19:07
aunque sea dabel, me da igual 00:19:10
entonces si queremos hacer 00:19:11
eso, que es 00:19:14
convertir un valor de un tipo 00:19:15
más grande, comodable 00:19:18
a uno más pequeño, que sí, podemos hacer 00:19:20
lo que explica el texto, que es un cast 00:19:22
que tendremos que hacer, pero en otras situaciones 00:19:23
y un casting 00:19:25
significa, castea 00:19:28
a entero 00:19:29
o lo que es lo mismo 00:19:32
quita la parte decimal, y ¿cómo escribo 00:19:34
eso en código? ¿cómo escribo eso en código? 00:19:36
porque si lo tengo que decir al 00:19:38
compilador, le tengo que decir, no, perdona 00:19:40
es que quiero hacer el cast 00:19:42
¿cómo lo escribo 00:19:43
ese código? Pues hacer un casting 00:19:46
se hace 00:19:48
poniendo delante 00:19:49
del número resultado, delante 00:19:57
de la expresión, pongo 00:19:59
el tipo al que quiero convertir 00:20:01
entre paréntesis. 00:20:03
¿Quieres convertir a in? 00:20:05
Pues pon el tipo al que quieres 00:20:07
convertir entre paréntesis. Ponlo. 00:20:09
Al que quieres convertir. 00:20:12
Y ahora ya pones eso 00:20:13
que quieres convertir, que en nuestro 00:20:15
caso era, pues por ejemplo, n 00:20:17
más 4 con 2 o lo que fuera, no lo sé. 00:20:19
Vale, entonces vamos a escribirlo ahí para que se vea, lo añadimos aquí, a ver, cuidado con los cambios de tipo, esto sin problema, vamos a imaginar que tenemos un int número igual a 4 00:20:21
Y ahora, un double decimal que es igual a número más 4.5, por ejemplo. 00:21:06
Esto ya sabemos que sin problema. 00:21:18
Coge el 4, le pone el punto 0, lo suma 4 con 5, le sale 8 con 5 y 8 con 5 va a double. 00:21:21
Ya está. 00:21:28
Esto no se puede, como ya sabemos. 00:21:33
Vamos a guardarlo en una variable entera. 00:21:38
Por ejemplo, en el propio número 00:21:40
Como ya sabemos que 00:21:43
Número más 4.5 00:21:44
Aquí ya se queja 00:21:50
¿Vale? 00:21:53
Coge número 00:21:54
Número es un entero 00:21:55
Muy bien, 4 00:21:57
Como lo suma a un decimal 00:21:58
Le pone el punto 0 00:22:00
Muy bien 00:22:02
Le queda 8.5 00:22:02
¿Vale? 00:22:04
Ahora ese 8.5 00:22:06
Intenta llevarlo a un int 00:22:07
Dice, no puedo llevar un 8.5 a un int 00:22:09
¿Vale? Hasta aquí es lo que sabemos 00:22:12
Pero puede ocurrir 00:22:14
Que yo quiera hacerlo 00:22:17
Igualmente y decir, no pasa nada 00:22:19
Si quiero hacerlo igualmente 00:22:26
Quitando la parte decimal 00:22:28
Podemos hacer un casting 00:22:29
Es decir, yo quiero 00:22:34
Me da lo mismo que esto sea 8.5 00:22:43
Quiero guardarlo en un int 00:22:46
Que pierdo el .5 00:22:47
Pierdo el .5 00:22:50
Lo siento 00:22:51
Pero claro, tengo que forzarlo y decirle al compilador 00:22:52
Que yo quiero hacer eso 00:22:55
Aun sabiendo que pierdo par de decimal 00:22:56
Pues como se hace un casting a un tipo 00:22:59
Un casting siempre es 00:23:01
Convertir un dato que tiene un tipo, en este caso 00:23:03
Double, a otro, en este caso 00:23:05
Int, eso es un casting 00:23:07
Cambiar el tipo de un dato, vale 00:23:08
Pues entonces, pongo 00:23:11
Al principio de todo 00:23:16
Entre paréntesis 00:23:18
El tipo al que quiero convertir 00:23:20
Vale, el tipo al que quiero convertir 00:23:22
y luego ya después 00:23:24
el valor que quiera convertir 00:23:27
aquí lo único cuidado 00:23:29
quiero convertir todo el resultado 00:23:31
entonces 00:23:33
tengo que ponerlo entre paréntesis para 00:23:34
que quede claro que el int 00:23:37
se refiere a todo enterito 00:23:39
a todo, si no pongo el paréntesis 00:23:41
el casting 00:23:45
se refiere solo a lo que tenga pegado 00:23:46
a lo que tenga ahí pegadito 00:23:49
si yo lo dejo así 00:23:51
el casting entiende 00:23:52
Del compilador que se refiere solo a número 00:23:55
Lo cual es una tontería, porque el número ya es entero 00:23:57
Sería una tontería 00:23:59
No, ojo, el casting se refiere a todo 00:23:59
El resultado final 00:24:03
Pues cuidadín, paréntesis 00:24:03
Vale 00:24:06
Pues estamos forzando 00:24:08
Que esto, que era decimal 00:24:10
Da igual, conviértelo 00:24:12
A int sí o sí 00:24:15
Quito la parte decimal 00:24:16
Y ahora ya sí que cabe en un entero 00:24:18
Ya sí que me ha dejado 00:24:20
entonces cuidado con los castings 00:24:22
porque es una solución maravillosa 00:24:25
para quitar todos los errores de compilación 00:24:27
y para generar todos los de ejecución 00:24:30
del mundo 00:24:32
uno ve un programa con muchas cosas rojas 00:24:32
muchas veces es porque lo ha diseñado 00:24:36
mal, lo ha planteado mal y está 00:24:38
metiendo en variables cosas que no son 00:24:39
entonces el compilador te dice 00:24:41
este tipo no es este tipo 00:24:43
y el compilador como lógicamente 00:24:45
no sabe programar ni el Eclipse ni nada 00:24:47
te lo soluciona 00:24:49
haciéndote un casting 00:24:51
todo lo rojo se quitó 00:24:52
pero el programa ha perdido todo el sentido 00:24:55
esto es como tienes un programa 00:24:56
con usuarios, facturas de usuarios 00:24:59
que vas gestionando 00:25:00
y lo has hecho tan mal que hay una línea 00:25:01
en la cual a un usuario 00:25:04
le estás asignando una factura 00:25:06
o sea un usuario 00:25:09
de repente es una factura 00:25:10
porque lo has diseñado mal 00:25:12
el compilador te dice 00:25:14
a una variable usuario le estás asignando 00:25:16
un objeto tipo factura 00:25:18
error, si le haces un casting 00:25:20
y factura, la transformas 00:25:22
a usuario, compila 00:25:24
sí, maravilloso, compila 00:25:26
pero no tiene ningún sentido que tú transformes 00:25:28
un papelito, factura, que la transformes de repente 00:25:30
en un humano 00:25:32
¿vale? pero el compilador se ha quitado el error 00:25:33
claro, luego tú ponte a ejecutar eso 00:25:36
cuando te pongas a ejecutar eso 00:25:38
y la máquina virtual se encuentra porque tiene que 00:25:40
transformar un papelito en un humano 00:25:42
pues lógicamente el programa peta 00:25:44
¿vale? entonces los 00:25:46
castings se tienen que 00:25:48
hacer cuando realmente 00:25:50
se controle que eso es lo que quiero 00:25:52
hacer, no porque 00:25:54
me quitan errores de compilación, creo que me quitan todos los 00:25:56
del mundo, pero el programa que 00:25:58
no tiene ningún sentido si yo cambio unos 00:26:00
tipos a otros así para que 00:26:02
las asignaciones se callen 00:26:04
¿vale? entonces los castings siempre van 00:26:06
a alterar el valor, que a mí no me importa 00:26:11
alterarlo y lo tengo controlado porque a mí no me 00:26:13
importa quitar aquí la parte decimal 00:26:15
pues venga, pongo el casting 00:26:17
Pero porque he identificado 00:26:19
Que aquí sí que quiero hacerlo 00:26:21
Bueno, pues ya está 00:26:23
Esto explica todo eso 00:26:40
Si tú necesitas 00:26:42
Hacer la conversión 00:26:52
Por ejemplo, esto 00:26:54
Como tal 00:26:55
Tiene sentido 00:26:58
Tú dices, convierte entero este 00:27:00
Entonces esto estaría sumando 00:27:03
El valor de este más 4 00:27:04
y el resultado convirtiéndolo a entero 00:27:07
ya sería entero 00:27:10
bueno, sí, 4 más el número 00:27:11
este que fuera 00:27:16
no lo sé, pero vamos, lo que valiera 00:27:16
4, 8, esto sería 00:27:19
este resultado sería 00:27:21
8 y sin el int 00:27:23
sería 8 también 00:27:26
porque lo hemos cambiado a entero 00:27:27
vale 00:27:29
a ver, siempre que necesites cambiar un tipo de dato 00:27:31
pero cuando necesitas cambiar 00:27:33
Haces ese casting, pero tienes que saber lo que haces 00:27:34
¿Vale? 00:27:37
Vale 00:27:48
Esto es muy 00:27:49
Esto es muy fácil 00:27:50
De entender 00:27:53
¿Vale? 00:27:54
A veces 00:27:58
A una variable le queremos sumar uno 00:27:58
Antes a número de usuarios le hemos sumado cualquier otra cosa 00:28:00
A veces le queremos sumar uno 00:28:03
Eso significa incrementar la variable 00:28:04
O a veces le queremos quitar uno 00:28:07
A una variable, eso se llama decrementar 00:28:09
Como es una operación muy habitual, tanto incrementar en 1 como decrementar, 00:28:11
porque es lo que hacemos cuando contamos, ¿no? 00:28:16
Me da igual contar hacia adelante que contar hacia atrás. 00:28:18
Contar es una operación natural. 00:28:21
Y entonces, en programación, también tenemos que contar muchas veces. 00:28:24
El programa nuestro muchas veces tendrá que contar. 00:28:29
¿Y contar qué es? 00:28:33
Incrementar en 1 muchas veces. 00:28:35
Eso es contar. 00:28:37
1, 2, 3, 4, incrementar en 1 00:28:38
un montón de veces 00:28:40
1 cuando paso a 2 ya he incrementado en 1 00:28:41
del 2 cuando paso a 3 ya he incrementado en 1 00:28:44
del 3 cuando paso a 4 ya he incrementado en 1 00:28:46
pues eso es contar 00:28:48
mi contador inicial 00:28:50
el que inicialmente está en 0 00:28:52
le incremento 1, ahora le incremento 1 otra vez 00:28:53
ahora le incremento 1 otra vez 00:28:56
y así mi contador inicial va pasando 00:28:58
0, 1, 2, 3 00:29:00
luego contar 00:29:01
es una operación natural 00:29:02
que tendrá que hacer un programa 00:29:05
muchas veces, contar cuántas veces 00:29:08
ha pasado algo, contar cuántos 00:29:10
usuarios se han dado de alta, contar 00:29:12
cuántas facturas se han pagado 00:29:14
o sea, contar es 00:29:16
una 00:29:17
actividad natural en un programa 00:29:20
bueno, pues contar implica 00:29:21
a una variable sumarle uno 00:29:23
muchas veces, luego sumar 00:29:25
uno a una variable es una operación natural 00:29:28
¿cómo sumamos uno a una 00:29:30
variable? pues ya lo sabemos hacer 00:29:32
¿verdad? 00:29:34
Si tenemos, por ejemplo, una variable contador para hacer una cuenta, que inicialmente es 0, voy a incrementarla en 1. 00:29:35
Ya sabemos que haríamos o bien esto, contador más 1, y ahora ya esta la incrementa en 1, su valor antiguo le suma 1 y valor nuevo a contador. 00:29:45
O esta de aquí, que es la misma que la de arriba. 00:30:03
vale, ya hemos visto antes 00:30:09
que esta expresión de abajo es la misma 00:30:13
que la de arriba, la misma 00:30:15
quito el igual, me queda contador más uno 00:30:16
¿qué hago con contador más uno? 00:30:19
se va a contador, son dos formas de hacer lo mismo 00:30:21
pero es que para este caso 00:30:23
cuando yo quiero incrementar uno 00:30:25
y solo uno, no cualquier otra burrada por aquí 00:30:27
sino solo uno 00:30:29
tengo otra abreviatura más 00:30:30
otra abreviatura más 00:30:32
que es esta 00:30:34
contador más más 00:30:36
luego 00:30:39
esta línea, esta línea 00:30:44
y esta línea 00:30:47
hacen exactamente 00:30:47
lo mismo, las tres 00:30:51
exactamente lo mismo 00:30:52
me da igual hacerlo así 00:30:54
que hacerlo así, que hacerlo así 00:30:57
¿vale? 00:31:00
esta es la abreviatura 00:31:03
más usada 00:31:04
entonces cuando veis contador++ 00:31:05
¿qué expresión matemática estáis viendo? 00:31:08
estáis viendo 00:31:10
una suma y una asignación 00:31:11
Todo esto estáis viendo 00:31:14
Una suma y una asignación 00:31:16
Estáis viendo todo eso 00:31:18
Cuando veis contador más más 00:31:21
Y también funciona 00:31:22
Cuando queremos decrementar en 1 00:31:27
Por ejemplo 00:31:29
Que ahora yo quiero al contador 00:31:32
Quitarle 1 porque estoy contando 00:31:33
Hacia atrás 00:31:35
Pues podríamos hacer 00:31:36
Contador menos 00:31:39
vale, entonces con esta expresión 00:31:43
el valor viejo de contador 00:31:50
lo he decrementado en 1 00:31:52
y el nuevo valor 00:31:54
a contador 00:31:56
vale, pues esto mismo con el operador 00:31:57
de arriba, ya sabemos 00:32:01
que lo podríamos hacer así 00:32:03
la de arriba y la de abajo son idénticas 00:32:04
hay una tercera forma de abreviar 00:32:15
esto 00:32:18
que es esta, entonces 00:32:18
de nuevo, las tres 00:32:28
son iguales 00:32:30
y cuando veis esta así tan cortita 00:32:31
estáis viendo dos cosas 00:32:34
una resta y una asignación 00:32:35
las dos 00:32:38
esto es una resta 00:32:39
en uno y el resultado 00:32:41
una asignación, entonces se usa 00:32:43
tanto lo de incrementar en uno o 00:32:50
decrementar en uno, porque lo 00:32:52
hacemos muchas veces cuando contamos 00:32:54
pues que hay una abreviatura 00:32:56
que es la que 00:32:58
usamos cuando incrementamos 00:33:01
en 1, no ponemos todo esto 00:33:03
porque es muy largo 00:33:05
pero podríamos porque es exactamente igual 00:33:06
hace lo mismo, es la misma expresión 00:33:09
pues esta abreviatura no puedes hacer 00:33:11
si quieres que, con contar 2 a que te refieres 00:33:33
sumar de 2 en 2 00:33:36
pues entonces esa abreviatura no te vale 00:33:42
tendrías que usar esta expresión 00:33:44
o esta 00:33:46
Entonces si quieres que cuente de dos en dos 00:33:47
Usas esta 00:33:55
O usas esta, esta no 00:33:56
Porque esta solo vale para contar de uno en uno 00:33:58
¿Vale? Esa solo vale 00:34:00
Para contar de uno en uno 00:34:02
¿Dónde va usted? 00:34:03
Ay, no puedes esperar los cinco minutos 00:34:08
Que faltan para que terminemos 00:34:10
Que ya en cinco minutos nos vamos 00:34:11
Cinco minutos, que serán ahí nueve 00:34:13
Aquí en el texto dice 00:34:18
Cinco minutos y ya nos vamos 00:34:24
Y relajamos 00:34:25
Que esto ha sido un rollo muy largo 00:34:27
Pero es que de verdad en mi caso es que no podemos hacer prácticamente nada 00:34:28
Si no tenemos esto 00:34:32
Revisado 00:34:34
Vale, aquí en el texto digo 00:34:36
El operador este puede ir 00:34:38
A la derecha o a la izquierda 00:34:40
Claro que puede ir 00:34:41
Es decir, si yo pongo 00:34:42
Más más 00:34:44
Contador 00:34:46
Esto también funciona 00:34:48
Y si pongo 00:34:50
Menos menos 00:34:52
Contador 00:34:53
Esto también funciona 00:34:55
Entonces 00:34:58
¿Cuál es la diferencia? 00:35:01
Entre ponerlo delante o ponerlo detrás 00:35:06
Pues así 00:35:08
Cuando va suelto 00:35:11
Con la variable 00:35:13
Cuando va suelto 00:35:14
No hay ninguna diferencia 00:35:15
Me da lo mismo 00:35:17
lo normal es que lo ponga detrás porque se ve mejor 00:35:18
no hay ninguna diferencia 00:35:21
esto y esto hace lo mismo que es incrementar en uno 00:35:22
contador y esto y esto hace lo mismo 00:35:25
que es incrementar en uno contador 00:35:27
entonces porque hay dos versiones 00:35:28
ponerlo delante y ponerlo detrás 00:35:30
hay dos versiones porque Java me permite 00:35:31
a la vez que incremento 00:35:35
una variable usarla 00:35:37
dentro de otra expresión más complicada 00:35:39
por ejemplo 00:35:41
podemos 00:35:43
usar el incremento 00:35:51
o el decremento dentro de otras expresiones. 00:35:54
Por ejemplo, vamos a imaginar que tenemos aquí nuestro numerito, 00:36:04
número, que tendremos algún número por ahí declarado entero, ¿verdad? 00:36:12
Sí, este. 00:36:15
Vale. 00:36:18
Yo tengo aquí mi número y mi número, por ejemplo, 00:36:20
va a ser igual a contador más 3. 00:36:25
¿Vale? 00:36:29
Primera expresión que se me ha ocurrido. 00:36:29
Vale. 00:36:32
Pues entonces, yo necesito incrementar este número a lo que tenga el contador más 3 y quiero dejar contador incrementado, quiero dejarlo incrementado además, porque el contador cada vez que lo use para lo que sea, además luego lo quiero dejar incrementado, por ejemplo. 00:36:33
Pues entonces, Java me permite, a la vez que uso una variable dentro de una expresión, 00:36:53
a la vez que la uso, contador o la que sea, a la vez que la uso, incrementarla. 00:36:59
Me deja esto. 00:37:06
¿Vale? 00:37:08
Entonces, yo cualquier variable que yo use dentro de una expresión, cualquiera, como esta, cualquier variable, 00:37:09
yo puedo, si quiero, ponerle el incremento. 00:37:16
¿Y esto qué significa? 00:37:20
El incremento al principio es como si no existiera. 00:37:21
Tú haces contador más 3. 00:37:24
Vale. 00:37:28
El resultado va a número. 00:37:29
Y este significa, y ahora que ya has terminado, 00:37:31
además deja contador incrementado en 1. 00:37:35
Luego, esto me permite hacer dos operaciones en una. 00:37:39
Primera, la asignación a número de contador más 3. 00:37:43
Y luego, una vez terminado, dejo contador incrementado. 00:37:48
Porque a lo mejor hay una operación, 00:37:51
Hay una situación en la cual yo quiero usar esta variable contador, pero cada vez que la use, la quiero dejar incrementada en 1 para avisar de que la he usado. 00:37:53
¿Vale? 00:38:02
Bueno, pues pongo el más más y eso significa. 00:38:04
Bueno, pues aquí sí que hay diferencia entre que el más más vaya antes o que el más más vaya antes o que vaya después. 00:38:09
Aquí sí que hay diferencia. 00:38:20
es decir, estas dos expresiones tienen comportamiento distinto, 00:38:21
comportamiento distinto, esta y esta, pero poniendo el más más delante, 00:38:40
ambas son válidas y serían contador más 3 a número, 00:39:01
Y luego deja incrementado el contador 00:39:05
Pero esta deja incrementado el contador luego 00:39:08
Y esta lo incrementa antes 00:39:10
Luego lo vemos ya despacio 00:39:12
Y paramos aquí 00:39:14
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:
2
Fecha:
29 de septiembre de 2025 - 17:41
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
39′ 21″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
753.18 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid