20260917 Variables_3 | Mediateca de EducaMadrid

bueno 00:00:00

pues más o menos todo el mundo 00:00:02

se le ha quedado claro de ayer 00:00:04

primero que es una variable 00:00:06

por ejemplo 00:00:09

¿tú puedes decir que es una variable? 00:00:10

seguro que eres capaz 00:00:16

¿un espacio de la memoria? 00:00:17

muy bien 00:00:25

claro que le das 00:00:26

claro, que sirve para darle valores 00:00:27

efectivamente a lo largo de tu vida 00:00:30

eso es exactamente una variable 00:00:32

un espacio en memoria que está ahí 00:00:34

creado para que el programa 00:00:37

pueda meterlos en él 00:00:39

y tenerlos ahí alineados para 00:00:40

meterlos, operar con ellos 00:00:42

eso es una variable 00:00:45

vale, esa es su definición 00:00:46

¿qué más cosas me podéis 00:00:49

decir de una variable ya en general? 00:00:51

más cosas de una variable 00:00:53

una variable necesita tener 00:00:54

siempre un título 00:00:57

en Java 00:00:58

un tipo, sí 00:01:00

ahora en concreto estaba pensando en un nombre 00:01:02

vale, pero sí, las dos cosas son ciertas 00:01:05

a una variable hay que darle un nombre 00:01:07

porque si no, cuando tú escribas 00:01:09

las sentencias de código, ¿cómo te refieres 00:01:11

a ese espacio en memoria en concreto? 00:01:13

de todos los que tienes 00:01:16

pues a cada uno de los espacios 00:01:17

en memoria en concreto te refieres con su nombre 00:01:19

lógicamente 00:01:22

luego cada variable recibe su propio nombre 00:01:22

y las reglas 00:01:25

ya de sintaxis de cada lenguaje 00:01:27

las reglas sintácticas 00:01:30

es lo que yo puedo 00:01:31

escribir 00:01:34

siguiendo las reglas 00:01:34

y lo que no, las reglas sintácticas de Java 00:01:37

pues en general quedémonos 00:01:39

con que nos dicen que elijamos 00:01:40

nombres de variables que sean 00:01:43

compuestos de letras 00:01:45

números 00:01:47

y subrayado 00:01:48

y que no 00:01:50

empiecen por número, ¿vale? 00:01:53

esas más o menos, con esas reglas básicas 00:01:54

podemos hacer nombres de variables 00:01:56

vale 00:01:58

entonces, la variable es un espacio 00:01:58

en memoria, luego como muy bien habéis dicho 00:02:02

la variable es de un tipo dentro de un conjunto de tipos posibles. ¿Y qué significa ser de un tipo? 00:02:04

En realidad, en Java, en programación, significa solamente cuánto espacio ocupa en memoria y cómo 00:02:13

está codificado. Entonces, una variable de tipo entero, de tipo entero, es una variable que está 00:02:20

codificada para guardar números 00:02:29

enteros, ya está 00:02:31

esa es una variable de tipo entero 00:02:33

¿y cuánto espacio damos para 00:02:35

codificar esa variable 00:02:37

de tipo entero? pues tenemos hasta 00:02:39

cuatro posibilidades 00:02:41

o dar solo un byte, 8 bits 00:02:43

entonces ese subtipo 00:02:45

dentro de los enteros 00:02:48

sería el subtipo que se llamaba byte 00:02:49

¿qué damos 16 bits 00:02:51

para codificar ese número entero? 00:02:54

pues entonces estamos hablando 00:02:56

del subtipo short 00:02:58

¿Vale? 00:02:59

Quedamos 32 bits 00:03:01

Para codificar ese número entero 00:03:03

Luego nos, podremos codificar números 00:03:05

Todavía más grandotes, con 32 bits 00:03:07

Pues esa variable, ese tipo 00:03:09

Entonces lo llamamos int 00:03:11

Quedamos hasta 64 bits 00:03:13

Para codificar ese número 00:03:15

En memoria RAM 00:03:17

Podemos guardar números muy grandotes 00:03:18

Pues ese tipo se llamará log 00:03:20

¿Vale? Luego 4 00:03:23

Subtipos, si lo queréis ver así 00:03:25

B para codificar 00:03:27

Variables de tipo número 00:03:29

Entonces cada uno de ellos eran 00:03:31

Como ya mencionamos ayer 00:03:33

Eran 00:03:36

Int 00:03:52

Bueno, empezado por 00:03:55

Shabbat 00:03:57

Short, muy bien 00:03:58

Int 00:04:01

Y long 00:04:02

Int y long 00:04:03

Son los dos tipos más usados para declarar variables de tipo número, ¿vale? 00:04:07

Porque byte y short, al tener solamente 8 bits esta de aquí y 16 bits esta de aquí, al tener solo eso, pues me permite números en un rango demasiado pequeño, ¿vale? 00:04:13

byte, pues entre menos 127 00:04:30

y 127 a cross 00:04:33

y short 00:04:34

pues entre 256 y 990 00:04:36

a cross, o sea, es poquito 00:04:38

pues normalmente cuando nosotros 00:04:40

necesitemos una variable 00:04:42

de tipo número entero, porque nuestro programa 00:04:45

va a trabajar con números enteros 00:04:47

para sumarlos, restarlos, porque haga falta 00:04:48

pues normalmente usaremos este 00:04:50

que es el que tiene 00:04:52

32 bits 00:04:54

y si ya nuestro 00:04:55

programa va a usar números enormes, que hay veces que puede ocurrir, lo declaramos así. 00:04:58

Bueno, pues ¿cómo se declara una variable? Ya dijimos ayer que eso ya se tiene que hacer 00:05:07

mediante una sentencia de código. Eso ya es código de programa, declarar variable. 00:05:12

Ya es una línea de código. Luego mi programa no tendrá solamente sentencias que hacen 00:05:17

cosas. Por supuesto que tendrá sentencias que hacen cosas, pero también tendrá sentencias 00:05:22

que valen solamente para declarar 00:05:27

variables, solo para eso. 00:05:29

Bueno, pues ¿cuál es la sintaxis, 00:05:31

las reglas, 00:05:33

las normas que tengo que seguir para 00:05:35

declarar correctamente una variable? 00:05:37

Ya las dijimos ayer. 00:05:39

Una vez que ya he elegido 00:05:41

el tipo de dato 00:05:43

que me interesa, el tipo de dato, 00:05:44

pues lo primero que pongo es el tipo de 00:05:47

dato. Eso es lo primero que pongo. 00:05:49

¿Vale? 00:05:52

Y luego ya 00:05:53

pongo el nombre que a mí me dé 00:05:54

la gana para la variable, el nombre lo más explicativo posible, porque luego mi programa 00:05:56

tendrá un montón de sentencias por debajo que hacen cosas con la variable altura, altura 00:06:02

por tres, altura no sé qué, entonces cuando yo vea esas sentencias ahí abajo, pues ya 00:06:06

sé en realidad qué están haciendo, ah, están haciendo cosas con alturas, ¿vale? 00:06:12

Lo que decíamos ayer, si yo a esta variable le he llamado x y veo un programa y me miro 00:06:16

directamente las líneas de abajo y veo un montón de operaciones con una tal x, digo 00:06:21

¿Y esto qué significa? ¿Para qué sirve? 00:06:25

Porque vuestros códigos 00:06:28

Lógicamente 00:06:30

Trabajarán con ellos otras personas 00:06:31

Que los cultivarán, los desarrollarán 00:06:33

O los mantendrán 00:06:35

Y tienen que ser códigos 00:06:36

Lo más fáciles de entender posibles 00:06:38

Si no son fáciles de entender 00:06:41

Pues ese código no se va a poder mantener 00:06:42

Con lo cual no va a ser un código bien hecho 00:06:44

Porque no se puede mantener correctamente 00:06:46

Y entonces vosotros lo habréis hecho mal 00:06:48

Con todo lo que eso implica 00:06:51

Bueno, pues entonces ayer 00:06:52

estábamos simplemente ya 00:06:54

en nuestro entorno de desarrollo 00:06:56

en el que íbamos a trabajar, poniendo 00:06:58

esa sentencia para ver, comprobar 00:07:00

que esa era su sintaxis correcta. 00:07:02

¿Vale? ¿Alguien ha tenido algún problema 00:07:05

instalando el eclipse? 00:07:06

Madre mía, cuánta gente. 00:07:11

Tú porque se quedaba parado. 00:07:12

¿No? Y se te sigue quedando parado. 00:07:14

¿Y vosotros? 00:07:17

¿Qué os ha pasado? 00:07:19

Y hablamos al topozo. 00:07:22

Venga, pues entonces 00:07:38

nosotros ya ayer habíamos dicho 00:07:52

como vamos a empezar ya desde el principio 00:07:54

para poder hacer cosas 00:07:57

a estirar líneas de código 00:07:58

hay cosas que 00:08:02

tenemos que poner por 00:08:04

decreto 00:08:06

sin entender todavía muy bien 00:08:08

qué significa, ¿vale? Entonces las cosas 00:08:10

que tenemos que poner por decreto 00:08:12

sin entender todavía muy bien que significan 00:08:14

porque están directamente 00:08:16

relacionadas a la programación de entrada de objetos 00:08:18

la cual todavía no conocemos 00:08:20

pues son estas, la primera línea que dijimos 00:08:21

que era 00:08:25

el paquete o subcarpeta 00:08:25

que uno había hecho aquí dentro del SRC 00:08:28

el paquete o subcarpeta donde tiene sus programitas 00:08:31

entonces, esta línea tiene que estar 00:08:35

luego tiene que estar esta otra 00:08:38

con una llave que se abre y otra que se cierra 00:08:40

donde ya va 00:08:43

todo el grueso del programa 00:08:45

y luego ya dentro de este bloque 00:08:46

que se abre y se cierra 00:08:49

esto, que es lo que se llama método 00:08:50

aunque ahora no lo entendemos 00:08:53

esto 00:08:54

que de nuevo abre aquí otro bloque 00:08:55

y aquí ya sí que irán 00:08:59

todas nuestras sentencias, ¿vale? 00:09:00

Repito, esto ya entenderemos 00:09:06

por qué hay que ponerlo, ahora no podemos 00:09:07

porque no sabemos programación orientada a objetos 00:09:09

vale 00:09:11

según vayáis haciendo cosas 00:09:13

si vais incorporando comentarios 00:09:15

mejor, porque así vais vosotros 00:09:17

explicándoos a vosotros mismos 00:09:19

en vuestros proyectos 00:09:21

porque estáis poniendo las cosas 00:09:23

los comentarios 00:09:24

ya seguramente sabéis 00:09:26

muchos de vosotros 00:09:29

que son líneas que se intercalan dentro del código 00:09:30

que son solamente 00:09:33

explicaciones para el humano 00:09:35

eso no se ejecuta 00:09:37

A la máquina virtual que va a ejecutar el programa, los comentarios los ignora directamente. 00:09:38

Los comentarios no se ejecutan, sirven solo para poner aclaraciones, que es fundamental. 00:09:45

Un programa bien comentado, con muchos comentarios, va a ser mucho más fácil de entender para otro que lo hereda y lo tiene que continuar manteniendo. 00:09:51

Entonces, ¿cómo incorporo comentarios en Java? 00:10:00

Pues tengo en realidad tres posibilidades. 00:10:05

una de ellas, los comentarios 00:10:07

multilínea que se llaman 00:10:10

cuando yo quiero empezar a hacer un comentario 00:10:11

esta es mi primera declaración de variable 00:10:13

pues barra 00:10:16

asterisco, ahí empieza 00:10:17

mi comentario y pongo yo lo que quiero 00:10:20

puedo seguir por aquí 00:10:22

abajo 00:10:32

de variable 00:10:32

entonces 00:10:36

el comentario 00:10:37

sigue siendo comentario, yo puedo seguir 00:10:39

aquí escribiendo cosas hasta el infinito 00:10:42

Y hasta que yo no le dé el cierre, que el cierre se lo doy de esta manera, no termina el comentario. 00:10:44

Es un comentario que se llama multilínea, porque yo pongo ahí un montón de líneas, bla, bla, bla, bla, bla, bla. 00:10:52

Desde el primer carácter hasta este último carácter, eso lo ignora el intérprete de Java, eso no se genera. 00:10:58

Otra forma de poner comentarios. 00:11:10

Cuando los comentarios van a durar solo una línea, que es relativamente habitual, 00:11:12

Para explicar cuál es la variable, pues los comentarios de una única línea arrancan con estas dobles barras, por ejemplo, esto sería un comentario típico, ¿vale? Con doble barra empieza un comentario que puede durar solo una línea. 00:11:17

desde el momento en que yo de un enter 00:11:42

lo siguiente 00:11:45

ya no es comentario 00:11:47

¿vale? ¿que quiero seguir comentando 00:11:48

aquí? pues pongo otra 00:11:51

doble barra 00:11:53

¿vale? es decir, si arranco 00:11:54

los comentarios con una barra sencilla 00:11:57

el comentario termina 00:11:59

en cuanto acaba la línea 00:12:01

¿vale? 00:12:02

con el siguiente salto de línea ya 00:12:05

se sobreentiende que es código 00:12:06

¿vale? 00:12:08

Entonces, incorporad comentarios para luego cuando veáis vuestros propios proyectos enteraros de lo que habéis hecho. Yo también iré incorporando comentarios porque bueno, ahora mismo estamos escribiendo dos chorradas, pero bueno, iré incorporando comentarios porque luego los proyectos, los ejercicios que vayamos ya subiendo resueltos, así se os quedan también comentados. 00:12:18

bueno 00:12:37

reglas de estilo 00:12:41

importante más de lo que parece 00:12:45

que vuestro código 00:12:48

tenga un estilo 00:12:50

legible 00:12:51

es decir, que se pueda leer 00:12:53

esto es como decir 00:12:55

tú puedes escribir el Quijote con una letra horrorosa 00:12:56

que sí, vale, está bien escrito 00:13:00

sin faltas de ortografía 00:13:03

perfectamente, pero con una letra horrible 00:13:05

que nadie entiende, con lo cual 00:13:07

alguien le das tú tu Quijote 00:13:10

escrito con tu letra, ortografía 00:13:12

perfecta, todo perfecto 00:13:14

y le cuesta a veces entenderlo, tiene que estar ahí 00:13:15

con la lupa a ver qué has escrito 00:13:18

eso sería escribir sin estilo 00:13:19

pero puedes escribir el Quijote 00:13:22

con una letra preciosa 00:13:24

perfecta, exactamente igual 00:13:26

que en el otro caso con las mismas 00:13:28

correcciones ortográficas 00:13:30

todo perfecto, pero 00:13:32

ese libro que has escrito con tu letra 00:13:34

perfecta, lo va a leer todo el mundo 00:13:36

y nadie lo va a tirar a la basura 00:13:38

porque lo entienden perfectamente. 00:13:40

Pues con el código es igual. 00:13:42

Yo este 00:13:45

programa lo puedo escribir así. 00:13:46

Voy a quitar 00:13:59

esto. ¡Hala! 00:13:59

Programa estupendo. 00:14:12

Perfecto. 00:14:15

La máquina virtual lo ejecuta. 00:14:16

Ni un solo error de compilación. 00:14:17

Recordad lo que eran los errores de compilación 00:14:19

de ayer. 00:14:21

Aquí no me aparece nada rojo. El programa está 00:14:23

estupendo, pero tú le entregas 00:14:25

esto a alguien 00:14:27

y madre mía, ve esto y dice, pero esto que es 00:14:28

tiene que ir así 00:14:31

que hay aquí escrito 00:14:32

y es una línea de código 00:14:34

la declaración de variables, si fueran tropecientas líneas 00:14:36

el programa 00:14:39

sintácticamente perfecto, ejecuta 00:14:41

la perfección, pero el que hereda 00:14:43

este código o quiere hacer algo con él 00:14:45

no entiende nada 00:14:47

luego, tenemos que seguir 00:14:48

unas reglas de estilo 00:14:50

que asumimos que seguimos todos 00:14:52

para que nuestros códigos sean legibles para otros. 00:14:54

Reglas de estilo. 00:14:59

Pues, por supuesto, cada sentencia en una línea, ¿vale? 00:15:00

Y la más importante, las tabulaciones. 00:15:04

Es decir, ahora mismo no sabemos muy bien lo que es un bloque 00:15:14

porque todavía nos falta mucha información. 00:15:17

Os digo simplemente que un bloque es todo el espacio encerrado 00:15:20

entre una llave que se abre 00:15:25

y otra que se cierra 00:15:27

luego aquí hemos tenido que hacer 00:15:28

obligatoriamente y sin entender 00:15:31

todavía por qué, porque os he dicho yo 00:15:33

tenéis que escribirlo así 00:15:35

aquí hemos tenido que hacer dos, este grandote 00:15:36

y dentro de ese 00:15:39

grandote este otro 00:15:41

ahora mismo lo hemos tenido que hacer así 00:15:43

porque os lo digo yo, que lo tenéis que hacer así 00:15:45

para poder escribir vuestro programa aquí dentro 00:15:46

vale, pues cada vez 00:15:49

que se abre un código 00:15:51

de estos, lo que hay dentro 00:15:53

tiene que ir tabulado, no es que tenga 00:15:55

no es obligatorio, pero es una regla de estilo 00:15:58

básica que todos debemos seguir 00:16:00

yo puedo escribir mi programa 00:16:01

también y está perfectamente escrito así 00:16:03

sintácticamente 00:16:06

ala, este programa 00:16:07

funciona exactamente igual que el otro 00:16:10

pero tú entregas esto 00:16:12

a alguien y dice, este tío no tiene ni puñetera idea 00:16:14

de hacer nada 00:16:16

y no te va a contratar, lógicamente, entregas un código 00:16:16

así, porque no estás siguiendo las reglas de estilo 00:16:20

comúnmente aceptadas 00:16:22

¿Qué te dicen? Uy, aquí arranca un bloque. Tabula. Tabula. Tabulo. Vale. Aquí arranca otro. Aquí arranca otro. Pues tabula dentro del de arriba. Vale. Y si no lo dejo aquí pegado, mejor. Aunque bueno, eso podría ser cuestionable e ir en gustos. Depende. Vale. 00:16:24

Esto ya sí 00:16:47

Aquí he arrancado un bloque 00:16:49

¡Pum! He tabulado 00:16:51

Resulta que aquí he tenido que arrancar otro 00:16:52

Todavía no sabemos por qué, pero he tenido que arrancarlo 00:16:55

¡Pum! He tabulado 00:16:57

¿Vale? 00:16:59

Cuando ya hagamos sentencias de cosas 00:17:01

Que arrancan otros bloques dentro 00:17:03

Que ya las tendremos que hacer 00:17:05

Lo que hagamos dentro de eso 00:17:06

Tabulado también 00:17:08

Ahora mismo pondremos una sentencia detrás de otra 00:17:09

Con lo cual ya no hará falta tabular más 00:17:12

estos tabuladores que fijan los entornos de desarrollo 00:17:13

son de cuatro espacios 00:17:18

que es lo que se asume 00:17:20

que es el tabulador estándar 00:17:21

en el código fuente de cualquier lenguaje 00:17:24

de programación prácticamente 00:17:26

cuatro espacios, ¿vale? 00:17:27

son tabuladores de cuatro espacios 00:17:29

lo digo porque no vale que me tabuleis y esta línea 00:17:31

aparezca aquí, queda muy feo 00:17:33

tabuladores de cuatro espacios 00:17:35

pero el entorno de desarrollo de Eclipse ya lo tiene 00:17:37

configurado para que sean cuatro 00:17:39

¿vale? 00:17:41

bueno, pues entonces 00:17:43

ahora ya siguiendo esas reglas de estilo 00:17:46

incluso comentando 00:17:48

y todo 00:17:50

pues ya hemos declarado nuestra primera variable 00:17:51

vale 00:17:57

este programa se ejecuta 00:17:58

podemos ejecutarlo 00:18:02

todavía no vamos a ejecutarlo 00:18:03

porque no vamos a ver nada 00:18:04

porque ¿qué es lo que va a hacer? 00:18:06

pues ya sabemos lo que va a hacer, pero eso no lo vamos a ver nosotros 00:18:08

cuando yo arranque 00:18:11

y le diga a la máquina virtual 00:18:13

que desde el Eclipse es muy fácil decírselo 00:18:15

le diga a la máquina virtual 00:18:17

ejecuta este programa que he hecho 00:18:18

con su única línea 00:18:20

porque el comentario es como si no existiera 00:18:22

a la máquina virtual, ya sabéis 00:18:25

pues ¿qué va a hacer la máquina virtual? 00:18:26

venga, yo ejecuto, vale 00:18:29

voy a ejecutar esta línea 00:18:30

anda, es una declaración 00:18:32

de variable, porque empieza 00:18:35

con el nombre de un tipo de dato 00:18:37

y continúa con un 00:18:38

nombre de variable, es una declaración 00:18:40

¿qué es lo que hace la máquina 00:18:43

virtual para ejecutar una declaración 00:18:45

lo que hace es 00:18:47

se va a la RAM 00:18:49

y habilita la cajita 00:18:51

para guardar 00:18:53

ese dato 00:18:55

esta cajita de cuánto 00:18:55

voy a ver, vale 00:18:59

pues te habilita una cajita 00:19:00

de 4 bits 00:19:02

o 32 bits, ya está 00:19:04

y le asocia 00:19:07

internamente, porque la máquina 00:19:08

virtual pues lleva su, lógicamente 00:19:11

su registro interno de todo lo que está haciendo 00:19:13

para luego seguir operando 00:19:15

le asocia internamente el nombre y altura 00:19:16

y se acabó la ejecución 00:19:19

de esta línea 00:19:21

aparece la cajita en RAD 00:19:21

tamaño correspondiente 00:19:24

al tipo 00:19:27

que hemos decidido 00:19:28

y le asocia 00:19:31

un nombrecito, por si luego hay que hacer algo con ella 00:19:33

esta sentencia 00:19:35

se ha terminado 00:19:37

nos vamos a la siguiente 00:19:38

hay siguiente 00:19:41

Uy, no es siguiente 00:19:43

Ya me acabo de encontrar la llave 00:19:44

Que está mal puesta, por cierto 00:19:47

No la he vuelto a tabular 00:19:48

Vale 00:19:50

Esta llave aquí 00:19:51

Vale 00:19:54

Ahora ya sí está tabulada 00:19:55

Vale, siguiente sentencia 00:20:01

Ya acabo de hacer 00:20:03

Esta que decía 00:20:05

Acabo de ejecutar esta 00:20:07

Que es crear en RAM 00:20:09

El espacio 00:20:10

vale 00:20:14

me voy a la siguiente 00:20:16

yo máquina virtual 00:20:18

no hay ninguna 00:20:19

se acabó, ya tengo la llave 00:20:22

de cierre de aquí 00:20:24

y la llave de cierre de aquí 00:20:25

significa programa terminado 00:20:28

eso significa 00:20:30

programa terminado, vale 00:20:32

pues el programa terminó 00:20:33

y que pasa cuando un programa termina 00:20:35

el proceso automáticamente 00:20:39

en memoria ya desaparece como si nunca hubiera existido 00:20:41

y con él 00:20:44

todo lo que hubiera en la RAM 00:20:45

que ese programa había declarado 00:20:47

20 variables 00:20:51

pues se supone que ese programa ha operado con las variables 00:20:52

cuando el programa ha terminado 00:20:55

yo he llegado aquí a este final 00:20:57

pum 00:20:59

ese espacio en RAM 00:21:00

con las variables desaparece 00:21:03

ya está, se acabó, no está en ningún sitio 00:21:05

entonces más vale que a lo largo del programa 00:21:07

me las haya enseñado 00:21:09

o algo porque ya está, han desaparecido 00:21:11

luego 00:21:13

si yo ejecuto este programa 00:21:15

ahora mismo, pues ya está 00:21:17

en un nanosegundo 00:21:19

ya va a haber terminado 00:21:21

y no vamos a ver nada, lógicamente 00:21:23

ha declarado la variable y ese espacio tal cual 00:21:25

se creó, ahí, ha desaparecido 00:21:27

eso es lo que haría este programa 00:21:29

¿vale? 00:21:31

bueno, pues 00:21:36

para verlo un poco más, antes de seguir con los tipos 00:21:37

de datos 00:21:39

vamos a hacer 00:21:39

la primera de las sentencias 00:21:41

que ya sí que hacen algo, además de declarar una variable. 00:21:45

Vamos a hacer una cosa que es, vamos a asignarle un valor a la variable. 00:21:51

¿Vale? Vamos a asignarle un valor. 00:21:56

Mi máquina virtual ya ha creado el espacio. 00:21:59

Ya está, lo ha creado. 00:22:03

¿Vale? Ese espacio se supone que es para introducir datos en él y operar con ellos. 00:22:11

pues como introducimos datos 00:22:16

desde nuestro código 00:22:19

en una variable 00:22:21

como le metemos datos 00:22:23

pues mediante una cosa 00:22:25

que se llama asignación 00:22:27

de variable 00:22:29

asignación 00:22:29

de valor 00:22:35

a una variable 00:22:38

mediante la sentencia 00:22:39

de asignación 00:22:47

yo le doy ya un valor a una variable 00:22:48

vale 00:22:51

Bueno, pues vamos a incorporar una sentencia para asignar valor a una variable 00:22:53

Y ya tendremos otra línea más de código 00:22:59

Bueno, pues ¿cómo es la sentencia de asignación? 00:23:01

Pues lo más sencillo del mundo 00:23:07

Una vez que mi variable está declarada 00:23:09

Que yo quiero hacer una asignación de un valor 00:23:12

¿Cómo lo hago? 00:23:18

Pues tengo que poner 00:23:24

el nombre de esa variable 00:23:25

el nombre de esa variable 00:23:28

a la que voy a asignar un valor 00:23:30

seguido 00:23:32

del operador 00:23:34

igual 00:23:36

y ahora ahí 00:23:37

el valor que yo quiera asignar 00:23:40

el valor que yo quiera asignar 00:23:42

ahora cuando lo ponga 00:23:46

y como la sentencia termina 00:23:47

ahí 00:23:52

cerraría con punto y coma 00:23:52

ahora completamos aquí esas interrogaciones 00:23:54

Luego, para asignar un valor concreto 00:23:57

Ahora ya a una variable 00:24:02

Porque para eso valen las variables 00:24:03

Para meterle valores 00:24:05

No valen para otra cosa 00:24:06

Que no sea para meterle valores 00:24:07

Pues para asignar un valor a una variable 00:24:09

Es así exactamente 00:24:11

Y ya está 00:24:14

Nombre de la variable 00:24:15

El nombre de la variable también se le llama 00:24:17

Identificador 00:24:20

Identificar es un término muy general 00:24:21

Bueno, pues nombre de la variable 00:24:24

Seguido de igual 00:24:26

y aquí el valor que yo le quiera dar, ¿vale? 00:24:28

Y ahora la pregunta es, ¿qué valor, qué tipo de valor le tengo que darle a esa variable? 00:24:38

Decidme un valor que yo pudiera darle, uno cualquiera. 00:24:50

¿Cuál? 00:24:55

Trece, trece precisamente, ¿vale? 00:24:56

¿Trece es un número entero? 00:24:59

si, 13 lo puedo 00:25:01

codificar en binario en 32 bits 00:25:04

sin duda, porque 00:25:06

32 bits me valen para codificar 00:25:08

números muy grandotes 00:25:10

pues va a ser que 13 es un valor válido 00:25:11

pues venga, vamos a darle 13 00:25:14

ya está 00:25:16

ala, ya está 00:25:17

mi variable altura 00:25:21

ahora ya tiene aquí un valor 00:25:28

que es el valor 13 00:25:30

vale 00:25:35

yo tengo ahí 00:25:36

altura 00:25:41

que hasta aquí estaba indefinido 00:25:42

definido entre comillas 00:25:45

porque los bits tienen que tener algo siempre 00:25:47

no pueden 00:25:50

o tienen ceros o tienen unos 00:25:50

y ahora ya 00:25:52

yo digo, venga, le voy a dar un valor 00:25:57

pues nada, en esta cajita de 4 bits 00:25:59

en esta cajita de 4 bits 00:26:01

lo doy 00:26:09

le eché 00:26:10

está morado y no lo veo 00:26:11

vale 00:26:14

en esta cajita de 4 bits 00:26:15

ya está ahí el 13 guardado 00:26:21

¿vale? ya está 00:26:24

el 13, vale 00:26:25

bueno, pues ya mi programación iría más 00:26:26

bueno, entonces 00:26:29

sentencia de asignación, ya no se le olvida 00:26:31

a nadie 00:26:33

siempre tiene 00:26:34

a la izquierda el nombre 00:26:36

de la variable 00:26:39

y a la derecha 00:26:40

el valor que le doy 00:26:46

parece evidente, pero hay veces 00:26:48

lo ponéis al revés 00:26:51

a la izquierda siempre el nombre 00:26:53

de la variable que recibe el valor 00:26:56

y a la derecha 00:26:58

del operador igual 00:27:00

que se le llama operador de asignación 00:27:01

por razones obvias porque sirve para 00:27:04

asignar, a la derecha 00:27:06

el valor que yo le doy 00:27:08

valor 00:27:09

compatible 00:27:11

con el tipo definido 00:27:12

el 13 es un 00:27:16

número entero que cabe en 32 bits 00:27:18

magnífico, valor perfectamente 00:27:20

compatible 00:27:22

¿vale? 00:27:23

y esto ya sí que es regla de estilo 00:27:26

antes y después 00:27:29

del igual 00:27:30

se pone un espacio 00:27:31

que no esté ahí todo apiñado 00:27:33

¿vale? luego la regla de estilo 00:27:36

de tabular 00:27:38

en cuanto yo abro un bloque 00:27:39

todo ahí tabulado 00:27:42

esa, desde ya 00:27:43

sin olvidar 00:27:46

en un solo momento 00:27:48

y la regla de estilo 00:27:49

de espacio antes y después del igual 00:27:51

también, desde ya, ¿vale? 00:27:53

no empecéis a hacer códigos 00:27:55

apiñaos 00:27:57

¿por qué no? 00:27:59

bueno, pues ya tenemos aquí 00:28:03

dos sentencias de código 00:28:04

¿vale? 00:28:06

¿perdón? 00:28:10

entonces 00:28:15

si ejecutamos esto, seguiremos sin ver nada 00:28:15

todo esto habrá pasado, no me lo he imaginado 00:28:20

todo esto habrá pasado 00:28:22

Se habrá creado la variable y se le habrá metido un 13. 00:28:23

Llegamos aquí, el programa se ha acabado, esa variable con su 13 ha desaparecido. 00:28:28

Vale, ¿para qué le doy yo valores a variables? 00:28:37

Hombre, para hacer cosas con ellas. 00:28:40

Por ahora, al menos, para poder hacer comprobaciones de que las cosas funcionan, 00:28:42

vamos a incorporar la sentencia de mostrar por pantalla. 00:28:47

para que al menos desde ya 00:28:51

podamos ver nosotros 00:28:53

por pantalla los resultados 00:28:55

de las cosas que estamos haciendo 00:28:57

entonces 00:28:59

la sentencia de mostrar por pantalla 00:29:01

es muy sencilla 00:29:04

y es simplemente esto 00:29:05

system con la primera S 00:29:14

mayúscula 00:29:16

print o println 00:29:18

da igual 00:29:20

vale, vamos a 00:29:21

y aquí, y esto terminado en punto y coma 00:29:23

vale 00:29:27

ahora completo las interrogaciones 00:29:27

esta es la sentencia básica 00:29:30

para que 00:29:32

la máquina virtual cuando llegue a ella 00:29:35

muestre algo por pantalla 00:29:37

para que lo veamos 00:29:39

¿vale? 00:29:40

¿y qué es lo que va a mostrar? 00:29:42

lo que le metamos aquí dentro 00:29:44

lo que le metamos aquí dentro 00:29:46

¿vale? 00:29:48

entonces 00:29:51

¿yo qué quiero ver ahora? 00:29:52

quiero ver 00:29:54

lo que tiene mi variable altura 00:29:55

eso es lo que quiero ver 00:29:57

pues entonces, ¿qué escribo aquí? 00:29:59

¿qué escribiría ahí? 00:30:02

si lo que quiero ver es 00:30:04

el contenido de mi variable altura 00:30:05

altura, el nombre de la variable 00:30:08

para eso sirve el nombre 00:30:11

¿vale? 00:30:12

para eso sirve el nombre 00:30:17

para hacer referencia al espacio 00:30:19

entonces, si yo pongo aquí 00:30:21

system.out.print 00:30:23

entonces dice, ah, un nombrecito 00:30:24

Pues la máquina virtual dice, este nombrecito será de una variable, lógicamente, voy yo a buscar ese nombrecito en mi RAM y voy a mostrar lo que hay dentro, ¿vale? 00:30:27

Esta es la secuencia que seguirá mi máquina virtual ejecutando estas tres cosas. 00:30:42

Primera sentencia, crea la variable altura en la memoria RAM, primera sentencia. 00:30:47

Segunda, asigna el número 13 a esta variable 00:30:59

Muy bien 00:31:06

Tercera sentencia, muéstrame algo por pantalla 00:31:07

¿El qué? 00:31:11

Uy, una cosa que se llama altura 00:31:12

Debe ser que tengo yo algo que se llama altura aquí 00:31:15

Se va a su RAM y dice, ah, sí, sí, sí, sí 00:31:18

Tengo una cosa que se llama altura 00:31:22

Pues venga, lo muestro 00:31:24

Con lo cual me mostrará 13 por consola 00:31:25

la secuencia de lo que está haciendo la máquina virtual 00:31:29

cuando se ejecute está clara 00:31:40

¿cómo ejecutamos esto desde Eclipse? 00:31:42

¿qué es lo más fácil? 00:31:52

desde consola, ahora mismo para no liarnos mucho a la consola 00:31:53

llamaríamos a la máquina virtual, le pasaríamos el compilado, etc. 00:31:56

pero el Eclipse ya te lo pre-compila directamente 00:32:00

no tenemos nosotros que hacer ese código intermedio by code 00:32:04

Recordad que decíamos que en Java, al ser un lenguaje mixto, primero el código este de aquí, que es el código fuente, se compila a un intermedio que se llama bytecode 00:32:08

y ahora ya la máquina virtual coge ese intermedio y lo va ejecutando. 00:32:20

Perdonad, creía que lo había... 00:32:24

Disculpad, a ver si va a ser... 00:32:27

¿Sí? 00:32:31

Perdón. 00:33:07

vale, pues entonces 00:33:07

el Eclipse ya nos hace 00:33:10

automáticamente, según vamos escribiendo 00:33:12

nos hace automáticamente 00:33:14

esa compilación al código intermedio 00:33:16

entonces nosotros ya 00:33:18

si trabajamos con el Eclipse nos olvidamos 00:33:20

ya directamente llamamos a la máquina virtual 00:33:22

para que lo ejecute, ya está 00:33:25

entonces, llamar a la máquina virtual 00:33:26

desde el Eclipse para que lo ejecute 00:33:29

es muy sencillo 00:33:31

¿vale? 00:33:33

simplemente, por ejemplo 00:33:35

el código que queréis ejecutar 00:33:36

este de aquí 00:33:38

pues le dais al botón derecho 00:33:39

oye ejecútame runas, ejecútame 00:33:42

y aquí 00:33:44

¿vale? ejecútamelo 00:33:46

¿vale? 00:33:48

y se abre una consola donde te muestra 00:33:50

el resultado 00:33:52

y ha hecho 00:33:52

lo que esperábamos que hiciera 00:33:56

ha hecho lo que esperábamos 00:33:57

que hiciera, que es mostrarme 00:34:00

por consola el 13 00:34:02

dime 00:34:03

si, entonces 00:34:04

tú vas a ejecutar un programa por primera vez 00:34:07

pues pinchas aquí 00:34:09

en el código que tienes escrito, botón derecho 00:34:10

en el desplegable te sale 00:34:13

un runas 00:34:15

y la primera opción que te sale, que es java 00:34:16

application, vale 00:34:19

una vez que ya has ejecutado programas 00:34:20

en el historial este del botón verde 00:34:23

este que es el botón verde 00:34:25

de ejecutar, tiene aquí un historial 00:34:27

vale 00:34:29

en el runas 00:34:30

de los últimos programas 00:34:32

que has ejecutado 00:34:35

vale 00:34:36

entonces 00:34:37

aquí perdón 00:34:38

entonces 00:34:47

en mi historial 00:34:48

ahora mismo 00:34:49

solo tiene uno 00:34:49

que es el que acabo 00:34:50

de ejecutar 00:34:51

podría tener muchos 00:34:52

y si le dais 00:34:53

al botón verde 00:34:54

este directamente 00:34:55

el te ejecuta 00:34:56

el primero 00:34:58

que esté en el historial 00:34:59

vale 00:35:00

el primero que esté 00:35:01

en el historial 00:35:01

cuidado porque 00:35:02

vosotros sois de los que 00:35:03

dais a los botones 00:35:04

a veces 00:35:05

entonces veis un botón 00:35:05

verde 00:35:06

uy ejecuta 00:35:07

pero eso no significa que esté ejecutando 00:35:07

el que esté abierto, está ejecutando 00:35:09

el primero del historial que hay arriba 00:35:11

¿y qué historial hay arriba? 00:35:13

las últimas ejecuciones, o sea ejecuta 00:35:15

el último ejecutado, el que está abierto 00:35:17

¿vale? 00:35:19

entonces no deis al botón verde así a la 00:35:21

¿vale? 00:35:22

bueno pues entonces 00:35:26

se abre la consolita, esta de aquí 00:35:27

que se me ha abierto ahí 00:35:29

y sale el resultado que era 00:35:31

lo que podíamos esperar 00:35:33

¿vale? a lo que podíamos esperar 00:35:34

Aquí, antes de seguir con tipos de variables 00:35:37

Cuestiones varias 00:35:43

Para que nos vayamos familiarizando 00:35:45

Este programa sintácticamente ha estado perfecto 00:35:48

¿Por qué cosas podría habernos fallado? 00:35:53

Por ejemplo, porque yo aquí me he equivocado 00:35:57

Imaginaos que me he equivocado y he puesto dos As 00:35:59

O he empezado con mayúscula, por lo que fuera 00:36:01

¿Veis? 00:36:04

automáticamente 00:36:07

el eclipse cuando trata de hacer 00:36:10

esa compilación que hace él para ver si 00:36:12

sintácticamente es correcto e ir al código 00:36:14

intermedio, me dice 00:36:15

¡uh! aquí tienes un error 00:36:17

claro, porque la máquina 00:36:19

virtual dice, uy me estás dando un nombre de algo 00:36:22

voy a buscarlo en mi lista de variables 00:36:24

dice, yo no tengo ninguna variable 00:36:26

que se llame así 00:36:28

claro, porque distingue las mayúsculas 00:36:28

y las minúsculas, distingue 00:36:32

entonces, lo siento, yo no tengo ninguna 00:36:34

variable que se llame altura 00:36:36

con mayúscula. No puedo 00:36:37

hacer este programa, no puedo compilarlo 00:36:39

porque es incorrecto. 00:36:41

Aquí también, en este caso, la ayudita 00:36:43

esta roja que saca 00:36:46

nos es útil porque nos dice 00:36:47

altura no es una variable. 00:36:50

En este caso 00:36:53

ese mensajito nos 00:36:54

informa del verdadero problema. 00:36:55

En muchos otros casos no. 00:36:58

Nos diría cosas random muy raras. 00:37:00

¿Vale? 00:37:02

Bueno, pues error típico de compilación. 00:37:04

de compilación, que uno escriba un nombre de variable 00:37:05

que no existe 00:37:08

porque se ha equivocado escribiéndolo 00:37:09

o porque se ha olvidado de declararla 00:37:11

que puede ocurrir, vale 00:37:13

bueno, vamos a parar aquí un segundín 00:37:15

antes de seguir, vale 00:37:18

20260917 Variables_3 - Contenido educativo

Del mismo autor…

Clase 05-04-24 - 2

Clase 05-04-24 - 1

Clase 02-04-24 - 2

Clase 02-04-24 - 1

Clase 19-03-24 - 2

Clase 19-03-24 - 1

Clase 18-03-24 - 2