Saltar navegación

20250922-ProgEstr-Variables_6 - 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 22 de septiembre de 2025 por Raquel G.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues del tipo char, poco más que esto que hemos dicho, el tipo char admite un carácter de los de la tabla ASCII, ese carácter se lo puedo dar entre comillas simples en la asignación o le puedo dar un numerito entero, 13, 14, ¿vale? 00:00:01
pero cuidado con 00:00:19
el matiz de darle una variable 00:00:21
entera, entonces ya no 00:00:24
entonces ya no 00:00:25
porque el compilador 00:00:28
trabaja por reglas 00:00:30
y la regla dice el número entero podría 00:00:31
tener algo mucho más grande 00:00:34
que los numeritos de la 00:00:35
tabla ASTI 00:00:38
y esto se extiende a no sé 00:00:38
quién ha preguntado lo del byte y el short 00:00:42
entonces yo le doy no tampoco, porque la regla es que 00:00:43
tiene el compilador es 00:00:46
Algo que tú has declarado con Ochar 00:00:47
Solamente le puedes dar 00:00:49
O un carácter así 00:00:52
¿Vale? 00:00:54
O se lo das en número 00:00:56
Pero un número que ya de partida 00:00:57
76 sea de los 00:00:59
Que están en la tabla ASCII 00:01:01
Pero no le podemos dar 00:01:03
Por ejemplo, tengo mi variable byte 00:01:07
Que tiene igual al 76 00:01:08
Por ejemplo 00:01:10
Entonces, a carácter 00:01:11
Le podría dar 00:01:14
la variable b 00:01:17
porque un byte 00:01:19
se guarda en 8 bits 00:01:21
entonces el compilador podría decir 00:01:22
no sé que hay en byte pero es imposible 00:01:25
que sea un número 00:01:27
que no esté en la tabla ASCII 00:01:28
pues no, las reglas son 00:01:30
a una variable char 00:01:32
no puedes darle nada que no sea 00:01:34
un tipo compatible exactamente 00:01:37
bien un char 00:01:39
entre comillas o el número 00:01:41
¿vale? 00:01:43
entonces estos casos tan raros 00:01:44
pues nos olvidamos, no los tenemos presentes 00:01:49
porque ni siquiera los usamos 00:01:51
y lo único que hay que tener en cuenta 00:01:52
es que a la inversa sí 00:01:56
a una variable entera 00:01:57
a la inversa sí es lo que acabamos de ver 00:01:59
a una variable entera 00:02:01
le puedes asignar 00:02:03
lo que tenga una variable char 00:02:05
eso sí que puedes 00:02:07
y esa variable entera 00:02:09
se va a quedar con el número entero 00:02:11
que codifica este carácter 00:02:13
por eso aquí cuando hemos mostrado esto 00:02:16
carácter me mostraba el char 00:02:19
y este me mostraba el número entero 00:02:22
porque la variable es entera 00:02:24
y se ha quedado con el número entero 00:02:26
bueno, es lo que hemos dicho antes 00:02:27
repasado así un poquito 00:02:30
un poquito por encima 00:02:31
¿vale? 00:02:33
entonces 00:02:36
¿qué ventajas tiene 00:02:37
el poder trabajar 00:02:39
con los caracteres 00:02:42
con las variables char 00:02:46
indistintamente 00:02:47
con el carácter 00:02:49
entre comillas simples o el numerito 00:02:52
pues bueno, tiene algunas ventajas 00:02:53
a la hora de operar 00:02:56
por ejemplo 00:02:57
vale, por ejemplo 00:03:08
aunque luego ya, y está recogido en los documentos 00:03:12
de la JOSIBA de la virtual 00:03:15
aunque ya tendremos que ver más en detalle 00:03:15
En la sentencia de asignación, ¿qué es eso de valor que yo le pongo a la derecha? En una sentencia de asignación como esta, ya sabemos, ya nos está quedando en la cabeza y nos empieza a sonar que la sentencia de asignación siempre es el nombre de variable a la izquierda. 00:03:19
un nombre de variable que esté previamente 00:03:42
declarada y que exista 00:03:45
¿vale? eso ya lo vamos dejando 00:03:46
grabado en la cabeza 00:03:49
entonces las cosas que 00:03:50
digo, eso ya se va quedando grabado en la cabeza 00:03:52
es así que se quedan grabadas 00:03:55
en la cabeza, ¿vale? no en el papel 00:03:57
¿vale? y otras cosas que os digo 00:03:58
bueno, son pequeños matices, que no espero 00:04:01
que todo el mundo tenga los matices en la cabeza 00:04:03
siempre, si los ha oído 00:04:05
alguna vez, cuando está haciendo 00:04:07
un programa y le sale un error afinado con eso 00:04:09
pues hace la conexión cerebral 00:04:11
¡Ah! Esto me sonaba que era 00:04:13
porque había una promoción automática 00:04:15
y no sé qué me sonaba, entonces 00:04:17
con que te suenen ciertas cosas 00:04:19
ya tienes el punto para tirar del hilo 00:04:21
¿vale? Pero hay cosas que no 00:04:23
basta con que suenen 00:04:25
hay muchísimas que tienen 00:04:26
que estar grabadas y memorizadas en la cabeza 00:04:29
no en el papel, ¿vale? 00:04:31
Pues una por ejemplo es 00:04:33
cómo se declara una variable, cómo es una 00:04:34
sentencia de asignación, bueno pues 00:04:37
eso ya a fuerza de decirlo 00:04:39
ya lo tenemos grabado en la cabeza 00:04:41
a la izquierda, nombre de una variable 00:04:42
que previamente 00:04:46
tiene que estar declarada 00:04:47
porque si no el compilador va a decir 00:04:49
esa variable no sé cuál es 00:04:51
con lo cual cómo voy a meter algo 00:04:53
en una variable que no existe 00:04:54
espacio operador de asignación 00:04:57
bueno, el espacio es por cuestión de estilo, no por obligación 00:04:59
operador de asignación 00:05:01
y aquí hemos dicho 00:05:02
un valor 00:05:04
del mismo tipo 00:05:06
y pongo mismo tipo entre comillas 00:05:09
porque aquí hemos visto algunas excepciones 00:05:12
como la promoción automática de int a long 00:05:15
o como a un int le puedo dar un sub 00:05:17
hemos visto algunas excepciones 00:05:20
valor del mismo tipo que la variable 00:05:22
esto es lo que sí que hemos incorporado 00:05:26
algunos matices a que el valor tenga que ser del mismo tipo 00:05:32
pues la promoción automática que hemos visto antes 00:05:37
que se puede hacer de un int a un long 00:05:40
o de un sort a un int 00:05:42
lo de asignar a un int 00:05:43
se le puede dar un char 00:05:46
y no pasa nada 00:05:48
porque el int se queda con el valor numérico 00:05:49
que codifique el char, o sea, hay matices 00:05:51
que son excepciones 00:05:53
para que el valor que hay aquí 00:05:55
tenga que ser del mismo tipo 00:05:58
idéntico que la variable, son excepciones 00:06:00
pero en general 00:06:01
si las variables se declaran 00:06:02
de un tipo 00:06:06
es para asegurarse 00:06:06
para que el programa se asegure de que 00:06:09
solo vas a meter cosas de ese tipo. 00:06:11
Y así se evitan errores 00:06:14
de ejecución. 00:06:15
¿Del mismo tipo te refieres a qué? 00:06:17
Que si es un boolean, 00:06:22
solo puede ir algo que sea un boolean. 00:06:23
Ya veremos lo que es. Si es un número entero, 00:06:25
solo algo que sea un número entero. 00:06:28
Si es un número decimal, solo algo 00:06:30
que sea un número decimal. 00:06:32
Si es un char, solo algo 00:06:34
que sea un char. 00:06:36
¿Vale? 00:06:38
entonces, este es el principio básico 00:06:38
de asignación de variables 00:06:42
este valor 00:06:43
tiene que ser del mismo tipo 00:06:44
del tipo del que se ha declarado 00:06:48
pero hay algunas excepciones 00:06:50
en esta asignación 00:06:52
como algunas que hemos mencionado 00:06:53
esta 00:06:55
la que viene de la promoción automática que hemos dicho 00:06:57
la variable está declarada como long 00:07:00
te le doy un int 00:07:02
no pasa nada, eso te lo tolero 00:07:03
porque yo puedo expandir el valor int 00:07:05
con ceros a la izquierda y meterlo en long 00:07:08
la variable está declarada como en short 00:07:09
y te he puesto un byte 00:07:12
no pasa nada, eso te lo tolero 00:07:13
porque el byte puedes tenderlo con ceros 00:07:16
a la izquierda y te cabe en short 00:07:18
entonces es una excepción 00:07:19
para que esto de aquí no sea el mismo tipo 00:07:22
otra 00:07:24
la que hemos visto 00:07:26
la variable está declarada como int 00:07:27
y me estás dando un char 00:07:29
esa también te dejo, yo cojo el valor 00:07:30
numérico que codifica ese char en la tabla 00:07:34
y pongo el semáforo en la variable i. 00:07:36
Hay excepciones que hacen más operativa la escritura de código. 00:07:39
Pero en general, si el lenguaje es tipado, 00:07:43
o lo que es lo mismo, te obliga a especificar un tipo, 00:07:47
es precisamente para que tú no hagas cosas extrañas 00:07:50
y metas en las variables cosas para lo cual están pensadas esas variables. 00:07:53
Si una variable está pensada para que tenga un nombre, 00:07:59
no le metas un 7 00:08:02
porque un 7 no es un nombre 00:08:04
es un número 00:08:06
para hacer eso están otros lenguajes 00:08:07
con otros objetivos 00:08:09
pero no está Java para eso 00:08:11
Java está para hacer aplicaciones robustas 00:08:13
entonces, si desde partida 00:08:16
te obliga que si tú una variable 00:08:18
va a tener un nombre 00:08:19
una cadena de caracteres, ya veremos cómo 00:08:21
solo le puedes meter un nombre 00:08:23
tú eso ya 00:08:25
en el momento que estás escribiendo código 00:08:27
ya estás cumpliendo esa obligación 00:08:29
La estás cumpliendo. 00:08:31
Luego, cuando ya lo ejecutes, como has hecho tus deberes, 00:08:33
la ejecución va a estar bien. 00:08:37
Porque has hecho los deberes en tiempo de escritura de código, 00:08:38
que es que todo encaje, que todo esté bien. 00:08:41
Si el compilador te dejara poner cualquier cosa, 00:08:43
podrías no hacer tus deberes y en una cadena de caracteres 00:08:47
meter un 7, te dejaría no hacer tus deberes. 00:08:50
Cuando eso se ejecuta, seguramente te salgan cosas 00:08:54
fruto de esa incoherencia. 00:08:57
me estás diciendo que este alumno se llama 7 00:08:59
eso te va a fallar 00:09:01
¿vale? 00:09:04
en Java todo eso 00:09:05
no va a ocurrir porque ya en tiempo de escritura 00:09:07
del código has tenido que cumplir unas reglas 00:09:10
porque si no el compilador te dice 00:09:12
no, no puedo 00:09:13
no voy a compilar, si no compilo 00:09:15
porque hay errores de compilación 00:09:17
pues no ejecuto, no ejecutas 00:09:19
solo se puede ejecutar lo que previamente se ha compilado 00:09:21
como ya sabemos del primer día 00:09:24
vale, pues entonces 00:09:25
todo esto venía a cuento de la sentencia de asignación 00:09:28
que estábamos aquí 00:09:31
repasando 00:09:32
vale 00:09:35
esta se ha quedado tonta 00:09:36
vale 00:09:39
entonces 00:09:49
en la sentencia de asignación por tanto 00:09:52
el compilador va a mirar que aquí haya un valor 00:09:54
como hemos dicho 00:09:56
del mismo tipo salvo estos matices 00:09:57
que nos están surgiendo y estamos viendo 00:10:00
vale entonces 00:10:02
esto de aquí que es 00:10:05
lo que hemos llamado 00:10:12
el valor 00:10:13
ya hemos visto dos formas 00:10:14
de darlo 00:10:19
dos formas de proveer ese valor 00:10:21
ya hemos visto dos maneras 00:10:23
a través de dos ejemplos 00:10:24
una 00:10:28
directamente el valor que sea 00:10:30
¿vale? como cuando hemos hecho 00:10:35
n igual a 7 00:10:42
directamente el valor 00:10:44
tal cual 00:10:46
o cuando hemos hecho c que era un char 00:10:47
igual a G 00:10:50
directamente, el valor tal cual 00:10:53
¿vale? 00:10:55
pero hemos visto también otras formas 00:10:57
de dar el valor 00:10:59
en una sentencia de asignación 00:11:01
la otra forma que hemos dicho 00:11:03
es dando una variable 00:11:05
por ejemplo, cuando hemos hecho 00:11:06
N igual a M 00:11:13
lo hemos hecho con las edades 00:11:16
edad tocha igual a edad 00:11:17
esta es otra asignación válida 00:11:19
¿vale? 00:11:21
aquí la forma de dar el valor 00:11:22
no es darlo directamente 00:11:25
7g el valor exacto 00:11:26
la forma de dar el valor 00:11:28
es dar otra variable 00:11:30
doy otra variable y ya hemos visto 00:11:32
que es lo que hace la máquina virtual cuando ejecute esto 00:11:34
se va a la RAM 00:11:37
a mirar la variable que se llama así 00:11:39
mira lo que hay dentro 00:11:42
y ese mismo valor, ese mismo 00:11:44
lo copia aquí 00:11:47
¿vale? se quedan las dos variables 00:11:48
con el mismo valor 00:11:51
pero las variables siguen siendo independientes 00:11:52
luego yo a M le puedo asignar otra cosa 00:11:55
a N otra, ¿vale? 00:11:57
hemos hecho asignaciones 00:11:59
de las dos maneras 00:12:00
¿vale? 00:12:03
pero tenemos una tercera manera 00:12:06
de dar valores 00:12:08
de otorgar aquí un valor 00:12:10
porque eso es lo que va ahí, ¿verdad? 00:12:13
ahí va un valor 00:12:16
tenemos otra manera de dar un valor 00:12:17
que es construir una expresión 00:12:19
una expresión con operadores 00:12:21
que de tal manera 00:12:24
que cuando esa expresión se evalúe 00:12:27
el resultado de la evaluación 00:12:29
de esa expresión sea un valor compatible 00:12:31
es decir, una expresión 00:12:33
con operadores 00:12:37
ahora lo vamos a ver 00:12:41
con un ejemplo 00:12:44
yo puedo poner una expresión que involucra operadores 00:12:45
están los básicos 00:12:48
sumas y restas 00:12:50
y los hay luego más complejos 00:12:52
que están todos recogidos en el aula virtual 00:12:54
puedo conseguir una expresión 00:12:55
pues 3 más 12 00:12:57
3 más 12 ahora ya es una expresión 00:13:00
no es un valor tal cual 00:13:03
no es 15 00:13:04
3 más 12 es una expresión 00:13:05
¿por qué? 00:13:08
porque involucra valores y operadores 00:13:10
en este caso el operador de suma 00:13:12
¿vale? 00:13:15
eso es una expresión 00:13:16
la máquina virtual cuando se encuentra una expresión 00:13:17
correctamente 00:13:21
escrita 00:13:22
porque claro, de nuevo también hay que satisfacer 00:13:24
las reglas sintácticas para construir expresiones. 00:13:26
Que ya tendremos que detallar una por una. 00:13:30
Pero bueno, lo básico lo podemos usar ahora 00:13:32
para hacer unos primeros ejemplos. 00:13:34
Pues la máquina virtual cuando se encuentra una expresión 00:13:36
la evalúa, es decir, hace la operación. 00:13:38
El resultado de esa evaluación 00:13:43
o de hacer esa operación 00:13:45
me da un valor. 00:13:47
Y ahora ese valor ya sí que lo asigno a la variable. 00:13:49
Luego, recopilando 00:13:54
yo le asigno valores a una variable 00:13:56
en general de tres maneras 00:13:59
bueno, hay más 00:14:01
a través de una interfaz gráfica, a través de no sé qué 00:14:03
pero eso ya es otra tarea 00:14:05
directamente el valor 00:14:06
tal cual 00:14:09
eso es asignar por código, por programa 00:14:10
le asigno el 7 00:14:13
lo que sea 00:14:15
vale 00:14:16
asignárselo a través de otra variable 00:14:18
asignárselo a través de otra 00:14:21
vale 00:14:23
esto nos ha quedado claro 00:14:25
lo que significa 00:14:28
o construí una expresión 00:14:28
que tendré que 00:14:31
repito, cumplir las reglas 00:14:32
sintácticas para construir expresiones 00:14:35
construí una expresión 00:14:38
esa expresión 00:14:40
le tocará a la máquina virtual evaluarla 00:14:41
y cuando la tenga 00:14:44
evaluada el valor que ha resultado 00:14:46
de esa evaluación 00:14:48
se va a la variable 00:14:49
y ya está 00:14:52
¿Vale? Pues por ejemplo, entonces, si yo, vale, aquí ejemplo con operaciones que estábamos, pues venga, para cambiar con variables nuevas, me voy a coger una variable número, le doy el 34, por ejemplo, número 1. 00:14:53
Y ahora me voy a hacer una variable número 2. Bueno, pues a número 2 yo le puedo asignar, por ejemplo, esta expresión, número 1 más 12. 00:15:37
Entonces, aunque ya veremos los operadores, podemos imaginar que Java entiende los aritméticos básicos, claro, los aritméticos básicos los entiende. 00:16:03
Entiende la suma, la resta, la multiplicación con el asterisco y la división. 00:16:20
Lo que pasa es que este funciona diferente en función de si le das números enteros o decimales. 00:16:29
ahora mismo como solo estamos con enteros 00:16:34
esta operación te da la división entera 00:16:36
es decir, el cociente 00:16:39
este sería el operador cociente 00:16:41
te da el cociente 00:16:44
ya está, el cociente 00:16:44
entonces podemos, eso lo podíamos deducir 00:16:46
que hombre, que menos que te entienda 00:16:50
los operadores básicos 00:16:51
no te entiende el operador potencia 00:16:53
no tiene el logaritmo 00:16:55
esos operadores no los entiende 00:16:57
para eso hay que construir 00:16:59
hay que usar objetos 00:17:01
patatín patatán 00:17:03
Pero estos los entiende tal cual 00:17:04
No hay que complicarse la vida 00:17:07
Bueno, pues 00:17:08
Estos son operadores 00:17:09
Los aritméticos básicos 00:17:11
Estos serían 00:17:14
Los operadores aritméticos básicos 00:17:15
¿Vale? 00:17:18
Que estos serían los operadores 00:17:19
Aritméticos básicos que se llaman 00:17:31
Pero vamos, de estos hay que explicar 00:17:33
Cómo funcionan 00:17:42
¿Qué regla sintáctica tenemos que seguir 00:17:42
Cuando los usamos? 00:17:45
Pues hombre, que tienen que tener un operador delante 00:17:47
y otro detrás, ya está 00:17:49
entonces si ponemos un operador delante 00:17:50
y otro detrás, pues estamos siguiendo 00:17:54
la regla sintáctica 00:17:56
que necesita Java 00:17:57
entonces esta expresión es válida 00:17:59
porque tenemos un operador delante 00:18:05
y otro detrás 00:18:07
y de nuevo, exactamente igual que hemos dicho antes 00:18:08
cuando yo doy un valor 00:18:11
cuando doy un valor 00:18:12
o bien doy el valor directamente 00:18:14
tal cual, o bien lo puedo 00:18:17
dar mediante una variable 00:18:19
o sea, yo siempre que dé un valor a alguien 00:18:20
sea dentro de una expresión 00:18:23
o sea directamente un valor a una variable. 00:18:26
Siempre que yo quiera, 00:18:29
siempre que yo necesite un valor 00:18:31
en una expresión o donde sea, 00:18:32
tengo dos formas de obtenerlo. 00:18:36
Poniéndolo tal cual 00:18:38
o poniendo una variable que lo tenga dentro. 00:18:39
Me da lo mismo. 00:18:43
¿Vale? 00:18:44
El valor tal cual 00:18:47
y una variable que lo tiene 00:18:48
es lo mismo. 00:18:51
de cara a las expresiones, a las asignaciones, a todo. 00:18:52
Es lo mismo. 00:18:56
Entonces, poner número 1 o poner 34, en este caso, 00:18:58
es exactamente igual. 00:19:05
La operación va a obtener el mismo resultado 00:19:07
porque número 1 tiene dentro 34. 00:19:10
¿Vale? 00:19:15
Entonces, siempre que yo necesite un valor, 00:19:15
ese valor puede provenir de calcarlo tal cual 00:19:19
o de poner una variable que lo contiene. 00:19:22
¿Vale? Hasta ahí está entendido, ¿no? Lo que pasa es que, claro, lógicamente aquí estamos programando. Se trata de hacer cosas que tengan sentido. 00:19:24
Porque, por ejemplo, estas dos sentencias, vosotros ponéis aquí, número 2 igual a 34 más 12, ¿vale? 00:19:37
Las dos hacen lo mismo. 00:19:54
Las dos suman 12 a 34 y el resultado lo guardan en número 2. 00:19:58
Eso es lo que hace la máquina virtual cuando se encuentra una expresión, ¿no? 00:20:06
Se encuentra la expresión, hace la operación correspondiente y el resultado va aquí. 00:20:09
Número 2 tendrá aquí su espacio, número 1 aquí su espacio. 00:20:17
Número 1 resulta que tiene 34, muy bien. 00:20:25
Vale, llegamos a este punto. 00:20:29
La máquina virtual, número 1 más 12. 00:20:31
El compilador nos ha dado vía libre para ejecutar porque es una expresión correctamente elaborada. 00:20:34
Vale, pues ¿qué hace la máquina virtual? ¿Me has dado la variable? Pues me voy a mirar la variable que tiene, 34. Cojo el 34. Lo sumo al 12. Pues nada, lo que me dé, 46. ¿Qué hago con ese 46? Lo guardo en número 2. 00:20:41
Se acaba la sentencia 00:21:01
Si en lugar de esta de arriba 00:21:04
Hubiéramos tenido la de abajo 00:21:09
Hubiera sido lo mismo 00:21:11
¿Verdad? 00:21:15
La máquina virtual se encuentra 00:21:17
Esta operación que es válida 00:21:19
Es un operador suma con dos valores a los lados 00:21:20
Hace la suma 00:21:23
Bueno, pues el 46 00:21:27
¿Dónde quieres que vaya? 00:21:29
A número 2 00:21:30
Entonces, claro, podríais decir 00:21:31
Pues es lo mismo. Esta sentencia y esta son lo mismo. No son lo mismo, tienen nada que ver. Esta es una mierda, esta sentencia está bien. ¿Qué quiero decir con eso? Que esta sentencia, este programa mío, solamente va a hacer 34 más 12 siempre. No puede hacer otra cosa. 34 más 12. 00:21:35
pero que ocurre 00:21:56
si yo quiero que este primer operador 00:21:57
a veces sea una cosa 00:22:01
y a veces sea otra 00:22:03
pues esa es la clave de la programación 00:22:04
yo en lugar de darle el 34 00:22:06
exactamente 00:22:09
le doy el nombre de la variable 00:22:09
y esta variable 00:22:12
en cada ejecución que tenga lo que quiera 00:22:15
aquí lo que pasa es que en esta ejecución 00:22:17
como todavía no sé leer 00:22:19
por teclado, le he puesto el 34 00:22:20
siempre, pero normal será 00:22:23
que esta sentencia 00:22:25
lea el valor del exterior 00:22:27
rápidamente incorporaremos como 00:22:29
para poder hacer un programa que trabaje con 00:22:31
diferentes valores en cada ejecución 00:22:33
entonces 00:22:35
la sentencia de arriba 00:22:36
es una ejecución que en función 00:22:38
de lo que tenga número uno 00:22:40
me hace una cosa o me hace otra, como tiene que ser 00:22:42
los programas 00:22:45
a datos distintos, cosas distintas 00:22:46
lógicamente 00:22:49
los datos que son los valores 00:22:51
de las variables 00:22:53
si los valores de las variables cambian 00:22:53
las operaciones cambian en consecuencia 00:22:56
¿vale? los programas 00:22:59
dependen de los valores 00:23:01
de las variables y hacen cosas diferentes para ellas 00:23:03
o sea, esta sentencia no tiene ningún 00:23:05
sentido, porque yo no voy a querer 00:23:07
siempre 34 más 12 00:23:09
no, voy a querer cada vez 00:23:10
lo que tenga número 1 00:23:13
más 12, ¿y qué tiene número 1? 00:23:15
no lo sé, cada ejecución tendrá una cosa, ni qué más me da 00:23:16
lo único que sé 00:23:18
es que yo quiero lo que tenga 00:23:20
número 1 más 12 00:23:23
en cada ejecución lo que sea 00:23:24
¿vale? entonces 00:23:26
lo natural, lógicamente, para que esto de 00:23:28
programar tenga algún sentido 00:23:30
es que las expresiones 00:23:32
involucren 00:23:35
dentro variables 00:23:36
para que esa expresión haga 00:23:38
unas cosas o haga otras 00:23:40
en función de mis datos de entrada 00:23:42
no siempre las mismas, lógicamente 00:23:44
un programa si te hace siempre lo mismo 00:23:46
con que lo hagas una vez, ya está 00:23:48
no tienes que ejecutarlo nunca más 00:23:50
la idea es que el programa 00:23:51
te haga cosas distintas 00:23:53
dependiendo de tus datos de entrada 00:23:56
si te autentica Pepito 00:23:57
te hace lo que sea para Pepito 00:23:59
si se autentica Juanito 00:24:01
hace lo que sea para Juanito 00:24:03
entonces el nombre Pepito Juanito 00:24:05
irá a una variable 00:24:07
y el programa hará lo que sea 00:24:08
dependiendo de lo que tenga la variable 00:24:10
por eso tiene sentido programar 00:24:12
porque yo te doy cosas 00:24:17
y tú haces lo que sea 00:24:19
para esas cosas 00:24:21
pues aquí igual yo te doy 00:24:22
valores para las variables 00:24:24
y tú haces lo que sea 00:24:26
para esos valores que yo te he dado 00:24:28
cada vez serán unos distintos 00:24:29
los que yo te doy aquí en cada ejecución 00:24:31
en cada ejecución te doy unos distintos 00:24:33
¿vale? luego 00:24:35
en las expresiones 00:24:37
siempre habrá variables 00:24:39
porque si no hay variables 00:24:41
esa operación siempre da 00:24:42
el mismo valor, luego la ejecuto 00:24:45
una vez y ya está, ese programa ya no 00:24:48
hace falta nunca jamás, con una ejecución 00:24:49
Ya tengo el valor, no hace falta nunca jamás ejecutarlo otra vez. 00:24:52
¿Vale? ¿Está claro esto? 00:24:57
Entonces, claro, eso sí. 00:25:08
Cuando yo meto variables en una expresión, como siempre, 00:25:12
esas variables tienen que ser compatibles en tipo, claro. 00:25:18
Con la operación que se está haciendo y con dónde se va a guardar, lógicamente. 00:25:25
si no el compilador ya me va a avisar 00:25:30
si yo a 12 00:25:32
le quiero sumar algo 00:25:35
ese algo 00:25:36
pues debería ser un número 00:25:38
debería ser un valor numérico 00:25:40
entonces debería ser una variable que tenga 00:25:42
un valor numérico 00:25:44
¿vale? 00:25:45
ahí no podría meter un boolean por ejemplo 00:25:48
aunque ese número todavía no lo hemos visto 00:25:50
no podría meter un boolean porque los boolean 00:25:52
no se suman y se restan 00:25:54
lo que se suman y se restan son los números 00:25:55
luego a los lados 00:25:58
de un operador 00:26:00
de suma o de resta 00:26:02
de multiplicación o de cociente 00:26:03
tienen que ir números 00:26:05
y lo que es más 00:26:06
eso es lo primero 00:26:09
que las variables que yo ponga 00:26:11
tienen que ser compatibles en tipo 00:26:13
con las operaciones que estoy haciendo 00:26:14
y lo que se suman son números 00:26:16
no otras cosas 00:26:19
eso por un lado 00:26:20
bueno, tú puedes poner aquí la variable que quieras 00:26:22
según lo que tú quieras hacer, claro 00:26:29
Claro, tú la expresión 00:26:30
Haces lo que quieras 00:26:41
Involucrando las variables que quieras 00:26:42
Claro 00:26:44
Esta sería otra expresión 00:26:45
Para conseguir 00:26:48
Otra cosa, depende de lo que tú quieras 00:26:50
Que haga tu programa 00:26:52
Pues haces una cosa u otra 00:26:53
Y esa expresión puede involucrar 00:26:55
Una variable, dos, tres, todas 00:26:58
las que hagan falta, siempre y cuando sea 00:26:59
una expresión correctamente escrita 00:27:02
esta expresión también está correctamente 00:27:04
escrita, número 1 más 00:27:06
número 3, porque es 00:27:08
el operador más que existe 00:27:10
a un operador 00:27:11
a un lado y otro operador a otro 00:27:14
el más necesita un operador a la derecha y otro a la izquierda 00:27:15
y además 00:27:17
lo que está a los lados son valores 00:27:19
numéricos, porque lo que se suma 00:27:21
son valores numéricos 00:27:24
muy bien, pues es correcto 00:27:25
entonces la parte 1 00:27:27
satisfecha 00:27:29
pero no solo 00:27:31
para que el compilador se quede tranquilo 00:27:33
y te compile eso ya y se ejecute 00:27:35
una vez que la expresión 00:27:37
sintácticamente es válida 00:27:40
el compilador verifica 00:27:42
que el valor resultante 00:27:45
también es compatible 00:27:47
con el tipo al que vas 00:27:49
en este caso no hay duda 00:27:50
número uno es un int 00:27:53
número tres 00:27:55
imaginaos que es un int que está por ahí declarado 00:27:56
Número 3 es un IN. La suma es un IN. Puede ir a un IN. Vale. No hay duda. 00:27:59
Pero, ¿qué pasaría si la batería se... 00:28:07
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:
22 de septiembre de 2025 - 17:17
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
28′ 18″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
551.78 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid