Saltar navegación

20240919 ProgrEstruct-Variables_4 - 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 19 de septiembre de 2024 por Raquel G.

17 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues entonces ya habíamos dicho 00:00:00
Variables de tipo entero 00:00:03
Las primeras con las que estábamos 00:00:05
Estas cuatro 00:00:07
Estas cuatro opciones 00:00:09
De nuevo 00:00:11
Recordamos la diferencia entre ellas 00:00:13
El espacio que usan para almacenar 00:00:15
Que con la voz de fondo 00:00:18
Me distraigo 00:00:19
¿Vale? Estas cuatro opciones 00:00:20
Que de nuevo ya sabemos la diferencia 00:00:23
Entre ellas, el tamaño que usan para almacenar 00:00:25
El número, ¿vale? 00:00:27
Entonces, asignación, sentencia de asignación 00:00:28
Ya sabemos que es nombre de variable 00:00:32
Operador de asignación 00:00:34
Valor que le damos a la variable 00:00:36
¿Vale? 00:00:38
Entonces esto ya sabemos que lo podemos hacer en cualquier momento 00:00:39
Si hacemos 00:00:42
Uy, ¿dónde me he ido? 00:00:45
Si hacemos esto, esta variable se queda sobrescrita 00:00:51
Tenía nueve cuando la inicializamos 00:00:54
Porque recordad que se puede 00:00:57
Asignar un valor a la vez que la declaramos 00:00:58
Tenía nueve, pero se queda sobrescrita 00:01:03
¿Vale? Y así vamos asignando valores 00:01:06
A las variables 00:01:07
¿Vale? Entonces 00:01:09
Nosotros ahora estamos asignando 00:01:11
Valores a variables 00:01:14
Directamente en el código 00:01:15
Directamente en el código 00:01:17
Claro, no es la situación habitual 00:01:19
Porque normalmente un programa 00:01:22
Trabaja con qué? Con lo que se llaman 00:01:23
Datos de entrada 00:01:25
Y los datos de entrada se dan en el momento 00:01:26
En el que el programa se ejecuta 00:01:29
El programa se ejecuta y en el momento de la ejecución lo natural es que pida unos datos para rellenar las variables. 00:01:31
Entonces en una ejecución pedirá unos datos y para una ejecución recibirá esos datos y trabajará con ellos. 00:01:39
Para la siguiente ejecución, tres días después, vuelve a pedir los datos, recibe los datos y trabaja con ellos. 00:01:46
Entonces lo normal es que las variables lógicamente se rellenen con datos de entrada que se piden en el momento de la ejecución. 00:01:53
porque si no el programa no tendría mayor interés 00:02:00
el programa sirve para trabajar con datos 00:02:03
que el usuario que ejecuta ese programa le dé 00:02:06
programa para calcular el factorial de un número 00:02:09
pues el programa para calcular el factorial de un número 00:02:13
tiene interés si yo le puedo dar 00:02:16
un número diferente en cada ejecución, lógicamente 00:02:19
si no, no tendría ningún interés ese programa 00:02:21
entonces en ese programa para calcular el factorial de un número 00:02:23
pues yo declararé una variable 00:02:28
para ese numerito con el que tengo que trabajar 00:02:29
y esa variable no le asignaré el valor por código, lógicamente 00:02:32
sino que tendré que poner aquí alguna sentencia 00:02:36
que se corresponda con leer valor del teclado 00:02:40
y será una sentencia de asignación igualmente 00:02:45
entonces lo que quiero decir es que cuando asignamos valor a una variable 00:02:50
el valor que ponemos a la derecha 00:02:54
y siempre a la derecha, recordad que ahí no hay alternativa, nombre de variable a la izquierda, operador de asignación, nombre de variable, perdón, valor a la derecha, pues el valor que demos aquí, se lo podemos poner a capón como hemos hecho aquí, pero bueno, eso nos interesará alguna vez porque estemos haciendo algo concreto, pero en la mayoría de los casos, los valores que damos a variables, los tenemos que asignar de otro sitio, y entonces aquí, ¿qué tocará poner?, 00:02:57
Tocará poner una sentencia que lee del teclado, nada más. 00:03:25
Y esta sentencia que lee del teclado es la que tomará un valor, 00:03:29
tomará el valor, y ese valor, 00:03:32
ese valor que se ha tomado leyendo el teclado va aquí. 00:03:35
¿Vale? 00:03:39
Luego las sentencias de lectura de teclado, de consola, 00:03:39
las tenéis que ver como si fueran sentencias de asignación 00:03:44
porque lo son, son sentencias de asignación. 00:03:46
Asigno un valor. 00:03:49
¿Qué valor? 00:03:50
El que está leyendo esto del teclado, el que está leyendo, 00:03:51
Ese valor que está leyendo 00:03:54
Se asigna a esta variable 00:03:57
Pero ahora mismo, como estamos solamente viendo 00:03:58
Las diferencias entre matices 00:04:01
De diferentes tipos y de asignaciones 00:04:03
Pues todavía no ponemos la sentencia 00:04:05
De lectura del teclado 00:04:07
Cuando ya queramos hacer 00:04:08
Algún ejemplo de programa que ya hace 00:04:11
Algo interesante, pues para que ese programa 00:04:13
Haga algo interesante 00:04:15
Tenemos que meter esa sentencia 00:04:16
Para poder leer el dato, si no el programa 00:04:18
No nos sirve para nada 00:04:20
Bueno, pues seguimos con 00:04:22
Pequeñas cuestiones 00:04:24
Y asuntos de variables enteras 00:04:27
Vale, la variable int 00:04:28
Pues no tiene mayor historia 00:04:30
Aquí, pequeñas cositas 00:04:31
Que esto sí que entiendo que a lo mejor a uno 00:04:34
Se le puede ir olvidando con el tiempo 00:04:36
Pero no es tan crítico 00:04:38
Porque como normalmente uno usa siempre variables int 00:04:39
Pues no suele ser el problema 00:04:43
Vale, ¿cuál es la diferencia entre la variable int 00:04:44
Y la variable long? 00:04:47
¿La recordáis, verdad? 00:04:49
guarda mucho más, mucho más 00:04:52
tamaño de memoria. 00:04:54
Exacto, vale. Entonces 00:04:56
yo aquí en número 3 puedo poner un 00:04:58
número muy largote, ¿vale? 00:05:00
Puedo poner un número muy largote. 00:05:02
Pero claro, 00:05:04
yo he puesto un número muy 00:05:06
largote. ¿Veis este 00:05:07
número? Si hiciéramos el cálculo 00:05:10
de lo que cabe en ir, que lo haríamos 00:05:12
elevando 2 a la 31, 00:05:13
pues 00:05:17
este número es mayor. 00:05:17
Pero sin embargo es menor, 00:05:20
bueno, lo he hecho un poco a voleo 00:05:21
mi intención era que fuera menor 00:05:23
a 2 elevado a 64 00:05:26
con lo cual según la teoría 00:05:27
que yo os he dicho 00:05:29
este número debería caber en una variable long 00:05:30
y sin embargo 00:05:34
el compilador está fallando 00:05:35
entonces el entorno de desarrollo 00:05:38
nos facilita la tarea 00:05:40
de ver errores de compilación 00:05:42
porque como os dije el martes 00:05:43
el entorno de desarrollo tal cual 00:05:46
voy escribiendo, él ya va compilando solo 00:05:48
Es como si estuviera llamando al javacé todo el rato 00:05:50
Entonces 00:05:52
Al llamar al javacé todo el rato 00:05:54
Él va viendo si hay algún error 00:05:56
De compilación en lo que yo escribo 00:05:58
Recordad 00:06:00
Errores de compilación son errores 00:06:02
De sintaxis 00:06:04
O de alguna incoherencia 00:06:05
Aquí no hay un error de sintaxis 00:06:07
Long existe 00:06:09
Esto es un identificador de variable válido 00:06:11
Y esto es un numerito con caracteres válido 00:06:14
Este no es error de sintaxis 00:06:16
Pero es un error de coherencia 00:06:17
¿Vale? Entonces, los errores de compilación 00:06:19
El entorno de desarrollo 00:06:22
Eclipse 00:06:24
Como él ya va haciendo Java hace todo el rato 00:06:24
Si encuentra que hay en alguna línea 00:06:27
Me la 00:06:30
Subraya en rojo 00:06:30
Me la subraya en rojo y me dice 00:06:33
Cuidado que aquí hay un error de compilación 00:06:35
¿Vale? 00:06:37
Aquí, primer aviso 00:06:39
Porque es una situación 00:06:40
Con la que hay que contar siempre 00:06:43
El eclipse está claro 00:06:45
Que si te marca en rojo 00:06:47
hay un error de compilación, sí o sí, pero 00:06:48
ahora mismo el programa es muy sencillo, entonces lo más seguro 00:06:52
es que haya acertado, pero muchas veces 00:06:56
te marca un error de compilación en una línea que no está 00:06:59
pero lo que ocurre es que esta línea al ponerla 00:07:01
tú aquí, pues automáticamente el programa se ha 00:07:05
hecho inconsistente respecto a algo que habías puesto 00:07:08
arriba, entonces primer aviso que voy diciendo 00:07:11
y que iréis comprobando, el entorno de desarrollo no sabe 00:07:14
nada, no tiene ni idea, tiene unas cuantas 00:07:17
reglas estúpidas que sigue 00:07:19
y alguna ayuda nos da 00:07:21
entonces como nosotros somos 00:07:23
los que conocemos y sabemos 00:07:25
decidimos interpretar 00:07:26
esa ayuda que él nos ha dado, la interpretamos 00:07:29
con nuestro conocimiento 00:07:31
y decimos, ah sí, sí, es verdad 00:07:32
aquí hay algo raro, no por lo que él me dice 00:07:34
porque me estoy dando una tontería, pero es verdad que hay algo raro 00:07:36
entonces ayuda nos da, por supuesto 00:07:38
desde luego en este 00:07:40
primer orden de compilación, porque si no lo hubiera 00:07:42
aquí no habría una línea rosa 00:07:44
Pero que ese error de compilación sea en esta línea 00:07:46
No tiene por qué 00:07:49
Puede ser en otra 00:07:50
¿Vale? 00:07:51
Por ejemplo 00:07:53
Aquí esta ya no me da error de compilación 00:07:54
Porque 00:08:03
Pero imaginaos que quito esto 00:08:03
¿Vale? 00:08:06
Entonces por ejemplo 00:08:09
Este es un ejemplo un poco tonto 00:08:10
Aquí me saca error de compilación en el entorno de desarrollo 00:08:11
Yo hago esta sentencia de asignación 00:08:15
¿Vale? 00:08:17
¿Por qué creéis que me saca ese error de compilación? 00:08:18
Me dice, este pago no compila 00:08:22
Porque no has declarado qué tipo de variable es 00:08:23
Claro, porque cualquier variable 00:08:25
Antes de usarla en Java 00:08:27
Sabemos que tiene que estar declarada 00:08:29
Entonces, aunque es un ejemplo 00:08:31
Un poco así cogido por los pelos 00:08:34
¿Eso significa que el error de compilación 00:08:35
Estrictamente esté en esta línea 00:08:37
Y que la modificación la tenga que hacer yo en esta línea? 00:08:39
No, a lo mejor 00:08:42
Mi error de compilación está 00:08:43
Porque yo esta variable número 3 00:08:45
si la he declarado 00:08:47
pero la he declarado así 00:08:48
¿vale? 00:08:51
porque me he equivocado, yo quería poner 00:08:53
int y he puesto char, me he equivocado 00:08:55
y él me saca aquí una red de compilación 00:08:57
y me dice, uy, cuidado 00:08:59
ahora vemos como te saca la información 00:09:01
me dice, esto 00:09:03
lo siento, no compila 00:09:05
entonces aquí es fácil, porque la línea está justo arriba 00:09:06
uno lo ve, pero uno se obceca 00:09:09
se obsesiona y dice, tengo que cambiar algo en esta línea 00:09:11
y cambias cualquier 00:09:13
cosa, cualquier tontería 00:09:15
para que te la compile, por ejemplo 00:09:16
uno podría decir, vale, vale 00:09:19
como tengo que cambiar algo en esta línea 00:09:21
porque esta línea da un error, tengo que cambiar algo 00:09:23
venga, voy a cambiar esto 00:09:25
vale, claro, y ya empieza 00:09:27
con el, ya empieza, vale, pongo in 00:09:31
la declaro, ya empieza con otro problema 00:09:33
no, es que ya está declarada arriba 00:09:35
entonces, este error 00:09:36
de aquí, podría ser en este caso 00:09:39
no porque esta línea esté mal, esta línea no está mal 00:09:41
sino porque nos hemos equivocado 00:09:43
aquí arriba en su momento, ¿vale? 00:09:45
Entonces, aunque este es un ejemplo sencillo, 00:09:47
porque tampoco tenemos herramientas 00:09:50
para poner ejemplos más complicados, 00:09:52
lo que quiero deciros es que 00:09:54
el entorno de desarrollo, 00:09:55
la ayuda que te va a dar, 00:09:57
es una ayuda muy estúpida. 00:09:58
Entonces, uno tiene que usarla, 00:10:00
tomarla, interpretarla como punto de partida 00:10:03
para ahora ya decidir 00:10:05
qué falla en su programa. 00:10:07
Bueno, pues entonces, 00:10:10
nosotros estábamos declarando ahora 00:10:12
una variable long y nos había pasado eso 00:10:15
nos había pasado que nos 00:10:17
daba un error de compilación 00:10:19
cuando yo había puesto 00:10:20
ahí 00:10:23
¿vale? 00:10:25
me daba un error de compilación 00:10:27
entonces allá iba 00:10:28
no es que aquí haya un problema 00:10:29
repito, el escribir 00:10:33
esto ha generado 00:10:35
un problema en mi programa 00:10:37
lo ha hecho inconsistente 00:10:39
sintácticamente 00:10:40
lo ha hecho que no se pueda compilar 00:10:42
¿Vale? No se puede compilar este programa 00:10:44
Vale, entonces 00:10:46
Cuando 00:10:48
Nosotros compilamos con Java C 00:10:50
Que lo hicimos el otro día 00:10:52
Cuando compilamos con Java C y hay un error 00:10:53
A los que os salió un error 00:10:56
Pues abajo veíais que os salía una línea 00:10:57
Error, sin das, bla, bla, bla 00:11:00
Y luego ponía un mensajito abajo en inglés 00:11:01
¿Vale? Todo eso es lo que 00:11:04
Está en la documentación de Oracle 00:11:05
Bueno, pues ese mismo mensajito en inglés 00:11:07
Que es la 00:11:10
Que es la ayuda de partida que tenemos 00:11:11
para saber por dónde van los tiros, si es que no sabemos 00:11:14
por qué, porque a lo mejor uno 00:11:16
en cuanto ve error de compilación se da cuenta y dice 00:11:18
ah, es por esto, y lo cambia 00:11:20
pero si no es error de compilación y no tenemos ni idea 00:11:21
de por qué, pues tratamos 00:11:24
de buscar esa ayuda que me 00:11:26
da el javacé cuando yo compilo y me dice bla bla 00:11:28
bla, esa ayuda 00:11:30
de por qué él ha 00:11:31
interpretado que eso está mal 00:11:33
os la da si aquí en la 00:11:35
crucecita 00:11:37
roja esta 00:11:38
dejáis la mano puesta, ¿vale? 00:11:41
sin pinchar 00:11:44
entonces si ahí en la crucecita esa 00:11:45
dejáis la mano puesta sin pinchar en ella 00:11:48
os dice 00:11:50
lo que dice el javase cuando uno 00:11:52
compila en la consola 00:11:54
y alguna información es 00:11:55
a veces tiene sentido, a veces no tiene 00:11:58
absolutamente ninguno, depende 00:12:00
porque una línea 00:12:02
él ve las líneas como cosas 00:12:03
separadas unas de otras y no 00:12:06
las líneas tienen que ver unas con otras 00:12:08
es nuestro código 00:12:10
Entonces los errores a veces no son por esa línea 00:12:11
Repito, como he dicho antes 00:12:14
Sino porque esa línea estando bien 00:12:15
Es incompatible con la de arriba 00:12:17
Y de eso él no se va a dar cuenta 00:12:18
De eso es de lo que él no se da cuenta 00:12:20
Él mira la línea tal cual 00:12:22
Y no mira si es compatible con la de arriba o la de abajo 00:12:24
Bueno, vamos a ver en este caso concreto 00:12:26
Que nos está diciendo 00:12:29
Por qué el jabacé ha fallado 00:12:31
Nos dice 00:12:33
Porque el número pum pum pum 00:12:34
Que es de tipo entero 00:12:36
Está fuera de rango 00:12:39
Vale, pues 00:12:41
Esto nos suena raro, fuera de rango 00:12:43
De tipo entero, si yo lo he declarado en variable long 00:12:45
Pero bueno 00:12:47
Esta pista no está demasiado desacertada 00:12:49
Al menos, no está demasiado desacertada 00:12:52
Vale, pues entonces 00:12:53
¿Qué es lo que ha pasado? 00:12:56
Que para Java 00:13:00
Y esto sí, acordémonos 00:13:01
Cuando escribimos un numerito sin más 00:13:02
Un número cualquiera 00:13:05
Para operar, por ejemplo 00:13:07
Yo puedo estar haciendo aquí una suma 00:13:09
vale, aquí estoy sumando 00:13:11
este con menos 34 00:13:15
menos 33, bueno, cuando escribimos un número 00:13:17
sea positivo o negativo 00:13:19
sin decimales 00:13:22
sin coma y sin decimales, cuando escribimos 00:13:23
un número entero así directamente 00:13:25
Java tiene que almacenarlo de alguna 00:13:27
manera, en alguna variable 00:13:29
interna suya, para luego en esa variable 00:13:31
moverla y asignarla aquí 00:13:33
eso a nosotros no nos importa, a nosotros 00:13:35
físicamente lo que sabemos es que existe 00:13:37
una variable número 3 ahí 00:13:39
existe una variable 00:13:41
y que este numerito se va a mover a esa variable, ¿vale? 00:13:43
Pero Java hace cosas para que eso pase, 00:13:47
para que ese movimiento ocurra. 00:13:49
Bueno, pues, ¿qué hace con ese, 00:13:51
con cualquier numerito que uno escriba? 00:13:52
Con este, con el menos 33, 00:13:55
con este en particular que estábamos ahí. 00:13:57
¿Este ya se va? No, este. 00:14:00
Vale, ¿qué hace con ese numerito? 00:14:02
Pues, se habilita un espacio, 00:14:04
pero espacio de 32 bits, un espacio entero. 00:14:06
Se habilita un espacio para guardar ese numerito 00:14:10
que yo he escrito, y ahora ya 00:14:12
lo coge y lo asigna a la variable 00:14:14
long. Por eso me estaba 00:14:16
diciendo, oye, este numerito 00:14:18
es demasiado grande para caber en un int. 00:14:20
Pero no se refiere para caber en este 00:14:22
int, porque esto no es un int, esto es un long. 00:14:24
Se refiere para caber en el 00:14:26
int temporal que él se ha 00:14:28
creado para guardar ese número. 00:14:30
Entonces, 00:14:33
diríais, pues qué estupidez, yo no 00:14:34
puedo escribir un numerito, no puedo asignar 00:14:36
un valor a long, es imposible, 00:14:37
porque en cuanto escriba un número 00:14:40
él como lo tiene que guardar en un espacio 00:14:41
intermedio para luego asignarlo 00:14:43
ahí, no le va a caber nunca 00:14:46
si puedo, pero entonces se lo tengo 00:14:48
que decir, y se lo digo 00:14:50
poniéndole una L 00:14:51
¿vale? 00:14:52
solo la interpreta 00:14:54
como entonces, si yo le pongo una L 00:14:58
lo que le estoy diciendo es, este numerito 00:14:59
guárdamelo en 64 00:15:02
bits, y luego ya 00:15:04
se lo asignas, con lo cual ya 00:15:06
le cabe, y dice, ah, estupendo 00:15:08
como te lo voy a guardar 00:15:09
en 64 bits, ya me cabe 00:15:11
¿vale? pero si no le ponemos 00:15:13
la L, entonces cuando trabajéis con 00:15:15
números grandes, que tengáis 00:15:17
que escribirlos directamente 00:15:19
¿esto es una particularidad del Eclipse? 00:15:20
no, no, no, todo esto que hablo es de Java 00:15:23
todo esto es Java, todo 00:15:25
claro, sí, entonces, todo lo que escribimos 00:15:26
en el editor de texto, es código 00:15:29
Java, no tiene que ver con el Eclipse, da igual que fuera 00:15:31
un blog de notas, que fuera 00:15:33
las particularidades del Eclipse son 00:15:34
los botoncitos, las ayudas 00:15:36
Si no le pones la L no te compila 00:15:39
No, no, no, si tú pasas esto sin la L 00:15:40
A Java C no te compila y te sale el error 00:15:42
Que te dice ahí 00:15:44
¿Vale? 00:15:47
Entonces todo lo que escribamos en el editor de texto 00:15:49
Da igual 00:15:51
Que lo tengas en Eclipse, en Intel y en un bloc de notas 00:15:52
Para compilarlo 00:15:55
Como es justo lo que pasa por una variable 00:15:56
Intermedia 00:15:59
Sí, pero eso lo hace la máquina virtual cuando está ejecutando 00:16:00
Claro, cuando está en la ejecución 00:16:03
¿Vale? Entonces el problema 00:16:05
Entonces el compilador 00:16:06
como él, el compilador 00:16:08
lo que dice es, este numerito 00:16:10
yo sé que la máquina virtual 00:16:13
cuando ejecute esto 00:16:14
va a guardarlo primero en 32 bits 00:16:16
para luego asignárselo a la variable 00:16:19
que yo le diga, entonces sus reglas 00:16:21
el compilador es una persona 00:16:23
que tiene reglas, y las va 00:16:24
una por una mirando, esto cabe, esto no 00:16:26
esto no sé qué, y te avisa, y ya está 00:16:29
y ese es Java C 00:16:31
y me da igual llamar a Java C desde Eclipse 00:16:32
desde cualquier otro entorno de desarrollo 00:16:35
¿vale? 00:16:36
Entonces, si alguna vez uno tiene que meter un número muy grande, pues tiene que poner la L después, porque si no, no, ¿vale? 00:16:38
Bueno, y llegaría un momento, si yo sigo poniendo aquí unos, que ya me tendría que poner en rojo, porque aquí, ya está. 00:16:50
Este número 00:17:01
Este, por ejemplo 00:17:04
Este número ya, ni en log 00:17:07
Este número, pues no podemos 00:17:09
Usarlo en programación, en ninguna variable 00:17:12
No, si tú necesitas 00:17:13
Usar un número tan grande, pues entonces 00:17:16
Te tendrás que administrar 00:17:18
Tus propias, o 00:17:20
Dividirlo en dos partes y ponerlo en dos variables 00:17:21
Lo que sea, ¿vale? 00:17:24
Pero claro, o sea, estamos hablando 00:17:26
En qué programa 00:17:27
Habitual, en qué aplicación 00:17:30
Tendría que ser una aplicación 00:17:32
Específica, científica 00:17:35
Vete a saber que tendrá sus propios lenguajes 00:17:36
¿Vale? 00:17:38
Pero aquí 00:17:40
Las variables log llegan hasta donde llegan 00:17:40
¿Y hasta donde llegan? 00:17:44
Pues por curiosidad solo vamos a ponerlo 00:17:48
Por ejemplo 00:17:51
Vamos a mostrar, recordad 00:17:52
Que esta era la 00:17:54
La sentencia 00:17:56
De mostrar por consola 00:17:59
Entonces la usamos 00:18:01
desde ya, aunque todavía esto de los puntos se nos hace raro 00:18:03
porque no entendemos qué significan estas tres palabras tan raras 00:18:07
bueno, tenemos que usarla desde ya, entonces ya lo entenderemos un poco más adelante 00:18:10
ahora mismo, basta con que sepamos que esto muestra por consola 00:18:14
lo que yo le pase ahí, vale 00:18:19
bueno, hasta ahora hemos mostrado por consola 00:18:21
la única vez que la hemos usado como ejemplo, hemos mostrado por consola 00:18:28
cadenas, ¿verdad? 00:18:32
cadenas entrecomilladas, ¿no? 00:18:35
entonces, si yo pongo una cadena 00:18:39
entrecomillada, esto me lo muestra por 00:18:40
consola, vale 00:18:42
entonces, si ejecutamos 00:18:44
este programa, este programa 00:18:46
habrá hecho esto de aquí arriba, que no 00:18:48
es nada, declarar una variable, darle el 8 00:18:50
declarar esta, darle el 9 00:18:52
esta no darle nada, y ahora número 3 00:18:54
darle este, habrá hecho todo eso, aunque 00:18:56
nosotros no tenemos conciencia 00:18:58
de ello, pues no lo vemos, pero lo habrá hecho 00:19:00
luego mostrará el 1, ¿verdad? 00:19:02
Pues venga, si hacemos eso, efectivamente el programa lo ha hecho. 00:19:04
¿Cómo vas a ejecutar? 00:19:11
Vale, entonces, para ejecutar, vosotros como sois, bueno, yo hablo en general, 00:19:12
algunos sois más jovencitos, otros menos, algunos habéis pasado la vida con el móvil, otros no. 00:19:18
Entonces, yo hablo en general, perdonadme, que os trata a todos como si fueran niños pequeños 00:19:24
que están con el móvil todo el día, pero bueno. 00:19:28
Bueno, entonces como vosotros 00:19:29
Generalizando, disculpadme, sois de la generación 00:19:34
De o doy algo 00:19:37
Y ya está, pues tendéis 00:19:38
Con naturales, tendéis 00:19:40
Por las buenas, ah, que hay un botón de run 00:19:42
Pues lo uso 00:19:44
Vale, eso está bien 00:19:46
Si solo tengo abierto 00:19:49
Un código 00:19:50
Ejecutable, si solo tengo abierto uno 00:19:53
Pero si tengo abierto muchos 00:19:54
Pues no, por ejemplo, si dais 00:19:57
en la flechita desplegable 00:19:58
que está a la derecha del botón 00:20:01
sale 00:20:03
en mi caso salen estos 00:20:04
que son los últimos que yo he ido ejecutando 00:20:06
entonces, si yo 00:20:08
le doy a este botón 00:20:11
me marca 00:20:11
me ejecuta el que esté el primero de la lista 00:20:14
que se corresponde 00:20:17
con el último ejecutado 00:20:19
pero si yo tengo una aplicación que tengo 00:20:20
varios main, o sea, varios 00:20:22
ejecutables y quiero 00:20:24
y por ejemplo, yo ahora voy a abrir 00:20:26
en mi editor de texto, voy a abrir 00:20:28
pues es que 00:20:30
estaba en otro entorno de desarrollo, pero bueno, en otro 00:20:31
workspace, entonces no lo puedo abrir desde ahí 00:20:34
imaginaos que 00:20:36
este mismo código Java 00:20:38
que es otra clase Java más 00:20:41
la tengo aquí metida también 00:20:42
la tengo aquí metida, entonces yo la abro 00:20:44
y la pongo en el editor de texto 00:20:46
la abro porque la cambio 00:20:47
y ahora ya, pum, le dais a este botón 00:20:49
y decís, pero si he hecho un cambio 00:20:53
y no me funciona, claro 00:20:55
recuerda, este botón te está ejecutando 00:20:56
la última que has ejecutado 00:20:58
no la que tienes aquí abierta 00:21:00
no esa, ¿vale? 00:21:02
no te ejecuta el código que tienes aquí abierto 00:21:04
yo puedo tener aquí abiertos un montón de clases 00:21:06
distintas, todas ellas con 00:21:08
su main para ejecutar, puedo tener 00:21:10
muchas, y el botoncito no me 00:21:12
ejecuta la que tenga abierta 00:21:14
entonces a veces uno hace cambios en la que tiene abierta 00:21:15
le da al botón de ejecutar 00:21:18
y hace otra cosa, y os volvéis 00:21:19
locos, no, el botón ejecuta 00:21:22
La que está en la primera de la lista, que es la última que ejecutaste, ¿vale? 00:21:24
Entonces, bueno, pues, si uno lo tiene claro, que está ejecutando la última que ejecutó, 00:21:29
pues, le da al botón run y ya está. 00:21:34
La forma más segura, ante la duda, pues, siempre podéis dar, 00:21:36
si estáis en la clase que vais a ejecutar, la que tiene aquí vuestro main famoso, 00:21:41
pues, botón derecho, runas, Java aplicación, ¿está? 00:21:46
pues en la ventana 00:21:53
en el editor de texto donde está el código 00:21:55
que queréis ejecutar, para asegurarse 00:21:57
sí o sí que es ese 00:21:59
el que va a ejecutar, botón derecho 00:22:01
en el desplegable el runas 00:22:04
y java aplicación 00:22:06
que sale ahí, ¿vale? 00:22:07
Entonces con ese ejecutáis ese sí o sí 00:22:09
no hay tutía, ¿vale? 00:22:12
Este desplegable 00:22:14
lo podéis abrir tanto en el editor de texto como aquí 00:22:15
en la ventana de proyectos 00:22:18
aquí en esa misma clase que queréis ejecutar 00:22:20
Pincháis y lo mismo, botón derecho 00:22:22
Se os abre lo mismo, ¿vale? 00:22:23
Vale, y esa parte tuya, ¿qué pone? 00:22:30
Vale, y 00:22:35
¿El nombre de tu fichero? 00:22:36
¿Cómo se llama? 00:22:38
¿El nombre es el mismo seguro? 00:22:41
¿Y tienes lo de package arriba o lo has quitado? 00:22:44
¿Y está metido en un package? 00:22:48
A ver, lee la información de compilación 00:22:55
Lee la información de compilación 00:22:57
cuando pones la manita ahí a la izquierda 00:22:59
¿qué te dice? 00:23:01
cuando tienes un error de compilación 00:23:03
acabamos de decir que 00:23:05
tú pones aquí la mano y te dice algo 00:23:09
pues ¿qué te dice a ti? 00:23:11
¿cómo no te va a decir nada? 00:23:14
ah, pero no es que lo subrayen 00:23:24
pues ya se ha abierto el 00:23:26
otra herramienta 00:23:27
no has abierto una 00:23:30
en el coverage 00:23:31
tú cuando has hecho el runas 00:23:32
en realidad has hecho de arriba 00:23:35
claro, pero antes de haber 00:23:37
en algún momento le has dado a ese 00:23:40
y esto te abre otra herramienta 00:23:41
que es para hacer 00:23:44
entonces esto 00:23:45
a ver si 00:23:48
esto 00:23:49
a ver 00:23:52
pero 00:23:53
para que te hagas 00:23:55
Gracias. 00:23:57
Vale, seguimos 00:24:29
Bueno, pues estábamos 00:24:52
El System.out este que estamos usando 00:24:54
Para mostrar por consola 00:24:56
también nos sirve 00:24:57
a ver, esto 00:25:00
tiene que estar si hemos organizado 00:25:08
nuestras clases en paquetitos 00:25:11
de estos, os acordáis que ayer os dije 00:25:13
las clases van dentro de SRC 00:25:15
pero pueden ir a Capone 00:25:17
yo puedo hacer aquí un new 00:25:19
cuando digo clase, digo ahora mismo clase y programa 00:25:20
asumid que estoy diciendo lo mismo 00:25:23
pueden ir a Capone directamente new class 00:25:24
podrían, o ahora para 00:25:26
de cara a organizarnos, vamos a 00:25:28
hacer una subcarpeta 00:25:30
que para Java es paquete, una subcarpeta 00:25:32
y la metemos en subcarpetas, entonces 00:25:34
si tú tienes clases en esas subcarpetas 00:25:36
esto es obligatorio 00:25:39
y este nombre tiene que ser 00:25:40
el nombre de la subcarpeta, de hecho es que te lo 00:25:42
van a poner solo 00:25:44
te lo van a poner solo, ahora mismo es que 00:25:45
no sabemos 00:25:48
no podemos todavía explicar los detalles 00:25:49
de lo que significa, pero 00:25:53
para que no os sueneis diciendo cosas raras 00:25:54
Una aplicación de Java 00:25:56
Solamente a modo de que entendáis 00:25:58
Un poquito por encima 00:26:00
Una aplicación de Java 00:26:01
Son un montón de ficheros de estos 00:26:03
Que son lo que en Java 00:26:06
Y en cualquier lenguaje de programación 00:26:08
Se llaman clases 00:26:09
Esto que hemos hecho es una clase 00:26:11
De hecho empieza con la palabra class 00:26:13
Una aplicación no es solo 00:26:15
Uno de estos 00:26:18
Son muchos 00:26:20
Que entre sí coexisten 00:26:21
Entre sí trabajan y cooperan 00:26:23
Como ya veremos 00:26:25
entonces como una aplicación son muchos 00:26:26
una aplicación normal y corriente a lo mejor 00:26:28
¿qué tiene? ¿750? 00:26:30
pues sí, 750 00:26:32
ficheros de estos, si los tengo 00:26:34
todos juntos en la misma 00:26:36
carpeta, para la máquina virtual 00:26:38
de Java a la hora de localizarlos 00:26:40
cuando unos se llamen a otros es más 00:26:42
complicado, ya entenderemos por qué es más complicado 00:26:44
entonces para la máquina virtual de Java 00:26:46
es más fácil cuando 00:26:48
una clase llame a otra encontrar 00:26:50
a la hora de ejecutar si está organizada 00:26:52
en carpetas y subcarpetas. 00:26:54
Bueno, pues los paquetes, 00:26:56
lo que yo estoy llamando paquetes, 00:26:58
que se llama así paquetes, 00:26:59
son esas subcarpetas, nada más. 00:27:01
Entonces, ahora mismo vamos a usarlas 00:27:04
desde ya esas subcarpetas 00:27:07
porque desde Eclipse es muy sencillo. 00:27:09
Se trata de en SRC, 00:27:11
que es donde están nuestras clases, 00:27:13
hacer new package y ya tengo una subcarpeta. 00:27:15
Y ya ahí meto las clases que yo quiera. 00:27:17
¿Vale? Entonces 00:27:20
Cuando trabajamos con esas subcarpetas 00:27:22
Lo que ocurre es que entonces 00:27:24
Es imprescindible que esta línea esté arriba 00:27:26
Para indicar, ojo 00:27:28
Que esta clase está en esta subcarpeta 00:27:30
Es una información, y está en la máquina virtual, etc. 00:27:32
¿Vale? 00:27:34
Pero como la pone el solo ahora mismo 00:27:36
Pues podemos olvidarnos un poco 00:27:37
Claro, porque 00:27:39
Porque esto es public, porque esto es static 00:27:43
Porque esto es void, porque esto es main 00:27:45
Y porque esto es esto, pues ahí no podemos entenderlo 00:27:47
nos falta información, lo único que 00:27:49
lo que pasa es que 00:27:51
si queremos hacer un programa en Java que la máquina 00:27:53
virtual ejecute, tiene que estar metido 00:27:55
en unas llaves 00:27:58
que tengan eso ahí escrito 00:27:59
no hay tutía, tienen que estar metido ahí 00:28:01
no hay ninguna otra alternativa ni posibilidad 00:28:03
¿vale? y otra cosa 00:28:05
por si a alguien le sale algún error, alguna cosa rara 00:28:08
recordad que ayer ya 00:28:10
cuando hicimos una clase con New Class 00:28:11
él te ponía automáticamente 00:28:13
esto, te ponía 00:28:16
esta línea también, pero ponía 00:28:17
el public delante. 00:28:19
¿Acordáis? La ponía yo. 00:28:22
Dije, ahora mismo me da igual que lo dejéis o que lo quitéis. 00:28:24
No afecta para nada. 00:28:26
Y luego también, si marcábamos la pestañita, ponía esto. 00:28:27
Entonces, os digo ahora, 00:28:30
por si a alguien le sale un error de compilación y se vuelve 00:28:31
loco. Entre poner el public 00:28:33
y no, aunque ya entenderemos exactamente 00:28:35
qué es el public, a efectos 00:28:37
prácticos ahora mismo hay una diferencia 00:28:39
que puede que os afecte. 00:28:41
Que es, si uno pone el public, 00:28:43
lo que ponga aquí 00:28:46
Tiene que ser exactamente igual 00:28:47
Que el nombre del fichero 00:28:51
Exactamente igual que el nombre del fichero 00:28:52
Entonces si yo pongo public 00:28:54
Y ahora decido cambiar el nombre 00:28:56
De esta clase mía, de este programita mía 00:28:58
Porque me entiendo mejor si se llama 00:29:01
De otra manera 00:29:03
Y decido cambiar y llamarlo uno 00:29:03
Se ha fastidiado, error de compilación 00:29:06
¿Por qué? Porque esto no es igual 00:29:08
Que el nombre del fichero 00:29:10
Pero eso es así 00:29:12
Porque hay un public 00:29:14
si no hay un public 00:29:15
lo puedo llamar como me dé la gana 00:29:18
¿vale? entonces ahora mismo 00:29:20
¿por qué eso es así? pues todavía no lo entendemos 00:29:22
porque necesitamos mucha más información 00:29:24
pero os lo digo por si os encontráis con ese error de compilación 00:29:26
entonces 00:29:29
siempre es más fácil ahora mismo 00:29:29
que nos da igual public que no 00:29:32
porque no trabajamos con diferentes aplicaciones 00:29:33
quitar el public 00:29:36
y ya os aseguráis que nunca tendréis ese error 00:29:37
pero vamos que si dejáis el public 00:29:40
no pasa nada siempre y cuando 00:29:42
Esto se llama igual que el fichero 00:29:44
¿Vale? 00:29:46
Bueno, pues entonces 00:29:49
Estábamos con el System.out este de aquí 00:29:50
Vale, pues el System.out 00:29:53
Hasta ahora lo hemos visto solo como sentencia 00:29:57
Para mostrar una cadena 00:29:59
De texto por consola 00:30:01
Entrecomillada 00:30:02
Porque las cadenas de texto en Java 00:30:04
Van entre comillas dobles 00:30:06
Nunca entre comillas simples 00:30:08
¿Vale? Hay otros lenguajes 00:30:10
En las que las cadenas de texto 00:30:11
Pueden ir entre comillas simples o dobles 00:30:14
Da igual, como Python, como otros 00:30:16
En Java las cadenas de texto siempre entre comillas dobles 00:30:17
¿Vale? 00:30:21
Lo pongo aquí como recordatorio 00:30:21
Vale 00:30:24
De hecho si lo cambiárais y pusierais una comilla simple 00:30:36
Pues automáticamente el compilador despierta 00:30:40
Y dice 00:30:44
Uy, esto no es válido 00:30:45
Lo subraya en rojo 00:30:47
Porque las cadenas de texto en Java 00:30:49
Siempre entre comillas dobles 00:30:51
Vale, bueno pues 00:30:52
vamos a usar 00:30:55
para algo más 00:30:57
el System.out.println 00:30:59
que para mostrar cadenas de texto 00:31:01
sin más. ¿Para qué más 00:31:03
lo podemos usar? Pues para 00:31:05
mostrar el contenido de variables 00:31:07
de mi programa. 00:31:09
Entonces eso nos interesa desde ya 00:31:11
si estamos trabajando con variables para ver 00:31:13
un poquito cómo funcionan, qué tipo de valores 00:31:15
pueden recibir. Hombre, me interesaría 00:31:17
mostrar por consola 00:31:19
sus valores. Bueno, pues entonces 00:31:20
Podemos mostrar por consola 00:31:23
El contenido de variables 00:31:30
Por ejemplo, en este programita mío 00:31:33
Que estamos probando cosas 00:31:41
Mi variable número uno 00:31:42
Que me apetece ahora mostrarla por consola 00:31:44
Pues se la paso al system.println 00:31:47
Con su nombrecito 00:31:51
Número uno 00:31:53
¿Vale? 00:31:54
Le paso el nombre de la variable 00:31:59
Pero ojo 00:32:00
Aquí nunca jamás pondría comillas dobles 00:32:03
Claro, porque esto no es la cadena número uno 00:32:07
La que yo quiero mostrar 00:32:12
Quiero mostrar, exacto 00:32:13
Quiero mostrar el contenido de una variable 00:32:16
Entonces, obviamente 00:32:19
Este System.out.println 00:32:26
Y este otro 00:32:28
Son completamente distintos 00:32:30
Y muestran cosas distintas 00:32:32
El de arriba 00:32:34
Como ve algo que no está entre comillas 00:32:37
cuando ve algo que no está entrecomillado 00:32:40
asume que es el nombre de una variable 00:32:43
dice, vale, pues entonces 00:32:45
me voy a buscar esa variable 00:32:47
cojo su contenido 00:32:49
y lo muestro 00:32:51
pero la de abajo, como está 00:32:52
entre comillas, ya 00:32:55
ni piensa en variables, ni piensa 00:32:57
en nada, dice, esto es un texto, pues 00:32:59
calco el texto tal cual 00:33:01
¿verdad? entonces si ejecutamos esto 00:33:02
pues el system out de arriba 00:33:05
ha mostrado el 9, lógicamente 00:33:07
porque ha mostrado el contenido de la variable 00:33:09
y el de abajo ha mostrado el texto. 00:33:11
Luego son dos cosas que no tienen nada que ver. 00:33:16
Luego, siempre puedo hacer referencia a una variable 00:33:21
cuando lo necesito a través de su nombre. 00:33:24
De ahí la utilidad de darle un nombre a una variable. 00:33:29
Claro, porque yo le he dado a la variable a número uno. 00:33:33
Le he asignado un valor. 00:33:36
¿Y esa variable para qué la suelo querer yo? 00:33:38
Pues la suelo querer para operar, para mostrarla, 00:33:40
para hacer cosas, entonces cuando tenga que 00:33:42
operar con ella, mostrarla, hacer cosas 00:33:44
¿por qué me referiré? por su nombre 00:33:46
como en toda la vida de Dios 00:33:48
¿tú te refieres a algo por su nombre? 00:33:50
pues en un código te refieres a una 00:33:52
variable por su nombre, por el que le has querido dar 00:33:54
aquí nos hemos referido 00:33:56
por su nombre para mostrarla por consola 00:33:58
pero podríamos habernos 00:34:00
querido referir a ella por su 00:34:02
nombre para asignárselo a otra 00:34:04
por ejemplo, yo 00:34:06
tengo aquí otra variable más 00:34:08
que la llamo num 00:34:11
y le vamos a asignar 00:34:13
a esta 00:34:16
variable un valor 00:34:18
podría asignarle un numerito 00:34:20
que hemos visto hasta ahora, pero no 00:34:22
yo quiero asignarle el valor 00:34:24
que tiene mi otra variable 00:34:27
vale, pues como me refiero a esa variable 00:34:28
por su nombre, como me refiero a todo 00:34:31
en la vida, pues entonces 00:34:32
pongo esto 00:34:34
vale 00:34:36
entonces siempre que necesite usar 00:34:37
el valor de una variable 00:34:40
el valor de una variable 00:34:42
nos referimos allá por su nombre 00:34:44
aquí hemos usado 00:34:46
el valor de esa variable 00:34:48
para mostrarlo por consola 00:34:50
aquí hemos usado 00:34:52
el valor de esta variable 00:34:54
para asignárselo a NUM 00:34:56
entonces una variable 00:34:58
en esta 00:35:00
composición mental lógica 00:35:02
en la que uno ya va organizando sus neuronas 00:35:04
una variable pensad que 00:35:07
Tiene dos conceptos dentro, su nombre y su valor. 00:35:08
Lo que interesa es el valor, porque con el valor operamos y el valor cambia. 00:35:13
El valor a veces era 7, a veces 12, a veces 15. 00:35:18
Y otro concepto es su nombre. 00:35:21
Su nombre es siempre el mismo, el nombre no cambia. 00:35:23
Y el nombre lo usamos cuando necesitemos utilizar su valor. 00:35:26
Aquí hemos necesitado usar el valor de esta variable para mostrarla. 00:35:32
Usamos su nombre. 00:35:37
El nombre no cambia, siempre es el mismo. 00:35:38
Aquí hemos necesitado usar el valor de esta variable 00:35:41
para asignárselo a otra. 00:35:45
Pues usamos su nombre, su nombre no cambia. 00:35:48
Entonces, de una variable lo que se utiliza es el valor, 00:35:50
porque es lo único que tiene, su valor dentro. 00:35:53
Es lo que se utiliza. 00:35:55
Y cuando queramos utilizarlo, ¿qué tenemos que hacer? 00:35:57
Pues llamarla por su nombre, ¿vale? 00:36:00
Y lo que es más, por ejemplo, 00:36:07
imaginaos que ahora quiero yo 00:36:10
la variable número 1 00:36:14
no sé qué valor tiene 00:36:16
porque me la ha pasado alguien 00:36:18
nosotros en los códigos que estamos haciendo 00:36:19
como son un único código nuestro 00:36:21
pues sé qué valor tiene porque me voy para arriba 00:36:23
y lo miro 00:36:25
pero claro, en condiciones normales 00:36:26
pues una variable uno puede no saber qué valor tiene 00:36:28
porque se la ha pasado otro programa 00:36:31
ya veremos cómo, etc. 00:36:33
o porque las pasa por consola, no sabes 00:36:34
pero sabes que esta variable 00:36:36
que ha recibido un valor en algún sitio, 00:36:39
en nuestro caso aquí, pero puede haber sido en otro sitio, 00:36:41
sabes que lo que quieres es a esa variable 00:36:44
el valor que tuviera sumarle 3, por ejemplo, 00:36:46
porque te interesa eso. 00:36:50
Vale, pues entonces tú quieres a la variable 00:36:52
que se llama número 1, 00:36:55
quieres asignarle un valor que es 00:36:57
3 veces más del valor que tenía antes. 00:36:59
Vale, y ahora ya paramos. 00:37:05
Bueno, pues eso ¿en qué se traduce? 00:37:07
Se traduce. ¿Qué estoy haciendo? Asignación. Porque es darle valor a variable. Entonces, primero identifica uno que lo que está haciendo es una asignación. Vale, estoy dándole a número uno algo. Muy bien, asignación. Hasta ahí está claro. A número uno le estoy dando algo. Luego sé que es asignación. 00:37:09
ahora 00:37:27
pensamos, como es asignación 00:37:28
tiene que ser así, entonces nosotros del lenguaje 00:37:32
natural, que el lenguaje natural a veces 00:37:34
es engorroso, pues el lenguaje natural es 00:37:36
suma tres a número uno 00:37:38
suma tres a número uno es nuestro lenguaje 00:37:40
todos nos entendemos muy bien 00:37:42
pero en la máquina virtual hay que expresárselo 00:37:43
en su idioma, que es el código Java 00:37:46
entonces ya lo traducimos 00:37:48
a lenguaje de programación 00:37:50
vale, ¿qué significa sumar tres 00:37:52
a la variable número uno? 00:37:54
pues ahora ya lo traduzco y digo 00:37:55
significa a número 1 00:37:58
asignarle algo, eso para empezar 00:38:00
asignarle algo, vale, ya he avanzado 00:38:01
mucho, que es, ojo, identificado 00:38:04
que lo que tengo que hacer es una sentencia 00:38:06
de asignación, estupendo 00:38:08
sentencia de asignación 00:38:10
eso lo voy a tener que hacer sí o sí 00:38:11
porque he identificado sentencia de asignación 00:38:14
número 1, vale, vamos a la siguiente 00:38:16
parte, vale, y que 00:38:18
le asigno 00:38:20
volvemos al enunciado inicial, súmale 3 00:38:20
a número 1, vale, pues entonces 00:38:24
¿qué le asigno? le asigno 00:38:25
el valor que tiene número 1 00:38:27
ese valor, a ese valor 00:38:29
le sumo 3 00:38:31
¿cómo accedemos al valor que tiene 00:38:33
una variable? con su nombre 00:38:35
lo acabamos de decir, pues entonces 00:38:37
este valor ya está 00:38:39
hago esto 00:38:41
entonces ya he traducido 00:38:43
lo de suma 3 a la variable 00:38:45
número 1 que está hecho en lenguaje de humanos 00:38:47
lo he traducido a una asignación 00:38:49
que es, a la variable número 1 00:38:51
hay que asignarle algo, muy bien 00:38:53
asignación, no hay tutía, la asignación solo es así 00:38:55
no hay alternativa 00:38:57
segunda parte, ¿qué valor le doy? 00:38:58
el valor 00:39:02
de la variable número 1 00:39:03
ah, ya sé cómo acceder a eso, con su nombre 00:39:05
pero ese valor no solo 00:39:07
le tengo que sumar un 3, vale 00:39:08
pues las operaciones de suma, resta, multiplicación 00:39:11
y divisiones podemos hacerlas 00:39:13
en Java siempre que queramos con estos operadores 00:39:14
ya revisaremos 00:39:17
más operadores, pero desde ya 00:39:19
nos suena raro que hagamos 00:39:21
Es una suma o una resta, ¿no? 00:39:23
De valores. 00:39:24
Bueno, pues entonces, 00:39:26
¿qué he querido decir con esta sentencia a construir? 00:39:28
Que una variable puede recibir un valor 00:39:34
que le involucra a sí misma. 00:39:37
No pasa nada. 00:39:38
Esto es una sentencia nada rara. 00:39:39
¿Y qué va a ocurrir? 00:39:41
Que el valor de número uno antiguo 00:39:42
queda sobrescrito por uno nuevo. 00:39:45
Aquí coge el que tenía de antes. 00:39:48
porque lo que hace la máquina virtual 00:39:50
es primero evaluar esta expresión 00:39:53
lo primero que hace es evaluar la expresión que hay aquí 00:39:55
para evaluar la expresión 00:39:57
cuando hay numeritos, es el número 00:39:59
no hay duda, y cuando hay variables 00:40:01
¿qué tiene que hacer? ya lo sabemos 00:40:03
se va al contenido 00:40:05
aquí hay un numerito, no hay duda, el 3 00:40:06
aquí que hay una variable 00:40:09
me voy al contenido, que tenía 00:40:11
9, vale 00:40:13
9 más 3, 12 00:40:14
ya tengo el valor 00:40:17
La máquina virtual una vez que tiene el valor 00:40:19
Ahora ya mira esta parte 00:40:22
Esto ya es lo último que mira 00:40:23
Una vez que ha construido el valor 00:40:24
Ahora ya lo mete en esta caja 00:40:26
El efecto secundario al meterlo en esta caja 00:40:29
Es que pisa lo que tuviera antes 00:40:32
Pues ya está, es que las asignaciones son así 00:40:33
Lo que tú asignas pisa lo que tuviera antes 00:40:35
Puma nada, se supone que es lo que quieres hacer 00:40:37
¿Vale? 00:40:39
Vale, pues ahora sí que vamos a 00:40:42
Parar aquí 00:40:44
Un minuto 00:40:44
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
17
Fecha:
19 de septiembre de 2024 - 16:59
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
40′ 46″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
152.40 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid