Saltar navegación

20250929-ProgEstr-Operadores_1 - 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

Vale, pues este es el documento, ¿está proyectando? Sí. Vale, pues no perdamos el contexto de que lo que vamos a revisar ahora son operadores que nos ofrece Java para construir expresiones y como resultado de la evaluación de esas expresiones la máquina virtual de Java obtendrá valores resultado, ¿vale? 00:00:00
Bueno, pues operadores aritméticos 00:00:25
Aquí ya los conocemos casi todos 00:00:29
Hay poco que decir 00:00:32
Cuando necesitamos hacer suma de datos 00:00:33
Resta, multiplicación, cualquier operador 00:00:35
Cualquier operación aritmética de esta 00:00:39
Pues tenemos estos cuatro operadores 00:00:42
Que ya los hemos usado como son básicos 00:00:44
Para sumar valores que habían variables 00:00:46
O restar, o multiplicar, o dividir 00:00:48
¿Vale? 00:00:51
Entonces, este operador que lo incluye 00:00:52
pues cualquier lenguaje de programación 00:00:54
lo conocéis, es el operador 00:00:56
que se suele llamar operador módulo 00:00:58
que no es más que la resta, perdón 00:01:00
el resto, ¿vale? 00:01:02
Entonces, cuando 00:01:05
tenemos una división entre 00:01:06
enteros, porque estos operadores 00:01:08
recordad que 00:01:10
todos en general pueden funcionar distinto 00:01:12
en función del tipo 00:01:14
de dato que tengan a cada lado 00:01:16
del tipo de dato que tengan a cada lado 00:01:18
el operador suma 00:01:20
me da igual que tenga números enteros o números decimales, me da igual, va a hacer la suma, si tengo números enteros va a hacer la suma de dos enteros, si tengo dos decimales va a hacer la suma de dos decimales, claro, pero funciona siempre como nuestra suma de toda la vida, la resta igual, el producto igual, me da igual que tenga dos enteros a los lados o dos decimales a los lados, la resta y la multiplicación va a funcionar como la que conocemos, ¿vale? 00:01:22
también sabemos 00:01:50
porque lo hemos visto en ejemplos 00:01:51
que en estos operadores aritméticos 00:01:53
yo puedo mezclar y poner 00:01:55
un int o entero a un lado 00:01:57
y un decimal a otro 00:01:59
¿y qué es lo que hace la máquina virtual? 00:02:00
pues promociona 00:02:04
el entero a decimal poniéndole 00:02:05
punto cero 00:02:07
porque para poner un punto cero no pasa nada 00:02:08
no alteras el número, me da igual 00:02:11
3.0 que 3 00:02:13
no lo altero porque el valor es el mismo 00:02:14
es el mismo valor 00:02:17
entonces cualquiera de estos operadores aritméticos 00:02:18
si se encuentra un entero a un lado 00:02:21
y un decimal a otro 00:02:23
pues antes de hacer la operación 00:02:24
el entero le pone un punto cero 00:02:26
luego hace la operación 00:02:29
y ya le queda en decimal 00:02:30
vale 00:02:32
y espera por tanto 00:02:33
guardarlo en una variable decimal 00:02:35
porque si no va a decir 00:02:37
uy es decimal no cabe 00:02:38
vale 00:02:39
todo esto lo hemos visto en ejemplos 00:02:40
bueno 00:02:41
entonces estos operadores 00:02:42
estos tres de aquí 00:02:44
suma, resta y multiplicación 00:02:45
Pues lo que acabamos de decir 00:02:47
Me da igual que yo a los lados tenga 00:02:49
Números enteros, números decimales 00:02:51
La operación va a ser la misma 00:02:53
La que conocemos nosotros 00:02:56
Como suma, resta y multiplicación 00:02:57
No funciona distinta 00:02:59
Este 00:03:01
Si que es el que funciona distinto 00:03:02
Que también lo hemos visto en ejemplos 00:03:05
En función de si tú tienes 00:03:07
Operadores decimales 00:03:09
O enteros a los lados 00:03:11
Depende 00:03:13
Si tienes enteros 00:03:14
La división es la resta entera 00:03:16
¿Verdad? 00:03:21
Si tenemos enteros 00:03:23
Si tú tienes enteros a los lados 00:03:24
7 entre 3 00:03:29
Esto interpreta que este operador es el cociente 00:03:31
La división entera, he dicho resta entera antes, creo 00:03:37
El cociente 00:03:40
Entonces 7 entre 3, pues 2 00:03:42
Nos daría 2 00:03:44
¿Vale? 00:03:45
Pero sin embargo 00:03:48
si lo que tenemos son valores 00:03:49
decimales, me da igual el valor 00:03:51
directamente que una 00:03:53
variable que lo contenga 00:03:55
vale, me da igual, estoy poniendo el valor directamente 00:03:56
pero ya sabemos que podríamos poner 00:03:59
una variable y entonces 00:04:01
se referiría al valor que contenga 00:04:03
me da igual, si la variable es double 00:04:05
contendrá un valor decimal 00:04:07
bueno, pues si lo que tiene es números decimales 00:04:08
a los lados, pues me dará 00:04:11
la división decimal 00:04:13
tal cual, con decimales, los que salgan 00:04:15
Yo qué sé, no sé lo que sale, me da igual 00:04:17
¿Vale? 00:04:19
Entonces, este operador sí que hace dos cosas distintas 00:04:21
A diferencia de estos tres 00:04:25
El operador división hace dos cosas distintas 00:04:26
En función de si tenemos enteros o decimales 00:04:29
Y de nuevo, también Java admite que mezclemos 00:04:32
Y pasará lo mismo que si usamos los de arriba 00:04:36
Si estamos mezclando tipos de datos 00:04:42
Él lo que hace es, no pasa nada 00:04:45
promociono este a decimal 00:04:47
porque da igual 7, que 7.0 00:04:49
no altera el valor 00:04:51
lo promociono a decimal 00:04:53
y entonces ahora ya sí que 00:04:55
considero la división 00:04:57
decimal, porque ahora tengo dos números 00:04:59
decimales, y como ahora tengo dos números decimales 00:05:01
considero 00:05:04
que me estás pidiendo la división decimal 00:05:05
¿vale? esto lo hemos visto en ejemplos 00:05:07
y también hemos visto que 00:05:10
si la división es decimal, esto tiene que ir 00:05:11
a un número decimal 00:05:13
a un double o a un float 00:05:15
¿Vale? Esto no podría ir a un entero 00:05:16
Lógicamente 00:05:19
Y este operador 00:05:20
El porciento, el operador resto módulo 00:05:23
Está en cualquier lenguaje de programación 00:05:26
Y es un operador matemático 00:05:28
Que también conoces de matemáticas 00:05:30
Que es muy útil para calcular 00:05:31
O sea, sirve para calcular el resto de divisiones enteras 00:05:34
Y es muy útil 00:05:37
¿Vale? Porque tiene un sentido matemático grande 00:05:39
El resto de una división entera 00:05:41
Tiene un sentido matemático grande 00:05:42
¿Vale? 00:05:44
Respecto a si 00:05:46
pues un número es múltiplo de otro 00:05:47
si cabe exactamente en él, se puede usar 00:05:49
para muchas cosas, entonces esto 00:05:51
lo usamos cuando necesitamos 00:05:53
el resto de una 00:05:55
división entera, entonces 00:05:57
7 por 00:05:59
102, pues nos 00:06:01
da 1, porque 00:06:03
el resto de dividir 7 entre 2 00:06:05
es 1 y ya está 00:06:07
para eso lo usamos y a veces 00:06:08
es útil, bueno 00:06:11
pues sobre estos operadores 00:06:13
No tenemos mucho más que decir 00:06:15
Si hay dudas sobre algo 00:06:18
Me paráis 00:06:21
No, admite decimales 00:06:21
Pero cuando le pones decimales 00:06:24
No sé muy bien qué sentido tiene que le pongas decimales 00:06:25
La verdad 00:06:28
Pero tú le puedes poner decimales 00:06:28
Y te lo hace 00:06:31
Lo que pasa es que no sé muy bien 00:06:32
Qué sentido tiene la operación módulo entre decimales 00:06:35
Alguno tendrá 00:06:38
Porque si te deja ponerlo 00:06:40
Alguno tendrá 00:06:41
Vamos a preguntárselo 00:06:42
A nuestro amigo. 00:06:44
A ver si nos dice algo con sentido. 00:06:47
¿Qué sentido tiene hacer la... 00:06:53
Ah, que no se ve, perdón. 00:06:57
¿Qué sentido tiene hacer la operación... 00:07:00
...módulo entre números decimales? 00:07:03
A ver si tiene algún sentido. 00:07:10
Bueno, el concepto se puede extender. 00:07:16
Casi que no nos interesa 00:07:18
Extender el concepto 00:07:23
Bueno, se puede extender matemáticamente 00:07:25
El concepto de operación módulo a decimales 00:07:29
Según esta formulita 00:07:31
Y entiendo entonces 00:07:36
Que los lenguajes de programación 00:07:39
Cuando le damos decimales 00:07:41
Es esa lo que usa 00:07:42
Por ejemplo, vamos a probar a hacer 7.5, 2.3 00:07:43
A ver si nos da 0.6 00:07:46
Que nos lo dará, supongo 00:07:47
Vamos a probar un segundito 00:07:48
Ejemplos operadores 00:07:51
vale, vamos a poner aquí aritméticos 00:08:00
por ejemplo, si yo me hago una variable double 00:08:14
num y le voy a 00:08:19
decir que esta variable double num me guarde 00:08:24
7,5 entre 2,3 00:08:27
el resto, perdón, módulo, 2,3 00:08:31
Vale, entiendo que nos dará 0,6 00:08:40
Sí, efectivamente 00:08:47
Esto es lo que sale de la 00:09:02
¿Qué sentido matemático tiene la operación módulo en números decimales? 00:09:03
No lo sé, yo no la he usado nunca 00:09:12
No, alguno tendrá, ¿no? 00:09:13
Reducción a intervalos, sí tiene sentido 00:09:17
Obtienes un excedente 00:09:19
bueno, si alguien tiene más curiosidad 00:09:22
que indague, vale, a partir de ahí 00:09:24
normalmente 00:09:26
este operador se usa 00:09:28
con números enteros y te da 00:09:30
el resto de la división entera, que eso sí 00:09:32
que es un concepto muy natural 00:09:34
y que usamos 00:09:35
a veces, pues para 00:09:38
efectivamente ver el excedente 00:09:40
entero que hay en determinadas situaciones 00:09:42
el excedente decimal 00:09:45
es un concepto que usamos menos 00:09:46
cuando gestionamos cosas 00:09:48
Una aplicación cuando gestiona cosas 00:09:50
Suele gestionar cosas enteras 00:09:52
Usuarios, facturas 00:09:54
No gestiona tres usuarios 00:09:56
Y medio o cuatro facturas y media 00:09:59
Entonces el concepto de excedente decimal 00:10:01
Es más extraño 00:10:03
Que el de excedente entero 00:10:05
Que es el resto 00:10:07
Venga pues a ver 00:10:07
En cuanto a esos operadores 00:10:17
Vale 00:10:19
Aquí lo tenéis además 00:10:23
Si es verdad, si es que además esto lo escribí 00:10:29
Si esto lo escribí yo el año pasado 00:10:31
Porque lo estuve mirando 00:10:34
Pero como no lo he vuelto a usar 00:10:35
Me había olvidado de ello 00:10:36
Pero esto está escrito aquí del año pasado 00:10:37
Porque lo habíamos estado usando 00:10:39
Operador de asignación 00:10:41
De nuevo 00:10:46
Lo conocemos perfectamente 00:10:48
El igual 00:10:50
El operador igual tiene 00:10:51
Un único sentido 00:10:53
Que es usarse en una expresión de asignación 00:10:55
¿Vale? 00:10:58
Tampoco tenemos nada que decir sobre él 00:11:00
Porque lo hemos usado todo el rato 00:11:03
Aquí tenemos ejemplitos 00:11:04
Varios, nada, vale 00:11:09
Ahora sí 00:11:11
Vamos a conocer el más igual 00:11:13
Que es una forma de abreviar 00:11:15
Operaciones estándar 00:11:18
¿Vale? Entonces 00:11:20
Este ya sí que es algo nuevo 00:11:21
Vamos a revisarlo 00:11:24
Vamos a revisarlo 00:11:26
Porque esto sí que se usa muy muy muy a menudo 00:11:27
Esta abreviatura 00:11:29
Vale, vamos a ponerlo aquí. Méticos con asignación. Vale, pues una situación muy habitual es que tengamos un dato y a ese dato queramos sumarle un valor o multiplicarle un valor a ese propio dato. 00:11:31
por ejemplo, yo tengo 00:12:03
mi conjunto de usuarios guardado en una variable 00:12:05
por ejemplo, numusuarios 00:12:08
que va a guardar el número de usuarios 00:12:11
que yo tengo en un momento dado en mi aplicación 00:12:13
para gestionar 00:12:15
o lo que sea, vale 00:12:17
entonces 00:12:21
vamos a 00:12:23
de partida, vamos a pedirle 00:12:25
cuantos usuarios tiene, con lo cual voy a 00:12:27
poner el escáner aquí arriba 00:12:29
del todo, como solo lo creo 00:12:31
una vez y luego lo uso todas las veces que quiera 00:12:33
lo pongo arriba del todo 00:12:35
así lo tengo ya creado y me olvido 00:12:36
de él, vale, ya tengo este 00:12:39
escáner aquí creado 00:12:48
y me olvido de él 00:12:49
olvidaos porque me 00:12:52
preguntáis a veces cuando hay un 00:12:54
simbolito amarillo 00:12:56
eso es un aviso, no es un error de 00:12:58
compilación, el error de compilación 00:13:00
está en rojo y impide 00:13:02
que el programa se pueda 00:13:04
compilar y por tanto generar 00:13:06
el punto clase, vale, entonces no 00:13:08
ejecutamos un programa 00:13:10
colores de compilación 00:13:12
los tenemos que arreglar 00:13:13
bueno, lo amarillo 00:13:16
es un warning, es un aviso 00:13:18
te dice cosas 00:13:20
que podrían 00:13:22
generarte problemas a la hora 00:13:24
de ejecutar 00:13:26
uy, esto que has hecho, cuidado, que se te olvida 00:13:28
esto y podría generarte un problema 00:13:30
en la ejecución, no es un problema 00:13:32
ahora de compilación, yo puedo compilar y ya está 00:13:34
pero cuidado que te puede generar un problema 00:13:36
en la ejecución, ¿vale? 00:13:38
Entonces, uno puede ignorar esto, este en particular lo puede ignorar, ahora os explicaré lo que significa ahora, aunque algunos ya os lo he dicho, pero este en particular se puede ignorar, habrá otros que no ignoremos porque sí que son avisos peligrosos y digo, uy, es que esto puede que me honore de ejecución en esta situación, pues bienvenido sea ese aviso. 00:13:40
Este, como ya habéis visto, lo que dice es, cuidado que esto está sin cerrar o algo así dice, ¿no? 00:14:03
Lo que me pasa en esta y en la anterior 00:14:10
es que me salta el rojo 00:14:12
y me pone que 00:14:14
como que escáner no puede ser. 00:14:15
Claro, porque tienes que hacer el import 00:14:18
este de arriba. 00:14:20
O lo escribes a mano o 00:14:24
si te aparece... 00:14:26
Por ejemplo, si yo no lo tuviera, me aparece 00:14:28
aquí y me dice eso. 00:14:30
Me dice, escáner no lo encuentro. 00:14:32
Entonces, 00:14:35
el Eclipse te ayuda para que no lo tengas 00:14:36
que escribir tú a mano. Pinchas aquí 00:14:38
y haces import. 00:14:40
Y ala, ya te lo has escrito solito, ¿vale? 00:14:42
Sí, sí, no, más que lo correcto es que hay que hacerlos ahí, 00:14:56
no puedes hacerlo en otro sitio. 00:14:59
Estas sentencias import tienen que ir después de esta, 00:15:00
que te dice en qué directorio estás, 00:15:04
y antes de la class. 00:15:06
Tienen que ir ahí obligatoriamente, ¿vale? 00:15:08
Bueno, pues entonces, aquí una vez arreglado el seguro de compilación, 00:15:15
este nos dice, cuidado que el scan nunca lo cierras. 00:15:19
Da igual, pero vamos a ver lo que significa. 00:15:24
A ver, scan es un objeto, es una variable que hemos declarado de un tipo que no es primitivo, no es sin, no es dable, no es nada. 00:15:26
Entonces, es que este es un tipo que ya está hecho, que es el tipo scanner, que es un tipo objeto. 00:15:34
Recordad lo que dijimos que eran los tipos objetos del otro día. 00:15:39
Entonces, este tipo objeto, como todos los objetos, tiene un montón de cosas dentro y además es capaz de llamar a código, como dijimos de los objetos el otro día. 00:15:43
De hecho, este objeto scan es capaz de llamar al código, lee un entero, lee un decimal, o sea, es un objeto muy complejo, más que el string, que solamente son un montón de caracteres y ya está, este es más complejo. 00:15:53
Bueno, pues este es tan complejo que cuando llama esos códigos, lo que hace es, como ya sabemos, automáticamente abre un flujo con el buffer del teclado, 00:16:06
donde está lo que nosotros hemos escrito 00:16:17
ahí está en el buffer hardware 00:16:20
ahí puesto 00:16:22
y de ese buffer saca lo que hay 00:16:22
y lo guarda en una variable 00:16:26
java para que nosotros 00:16:28
ya lo cojamos y se lo demos 00:16:30
a nuestra propia variable mediante una asignación 00:16:31
o lo que sea 00:16:34
entonces parte de lo que hace es conectarse 00:16:34
a un recurso hardware externo 00:16:38
como el buffer 00:16:40
cuando java 00:16:40
no solo mediante este objeto 00:16:44
sino mediante muchos otros objetos que ya veremos 00:16:45
se apodera de un recurso 00:16:47
como el buffer del teclado 00:16:50
como un fichero para sacar datos de él 00:16:51
lo deja bloqueado 00:16:53
y lo va a dejar así bloqueado 00:16:54
hasta que no lo cerremos 00:16:56
y digamos, uy, objeto cerrado 00:16:58
con una cosa closed ya no nos importa 00:17:00
entonces te dice, cuidado 00:17:03
que desde el momento en que has creado esto 00:17:05
te estás apoderando del buffer del teclado 00:17:07
y lo has dejado bloqueado 00:17:10
¿nos importa? 00:17:11
No nos importa porque no hay ningún otro programa 00:17:12
Ejecutándose en paralelo que use el teclado 00:17:15
Nosotros ejecutamos nuestro programa 00:17:18
Y somos los 00:17:20
Y somos los únicos 00:17:21
Que estamos escribiendo en el teclado 00:17:23
Cuando estamos ejecutando el programa, no nos importa 00:17:25
Que lo deje bloqueado, nos da igual 00:17:27
Por eso no lo cerramos 00:17:29
Y porque tampoco entendemos muy bien 00:17:30
Que hacemos cuando lo cerramos, etc 00:17:33
Y no lo estamos usando sin entender este objeto 00:17:35
Solo porque lo necesitamos para hablar del teclado 00:17:37
Pero bueno, que sepáis que es lo que nos dice 00:17:39
¿Por qué nos dice eso? 00:17:41
Que lo deje bloqueado no es problema porque en cuanto el programa termina, 00:17:43
que el programa termina en las cuatro líneas que tiene, 00:17:48
automáticamente todas las variables que tuviera desaparecen, entre ellas esta. 00:17:51
Entonces el buffer se queda liberado. 00:17:56
En cuanto el programa termina, ya está, este objeto ha desaparecido, el buffer se queda liberado. 00:17:59
El problema sería que este programa no terminará nunca, 00:18:03
Estuviera ahí todo el rato con el scan 00:18:06
Y efectivamente el buffer del teclado 00:18:08
Estaría ahí enganchado a este scan 00:18:11
Y si otro hilo 00:18:13
Tiene que usarlo, pues no podría 00:18:15
Pero no es nuestra situación 00:18:16
Así que podemos ignorar ese warning 00:18:18
Vale, pues entonces, creamos el scan 00:18:20
Vamos a leer 00:18:23
El número de usuarios 00:18:25
Este sistema, no sé qué hace aquí 00:18:26
Vale 00:18:32
Vamos a decirle aquí 00:18:34
Así que iba yo a poner 00:18:38
Introduzca número de usuarios 00:18:41
Por eso está así 00:18:43
Introduzca número 00:18:43
De usuarios 00:18:49
Vale 00:18:52
Pues venga, número de usuarios 00:18:54
Que sea igual a 00:18:56
Scan.nextint 00:18:58
Ala, ya está 00:19:03
Ya sabemos como funciona esta sentencia 00:19:04
Deja 00:19:07
Al programa ahí cruzado de brazos 00:19:07
esperando que llegue un número 00:19:10
y cuando ese número llega 00:19:12
lo recoge del buffer y lo guarda en la 00:19:13
variable que le estamos asignando 00:19:16
vale 00:19:17
bueno pues ya está, este es el número de usuarios 00:19:20
entonces, puede ser 00:19:23
que ahora de repente el programa haga cosas 00:19:26
bla bla bla 00:19:28
y el número de usuarios aumente, me llegan usuarios 00:19:28
nuevos 00:19:32
vale, llegan usuarios nuevos 00:19:32
por ejemplo 00:19:35
vale, pues vamos a 00:19:36
guardarlos aquí 00:19:58
vale 00:20:02
bueno, pues entonces, ahora yo que quiero hacer 00:20:11
lo que yo quiero hacer ahora es 00:20:21
actualizar esta variable 00:20:22
para que se incremente 00:20:25
en esta nueva cantidad 00:20:28
vale, tengo dos variables diferentes 00:20:30
primera 00:20:32
mi número de usuarios original 00:20:34
segunda, el incremento 00:20:35
son dos datos distintos, mi número de usuarios 00:20:38
original y el incremento 00:20:40
Y ahora quiero que mi variable original se quede actualizada, se quede pisada con el valor que tenía antiguo más el incremento nuevo. 00:20:42
¿Vale? 00:20:54
Entonces, ¿qué sentencia haríais aquí para conseguir eso? 00:20:56
Que a la variable en un usuario se le asigne el valor que tenía de antes más el incremento. 00:20:59
¿Alguien me la dicta? 00:21:08
¿Perdón? 00:21:11
No, más o igual no quiero que me uséis. 00:21:15
Quiero que me uséis los operadores que conocemos 00:21:18
Y la asignación que conocemos 00:21:19
¿Eh? ¿Qué alguien me diste? 00:21:21
Num más 00:21:27
Pero num no existe 00:21:28
Número de usuarios más el otro 00:21:31
Número de usuarios 00:21:34
Más el otro 00:21:40
Vale, pero esto 00:21:42
¿Qué hago con esto? 00:21:45
Vale, pero yo quiero que este valor 00:21:53
Que es el número de usuarios 00:21:55
Yo quiero que este valor 00:21:57
Que era el antiguo 00:22:02
Más este num nuevos 00:22:04
Que es el incremento 00:22:05
¿Dónde quiero que vaya este valor? 00:22:07
Con lo cual ¿A quién se lo asigno? 00:22:09
Vale, pues entonces 00:22:12
Esto 00:22:13
Usuarios 00:22:14
Vale, esta sería la sentencia 00:22:19
Que haría, ¿verdad? 00:22:22
La máquina virtual ¿Qué hace? 00:22:25
Lo primero de todo 00:22:26
Se va a la derecha 00:22:27
A ver la expresión 00:22:29
A quien se le asigne 00:22:30
Ahora mismo no le importa nada 00:22:32
Recordad que siempre trabaja así 00:22:34
Cuando ve una asignación 00:22:36
Cuando ve una asignación 00:22:38
Primero se va a la derecha 00:22:40
A hacer la operación 00:22:43
La operación es 00:22:45
Uy, la suma de dos variables 00:22:47
Vale, pues me cojo la primera variable 00:22:48
Que es efectivamente el número antiguo 00:22:52
Lo que tenga 00:22:54
Me cojo la segunda variable 00:22:55
que es el incremento, hago la suma 00:22:57
y me da el valor 00:22:59
si numu usuarios originalmente 00:23:00
tenía 7 00:23:03
y el incremento es 2 00:23:04
pues efectivamente 00:23:07
el número de usuarios original que era 7 00:23:09
más el incremento 2 me da 9 00:23:11
entonces se le evalúa su expresión y ya está 00:23:13
y cuando ya todo eso está terminado 00:23:15
ahora ya dice, ¿y ahora qué hago con esto? 00:23:17
pues ahora ya se va 00:23:20
a la izquierda a ver qué hace con eso 00:23:21
y dice, ah, que lo quieres en numu usuarios 00:23:23
muy bien, pues 00:23:24
pisó el valor anterior 00:23:26
antes tenía 7 numus 00:23:29
usuarios, pisado 00:23:31
ahora se queda en 9 00:23:32
¿vale? entonces 00:23:34
no hay problema 00:23:38
lógicamente 00:23:40
cuando asignamos a 00:23:41
una variable una expresión 00:23:44
que involucra la propia variable 00:23:47
de hecho 00:23:48
es lo natural porque las variables 00:23:50
las podemos modificar normalmente 00:23:52
para que cambien su valor 00:23:55
y a veces esa modificación 00:23:56
depende del valor antiguo. 00:23:58
Entonces, la modificación 00:24:01
del nuevo valor de esta variable 00:24:02
depende del valor antiguo. 00:24:04
Es el antiguo más 2. 00:24:06
Depende del valor antiguo. 00:24:08
Esto es como cuando hacemos 00:24:09
esta operación, 00:24:10
esta función matemática. 00:24:11
fx igual a x más 2. 00:24:13
El nuevo valor es el antiguo más 2. 00:24:15
El nuevo valor es el antiguo más 2. 00:24:18
Que el antiguo es 10, 00:24:20
pues el nuevo será 12. 00:24:22
Que el antiguo es 8, 00:24:24
pues el nuevo será 10, ¿vale? 00:24:25
Entonces, muchas veces, repito, 00:24:28
una asignación a una variable 00:24:31
se hace a través de una expresión 00:24:33
que involucra la propia variable, no pasa nada. 00:24:36
La máquina virtual cogerá su valor antiguo 00:24:39
para hacer la operación, 00:24:41
cogerá el valor que tenga en ese momento, el antiguo. 00:24:43
Cuando ya ha construido la operación, 00:24:46
pisa ese valor antiguo, lo pisa 00:24:48
y esa variable se queda con el valor nuevo, ¿vale? 00:24:50
El valor antiguo se coge para hacer la evaluación de la expresión. 00:24:55
Cuando ya esté evaluado, automáticamente se pisa ese valor antiguo que hemos cogido para hacer la evaluación, se pisa con el resultante. 00:25:00
¿Vale? 00:25:11
Entendida esa idea, ¿no? 00:25:12
Y quien dice numusorios más nuevos podría ser numusuarios por dos menos numusuarios. 00:25:15
Podría ser una expresión todo lo compleja que uno quisiera y no pasa nada. 00:25:20
En lugar de esta, pues podríamos tener numUsuarios igual a numUsuarios por 7 menos numUsuarios. 00:25:25
No pasa nada, la máquina virtual dice, ah, vale, voy a hacer esta expresión. 00:25:39
Valor en este momento de numUsuarios por 7 menos valor en este momento de numUsuarios, el original, el antiguo, el que tenga en ese momento. 00:25:43
cuando ya lo he construido 00:25:52
sustituyendo esto por su valor 00:25:54
en ese momento, o sea, el antiguo 00:25:57
en ese momento, cuando ya lo he construido 00:25:59
tengo un nuevo valor 00:26:01
pues ese nuevo valor pisa ese valor 00:26:01
antiguo, ese que he utilizado 00:26:05
aquí, lo pisa con el nuevo 00:26:07
y ya está 00:26:09
bueno, pues entonces 00:26:10
entendida la idea 00:26:14
de que una asignación 00:26:17
a una variable puede, lógicamente 00:26:19
incorporar una expresión 00:26:21
que use esa propia variable 00:26:22
pues ahora ya 00:26:25
ahí podemos usar 00:26:26
para hacer esto mismo un operador 00:26:29
que nos lo hace más abreviado 00:26:31
es decir 00:26:33
hay una situación que podemos hacer mucho 00:26:35
que es a una variable 00:26:37
la incremento con una cantidad 00:26:38
o a una variable la decremento con una cantidad 00:26:40
como eso es algo que hacemos mucho 00:26:43
por ejemplo aquí, a esta variable 00:26:44
la he incrementado con esta 00:26:47
o podría hacer esto otro, ahora vamos a decrementarlo 00:26:48
Al valor que me ha quedado 00:26:51
Lo decremento 00:26:55
¿Vale? Como esto es algo que hacemos mucho 00:26:59
Incrementar con una cantidad 00:27:07
Una variable para actualizar 00:27:09
Con el nuevo valor 00:27:11
O decrementarlo 00:27:12
Pues esta expresión 00:27:13
Se puede abreviar 00:27:15
Esta expresión se puede abreviar 00:27:18
Entonces, esta misma expresión de arriba 00:27:20
Otra forma de escribir 00:27:22
Esto mismo 00:27:27
Sería esto 00:27:28
num 00:27:32
usuarios 00:27:34
más igual 00:27:36
num nuevos 00:27:38
y en esta de abajo 00:27:40
pues por ejemplo lo mismo 00:27:50
num usuarios menos 00:27:51
igual num nuevos 00:28:00
esta sentencia de arriba 00:28:01
y esta sentencia de abajo 00:28:05
son la misma, idéntica 00:28:08
me da igual usar una 00:28:10
que usar la otra 00:28:11
y aquí igual 00:28:12
¿vale? 00:28:14
O sea, quedaba ahí el cursor puesto. 00:28:17
Vale. 00:28:21
Entonces, cuando vemos un más igual, 00:28:23
un más igual lo vemos siempre, ¿vale? 00:28:26
Después de una variable a la que estamos asignando algo. 00:28:31
Vemos una variable cualquiera, n más igual, lo que sea. 00:28:34
Pues entonces, cuando vemos un más igual, 00:28:40
siempre tenemos que operar, que pensar, para no olvidarnos. 00:28:43
Cuando vemos un más igual en una asignación, n más igual, lo que sea. 00:28:47
pues lo que tenemos que hacer es 00:28:51
tapar el igual 00:28:53
tapamos el igual 00:28:54
y nos quedará una expresión 00:28:56
hacemos esta expresión 00:28:58
y cuando tengamos el resultado 00:29:01
la asignación se hace 00:29:04
a la variable 00:29:07
que está justo delante del más igual 00:29:09
es la forma de entender 00:29:11
este operador 00:29:13
porque nos lo podemos encontrar 00:29:14
teniendo aquí a la derecha 00:29:16
cosas más largas y más grandes 00:29:18
no solo una variable, ¿vale? 00:29:20
Entonces, para entender 00:29:23
esa expresión que estamos mirando, 00:29:24
pues, lo más fácil es 00:29:27
nos olvidamos del igual 00:29:29
porque la asignación es lo que se hace al final, 00:29:31
eso ya lo sabemos, la asignación se hace al final. 00:29:33
Primero se hace la expresión, 00:29:35
pues nos olvidamos del igual 00:29:37
y nos va a quedar una expresión, ¿verdad? 00:29:38
Nos va a quedar aquí una expresión. 00:29:41
Se hace la expresión, cuando la expresión 00:29:44
esté, ese resultado 00:29:46
final, ¿dónde lo meto? 00:29:49
pues lo metemos 00:29:51
en aquello que esté a la izquierda 00:29:53
del más igual, así es como 00:29:55
va a actuar la máquina virtual cuando ve 00:29:57
un más igual, ¿vale? así es como va a actuar 00:29:59
¿vale? porque aquí 00:30:01
repito, podría haber una cosa 00:30:03
más complicada, numu usuarios 00:30:05
más igual 00:30:07
no pasa nada 00:30:08
significa, oye, a ver, numu 00:30:10
usuarios más num nuevos, es la expresión que me 00:30:13
ha quedado, ¿vale? ¿qué hago ahora 00:30:15
con numu usuarios más num nuevos? 00:30:17
Quito esto, ah vale 00:30:19
Va a la variable que está a la izquierda 00:30:21
Y lo mismo con menos igual 00:30:24
Y con por igual 00:30:29
Con división igual 00:30:31
Son formas de abreviar 00:30:33
Expresiones que involucran a la misma variable a la que lo asigno 00:30:35
¿Vale? 00:30:41
Al tapar esto 00:30:43
Aparece una expresión en la que está esta variable 00:30:44
Operamos 00:30:47
¿Y el resultado final a quién va? 00:30:49
Pues a esa misma variable 00:30:51
Entonces, pues hombre, es muy común 00:30:53
Lógicamente que los usemos porque son muy cómodos 00:31:02
Cuando sobre una misma variable 00:31:04
Guardamos el resultado 00:31:06
De una expresión en la que la hemos usado 00:31:08
Que la involucra a ella 00:31:11
¿Vale? 00:31:12
Entonces, x más 00:31:20
Bueno 00:31:21
Ninguna duda, ¿no? 00:31:29
Aquí hay nada, breves explicaciones 00:31:32
Chorras y ya está 00:31:33
Entonces, esa abreviatura con el igual 00:31:35
Se puede hacer con cualquier otro operador 00:31:44
No solo con los aritméticos 00:31:48
Por eso he puesto aquí esta tabla 00:31:49
Pero bueno, es que estos operadores de aquí abajo 00:31:53
Este desplazamiento de bits 00:31:56
El an, el or y el sort de bits 00:31:58
Estos no los hemos visto todavía 00:32:00
Pero lo que quiero poner aquí es que con cualquier otro operador 00:32:02
Que haga cosas con variables 00:32:05
No solo los aritméticos 00:32:07
Cualquier otro que haga cosas con variables 00:32:08
Se puede usar la abreviatura con igual 00:32:10
Y siempre será igual 00:32:13
uno, que me encuentro 00:32:17
esta operación, aunque ahora mismo no sepamos 00:32:19
lo que significa esta operación 00:32:21
pues que es lo que es realmente 00:32:22
es como si el igual no existiera 00:32:24
me queda una expresión 00:32:27
evalúo esa expresión 00:32:29
y el resultado va a la variable de la izquierda 00:32:31
aquí igual me encuentro este 00:32:35
que significa esto 00:32:36
pues esto es como si el igual no existiera 00:32:37
me encuentro una expresión que es el 00:32:40
a and b 00:32:42
y ahora el a and b una vez evaluado 00:32:43
donde va, pues la variable de la izquierda 00:32:46
es una manera de 00:32:48
simplificar 00:32:50
ahora de escribir, simplificar código 00:32:54
a la máquina virtual le da igual como lo escribamos 00:32:56
lo que hace es lo mismo 00:32:57
va a hacer lo mismo, todo esto son cuestiones 00:32:59
de que el código sea un poquito más claro 00:33:01
y más legible 00:33:03
y ver x más igual 3 00:33:04
rápidamente vemos, a x le incremento 3 00:33:07
x igual a x más 3 00:33:10
no sé, es como más feo 00:33:12
estamos como menos acostumbrados a verlo 00:33:13
y lo vemos y decimos 00:33:15
Uy, qué feo, x igual a x más 3 00:33:17
Y toda la vida lo he visto x más igual 3 00:33:19
Es eso en realidad 00:33:22
No es más que eso 00:33:24
Bueno, sobre esta forma de abreviar 00:33:24
Alguna duda 00:33:29
Nothing, de nothing 00:33:30
Vale, el operador más 00:33:33
Cuidadín, que ahora ya sí que sí 00:33:35
¿Vale? 00:33:37
El operador más, que nos volvemos a él 00:33:39
Hemos dicho 00:33:42
El operador más de toda la vida, ¿para qué nos vale? 00:33:45
Pues para sumar 00:33:49
Números, ¿verdad? 00:33:50
El operador más nos vale para sumar numeritos 00:33:52
Para eso nos vale 00:33:58
Y hemos dicho 00:33:59
Me da igual que los números sean decimales o enteros 00:34:01
O incluso mezcla 00:34:04
Porque va a hacer la suma natural, aritmética, algebraica 00:34:05
De toda la vida y ya está 00:34:08
Pero el operador más 00:34:09
Tiene una funcionalidad añadida 00:34:12
Que no tienen los demás 00:34:15
Tiene una funcionalidad añadida 00:34:17
Y es que el operador más 00:34:19
Puede llevar también objetos string a los lados 00:34:20
No solo números 00:34:24
No solo números 00:34:25
¿Vale? 00:34:26
Es decir, vamos a ponerlo aquí para que se quede grabado 00:34:29
A ver 00:34:34
Vamos a ponerlo aquí 00:34:35
Operador más con cadenas 00:34:38
Vale, pues vamos a imaginarnos que tenemos una variable string 00:34:47
Nombre 1 00:34:53
en lugar de leerlo por teclado 00:34:55
que es más lento 00:34:59
pues nada, venga 00:35:01
vale 00:35:03
a mi string yo le puedo 00:35:05
asignar directamente una cadena de texto 00:35:07
entrecomillada doble 00:35:09
porque eso es un string 00:35:11
otro string 00:35:12
nombre 2 00:35:16
vale 00:35:21
pues resulta 00:35:26
que el operador más 00:35:29
también se puede usar con 00:35:31
operadores con operandos que sean cadenas no sólo números y cuando son 00:35:33
cadenas que hace con ellos las concatena es el operador concatenación 00:35:39
entonces cuando el operador más se usa con operandos string funciona como 00:35:45
concatenación de texto lo cual nos es muy útil también a veces por ejemplo si 00:35:58
yo hago 00:36:08
nombre1 más nombre2 00:36:10
esta operación es 00:36:12
perfectamente válida, está concatenando 00:36:14
nombre1 y nombre2 00:36:17
su contenido 00:36:18
el resultado de una concatenación de cadenas 00:36:19
es otra cadena 00:36:22
luego esto donde tiene que ir, tiene que ir 00:36:24
a algún lado, no lo puedo dejar así 00:36:26
pues por ejemplo 00:36:27
vamos a ponerlo en un 00:36:29
string nombre3 00:36:32
¿cómo? 00:36:33
aquí 00:36:46
Bueno, a ver, nuevos y no usuarios, los dos son int 00:36:47
No, ¿por qué? 00:36:55
Esta es la expresión esta de aquí 00:37:02
Tú tienes ya las variables declaradas 00:37:04
Esta variable menos esta otra 00:37:06
Se lo guardo en esta 00:37:08
Y esta es otra forma de escribirlo de arriba 00:37:09
Aquí ya el tipo de edad 00:37:12
Las variables ya están declaradas con su tipo 00:37:13
Aquí no hay que hacer ninguna referencia a nada 00:37:16
Vale, entonces 00:37:18
Como este involucra 00:37:20
Una cadena 00:37:23
Y otra cadena 00:37:25
El resultado de la concatenación 00:37:26
Tiene que ir a otra cadena 00:37:29
Con lo cual tiene que ir a un string 00:37:30
Y si mostramos ahora nombre 3 00:37:32
Pues veremos 00:37:35
Efectivamente 00:37:37
Que lo ha concatenado 00:37:38
Vamos a ejecutarlo 00:37:40
Al principio me pide el número este 00:37:43
Para mostrar 00:37:45
Vale 00:37:47
la suma de dos variables string 00:37:49
en realidad es la concatenación 00:37:57
y el resultado por tanto 00:37:59
es una variable string o cadena 00:38:01
y efectivamente hemos visto 00:38:03
que nombre3 me ha guardado eso 00:38:05
¿vale? 00:38:07
vamos a parar aquí un momento 00:38:09
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:37
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
38′ 11″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
730.92 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid