20260917 Variables_4 | Mediateca de EducaMadrid

estábamos diciendo cositas que podríamos haber puesto mal, ¿vale? 00:00:01

Pues el nombre de identificador, importante. 00:00:06

Cuando uno le dice, muéstrame por consola el contenido de algo, 00:00:09

ese algo tiene que existir y estar declarado previamente, ¿vale? 00:00:13

A ver, cosas también que podemos ir incorporando desde ahora. 00:00:18

Si tú le dices al system.outprint del n o a otra sentencia 00:00:23

desde que vayamos incorporando, 00:00:27

le dices altura así, a palo seco, 00:00:29

tal cual la hemos escrito, 00:00:33

él sabe que tiene que ir a buscar 00:00:34

una variable que se llame altura 00:00:36

para mostrar su contenido, 00:00:39

que es lo que hemos hecho hasta ahora, ¿verdad? 00:00:42

Eso está claro. 00:00:43

Pero, ¿y si yo quiero que por consola 00:00:45

me muestre directamente la palabra altura, tal cual? 00:00:47

O sea, no quiero que me muestre el contenido 00:00:52

de la variable que se llama altura, 00:00:54

Si no quiero que me muestre directamente 00:00:56

La palabra altura 00:00:59

Porque me apetece a mí que mi programa 00:01:01

Me muestre la palabra altura 00:01:03

Así de partida podríamos decir 00:01:04

Uy, tengo aquí una ambigüedad, una confusión 00:01:07

¿Cómo sé 00:01:09

Cuando referirme a la variable 00:01:11

Que se llama altura y por tanto 00:01:13

Su contenido 00:01:15

O cómo sé cuando me estoy 00:01:16

Refiriendo al texto literal 00:01:19

Altura 00:01:21

Que es el que yo quiero mostrar 00:01:22

Tiene que haber alguna forma de distinguir 00:01:24

tiene que haber alguna forma de distinguirlo 00:01:26

no puede ser que exista esa ambigüedad 00:01:28

si os ocurre o os suena 00:01:30

claro 00:01:32

si yo no pongo comillas 00:01:35

aquí no hay ninguna duda 00:01:36

me estoy refiriendo a una variable 00:01:38

que se llama altura 00:01:40

la busco y si está declarada 00:01:41

y tiene su valor 00:01:45

lo muestro 00:01:46

que yo quiero mostrar directamente 00:01:47

el texto altura 00:01:50

pues 00:01:51

lo tengo que poner 00:01:59

entre comillas dobles 00:02:04

vale 00:02:06

entre poner el 00:02:07

un segundín, entre poner el LN 00:02:12

y no ponerlo, esto significa 00:02:13

que una vez que lo ha mostrado 00:02:15

te va a saltar a línea siguiente 00:02:17

para que lo siguiente que muestres 00:02:19

lo haga debajo 00:02:21

y si no pones el LN 00:02:22

y pones el print a palo seco 00:02:26

pues lo siguiente que muestres 00:02:27

no te lo muestra en la siguiente línea 00:02:29

podéis usar las dos, la que os dé la gana 00:02:31

en función de si queréis que salte a la línea siguiente 00:02:33

para el siguiente sistema autónomo, ¿vale? 00:02:36

Dime. 00:02:38

Eso también se puede poner en barra invertida. 00:02:38

Sí, sí, sí. 00:02:42

Barra invertida N es el carácter salto de línea. 00:02:44

Si tú lo pones entre comillas doble, 00:02:46

le estás diciendo, muéstrame por pantalla un salto de línea. 00:02:48

¿Vale? 00:02:52

Pero bueno, en este caso es más cómodo 00:02:52

que tú uses por defecto el... 00:02:53

¿Vale? 00:02:55

Pues entonces, hay una diferencia... 00:02:57

Ay, perdona, dime. 00:02:59

Que cuando creas el marquete, 00:02:59

luego tienes que crear la clase, ¿no? 00:03:02

claro, creas el paquete 00:03:03

dentro del paquete new class 00:03:05

new class 00:03:06

vale, pues entonces, primera cosa 00:03:09

que ya también se nos queda en la cabeza 00:03:13

y no nos olvidamos 00:03:15

algo entre comillas dobles 00:03:16

es ese texto literal 00:03:18

eso es lo que se llama una cadena de texto 00:03:20

es ese texto literal, tal cual 00:03:23

sin las comillas 00:03:24

es una variable 00:03:26

que se llame así 00:03:29

¿vale? 00:03:30

Si yo ejecuto ahora este programa, si yo lo ejecuto ahora, pues me hace lo que preveía que me iba a hacer. 00:03:35

Primero me ha mostrado el texto literal altura, el texto literal, y luego me ha mostrado el contenido de la variable altura, ¿vale? 00:03:44

Y como veis, me lo ha mostrado una línea separada, porque este es el println, que significa, 00:03:54

Sáltame a la siguiente línea 00:04:01

Después de haber mostrado 00:04:02

Si yo no hubiera puesto 00:04:04

El LN 00:04:07

Me lo habría sacado todo seguido 00:04:08

¿Veis? 00:04:12

Me lo habría sacado todo seguido 00:04:16

System Print me muestra el texto altura 00:04:17

Al no tener el LN 00:04:20

No me ha saltado a la línea siguiente 00:04:22

Con lo cual el siguiente System Print 00:04:24

Que me muestra el 13 00:04:27

Me lo muestra completamente pegado 00:04:30

¿Vale? 00:04:32

Muy feo. 00:04:35

Con esto lo dejo más bonito, vale. 00:04:37

Bueno, esto es solo para que incorporemos ya esta sentencia para mostrar cosas. 00:04:41

Porque si no la tenemos desde ya, ¿cómo vemos el resultado de nuestros códigos? 00:04:45

No podemos verlo de ninguna manera porque no sabemos ni mandar a fichero, ni a bases de datos, ni nada. 00:04:49

Entonces nuestra única forma ahora mismo de ver el resultado de nuestros programas es la sentencia system.out.println. 00:04:55

¿por qué se escribe tan rara con estos 00:05:02

puntos y de esta manera? 00:05:05

de nuevo es algo que todavía no podemos entender 00:05:07

porque tiene estrictamente 00:05:09

que ver con la programación orientada a objetos 00:05:11

entonces ahora mismo 00:05:13

quedémonos 00:05:15

con que para mostrar por consola yo escribo 00:05:17

esto y se acabó 00:05:19

bueno 00:05:21

¿qué más cosas podría yo haber hecho 00:05:24

que me generaran un error 00:05:27

de compilación y que me dijera 00:05:29

el precompilador 00:05:31

Construí esto, esto no, esto no me lo trago. Pues imaginaos que a mí se me ha quedado el dedo ahí pegado en el 3. Esto es un número entero. ¿Por qué te quejas? ¿No? Dice, ¿por qué te quejas si es un número entero? ¿O es que este no es un número entero? Claro que lo es. 00:05:33

pero es muy grande 00:05:54

efectivamente, dice, sí, claro que es un número entero 00:05:55

pero perdona 00:05:58

yo tengo 32 bits 00:05:59

esto no cabe, 32 bits 00:06:01

lo siento, no puedo 00:06:03

guardarme ahí, pues por eso ha saltado 00:06:05

¿vale? 00:06:08

mensaje, esta vez tiene sentido 00:06:16

¿vale? o sea, las cosas que estamos 00:06:18

haciendo ahora, como son muy básicas 00:06:21

el compilador acierta 00:06:22

con las cosas que nos dice, tiene sentido 00:06:24

me dice, perdóname, pero esto 00:06:26

está fuera de los rangos 00:06:28

que yo puedo manejar con int, ¿vale? 00:06:31

Está fuera de los rangos, ¿vale? 00:06:33

Llegará un momento en que el rojo 00:06:45

desaparecerá. 00:06:47

Ahí era. 00:06:54

Este ya no. 00:06:56

Esto ya sí se puede codificar en 32 bits. 00:06:58

Esto sí, 00:07:02

por ejemplo. Este sí cabe 00:07:02

en 32 bits, ¿vale? 00:07:04

Tenemos que sabernos 00:07:09

de memoria, cuáles 00:07:10

son los valores máximos 00:07:12

que caben en un int, en un long 00:07:14

en un... hombre pues no hace falta 00:07:16

porque uno los puede consultar 00:07:18

rápidamente 00:07:20

¿vale? 00:07:21

hay una forma rápida de verlo aquí en java 00:07:24

pero bueno, no quiero ahora mezclar unas cosas con 00:07:26

otras, pero si vosotros 00:07:28

hacéis 2 elevado a 31 00:07:30

pues es el mayor número que 00:07:32

puedes hacer en 32 bits 00:07:34

porque claro, como uno de los bits es para el signo 00:07:35

con 32 bits, si 1 es para el signo 00:07:38

positivo o negativo 00:07:42

solo te valen para valor absoluto 00:07:43

los 31 restantes, con lo cual 00:07:45

2 elevado a 31 es lo más 00:07:47

que vas a poder codificar en 00:07:49

en un int 00:07:51

lo que de ese número 00:07:53

bueno 00:07:55

ahora mismo 00:07:57

que más errores nos podrían haber salido 00:08:00

que mal podríamos haber escrito aquí mal 00:08:01

pues hombre, por supuesto, imaginaos que yo 00:08:03

a altura voy y le digo 00:08:06

altura, esto 00:08:07

me dice, pero ¿qué le estás 00:08:10

asignando tu altura? 00:08:12

¿qué altura es int? que solo puedes 00:08:13

un número entero que quepa en 32 bits 00:08:16

¿esto qué es? 00:08:18

entonces cada vez que una sentencia 00:08:20

de asignación, tú intentes 00:08:22

asignar algo 00:08:24

que no es 00:08:25

lo que está capacitado para recibir 00:08:27

siempre te va a dar ese error 00:08:30

¿esto qué es? un texto literal 00:08:31

ya sabemos ahora 00:08:34

que algo entre comillas dobles es un texto tal cual literal. 00:08:35

Pues un texto literal no es un número. 00:08:40

No tiene ningún sentido que yo un texto literal lo ponga en una variable número. 00:08:42

Aquí solo puedo poner números. 00:08:47

Bueno, pues ahora sí, vamos a seguir viendo los tipos de datos ya para completar. 00:08:49

Hemos visto, vale, a ver un momentito. 00:09:04

vale 00:09:30

adiós 00:09:31

vale, pues entonces 00:09:38

¿qué más datos podemos necesitar 00:09:40

guardar nosotros? números enteros 00:09:44

siempre básico, números enteros siempre hay que guardar 00:09:46

ya sabemos cómo guardarlos 00:09:48

¿vale? lógicamente nos faltan 00:09:49

matices sobre muchas cosas, pero esos ya 00:09:52

irán apareciendo, lo básico para 00:09:54

guardar un número entero ya lo sabemos 00:09:56

vale, pero con los números enteros 00:09:57

no lo 00:10:00

Pero no lo tenemos todo resuelto. También usamos a menudo los números decimales, ¿verdad? Los números reales con coma de toda la vida. Bueno, pues ¿cuál es el tipo de dato para guardar números decimales? Tenemos dos posibilidades en realidad. Tenemos dos. 00:10:01

Una es el tipo float y otra es el tipo double, ¿vale? Ambos son para guardar números decimales. ¿En qué se diferencia uno de otro? 00:10:19

en la precisión 00:10:36

de la parte decimal 00:10:39

¿vale? el float 00:10:40

usa 32 bits 00:10:44

y una codificación 00:10:46

de punto flotante patatín 00:10:48

patatín 00:10:50

un tipo de codificación muy complicado 00:10:51

de entender, que ni vais a estudiar 00:10:54

en sistemas operativos ni nada 00:10:56

el dabble usa 64 bits 00:10:57

y una forma de codificar los decimales 00:10:59

¿en qué se traduce para nosotros? 00:11:02

que el dabble admite 00:11:05

mucha más precisión de decimales 00:11:06

un montón de 00:11:08

dígitos en la parte 00:11:09

decimal, entonces si necesitamos una precisión 00:11:12

más alta, el double 00:11:14

no necesitamos tanta precisión 00:11:15

el flow, y ya está 00:11:18

cualquiera de los dos se usa 00:11:19

con bastante 00:11:22

asiduidad 00:11:23

no es que haya uno que se use más que otro, tampoco 00:11:25

son los dos muy usados 00:11:27

la verdad es que 00:11:29

yo siempre uso double cuando 00:11:31

trabajo con números reales y bueno 00:11:34

es bastante habitual directamente usar 00:11:36

DAB, tiene más precisión 00:11:37

y ya está 00:11:39

y para completar los tipos de datos 00:11:40

antes de abrir el eclipse para hacer más ejemplos 00:11:43

¿qué más cosas puedo yo 00:11:47

almacenar en mis variables en RAM? 00:11:50

pues me permite 00:11:52

almacenar JAB 00:11:53

un único carácter también 00:11:54

un único carácter, punto pelota 00:11:58

en ese espacio en memoria que me hable 00:12:01

en la RAM 00:12:04

un único carácter 00:12:04

vale 00:12:09

entonces ese tipo para un único carácter 00:12:10

el A, el B 00:12:13

la interrogación, el carácter que sea 00:12:14

ese tipo es el tipo 00:12:16

char 00:12:19

vale 00:12:20

el tipo char vale, ahora lo vemos con 00:12:21

ejemplos porque igual es un poco más 00:12:26

confuso de entender a veces 00:12:28

para guardar un carácter 00:12:29

un carácter es cualquier cosa 00:12:32

que sea un carácter de los que escribimos 00:12:34

en un ordenador 00:12:36

C, B, el salto de línea 00:12:38

es un carácter también 00:12:41

la interrogación, el guión 00:12:42

todo eso son caracteres 00:12:44

pues yo puedo guardar 00:12:45

uno y solo uno 00:12:48

en las variables de tipo char 00:12:49

¿y falta algún tipo de dato? 00:12:51

pues sí, porque dijimos que eran ocho 00:12:56

y hemos visto siete 00:12:57

falta uno 00:13:00

que es el tipo boolean 00:13:02

Bueno, pues una variable de tipo Boolean 00:13:09

Solo puede guardarme dos posibles valores 00:13:15

Que son 00:13:20

¿Verdad o mentira? 00:13:22

Ya está 00:13:25

Lo que viene a ser 00:13:25

En inglés 00:13:27

True o false 00:13:30

Solo me puede guardar esas dos cosas 00:13:32

O una o la otra 00:13:37

No puede tener otra cosa diferente a true o false 00:13:38

Esa variable 00:13:41

no es como los números enteros 00:13:41

que pueden tener tropecientas cosas distintas 00:13:44

27, menos 12 00:13:47

14.000, pueden tener mil cosas diferentes 00:13:48

o no es como 00:13:51

la variable char, que puede tener un montón de cosas 00:13:53

a veces puede tener una A, a veces una C 00:13:55

a veces una J, esas posibilidades 00:13:56

no, el boolean 00:13:59

solo puede tener dos cosas 00:14:01

o tiene true o tiene false 00:14:03

ya está 00:14:05

para números 00:14:06

con parte de final 00:14:09

No, esos son números enteros 00:14:10

Claro, números enteros 00:14:14

¿Vale? 00:14:16

Números enteros 00:14:18

Vale, entonces 00:14:19

La variable boolean, como ya iremos viendo 00:14:22

Sirve para guardar 00:14:24

Lo que llamamos 00:14:28

Condiciones 00:14:30

Porque ¿qué es lo que puede ser verdad o mentira? 00:14:31

En el mundo 00:14:35

Las condiciones 00:14:35

Una condición 00:14:37

Solo tiene dos opciones. O se cumple o no se cumple. Las cosas no se cumplen a medias en informática y en programación. Una condición. Llueve. O llueve o no llueve. A medias no estamos. ¿Vale? Es martes. O es verdad o es mentira. Pero no estamos a medias. 00:14:39

O sea, las condiciones son cosas que o se cumplen o no se cumplen, no hay tutía, ¿vale? Eso es un portátil, ¿eso es verdad o es mentira? Depende, no sé, si es un portátil será verdad y si no lo es será mentira, ¿vale? Las condiciones, lo que llamamos condiciones, que todos sabemos lo que es una condición, un enunciado del tipo, mañana va a llover, esa pizarra es verde, tengo hambre, enunciados de ese tipo, se pueden o cumplir o no cumplir, ser verdad o ser mentira. 00:15:01

Luego una condición solo tiene dos posibilidades, ser verdad o ser mentira, punto pelota. Pues precisamente las variables boolean valen para guardar condiciones, porque las condiciones solo tienen dos posibilidades, o son verdad o son mentira. 00:15:30

y son muy útiles 00:15:47

porque en un programa 00:15:49

hay un montón de cosas 00:15:51

que se hacen en función de si una condición 00:15:53

se cumple o no se cumple 00:15:55

entonces el manejo de Boolean 00:15:57

es básico 00:15:59

porque las condiciones son básicas 00:16:00

en un programa 00:16:03

como iremos incorporando 00:16:04

lógicamente 00:16:07

ahora lo digo para que entendáis 00:16:08

por qué aparece eso, por qué aparece un tipo tan raro 00:16:11

para guardar verdad o mentira 00:16:13

¿por qué pinta guardar verdad o mentira? 00:16:15

para qué me interesa a mí guardar verdad o mentira 00:16:16

en una variable 00:16:19

pues me interesa porque verdad o mentira 00:16:19

son las dos posibilidades 00:16:22

que puede tener 00:16:24

en su interior una condición 00:16:26

o es verdad o es mentira 00:16:28

y como las condiciones son cosas 00:16:30

que usamos continuamente en nuestros 00:16:32

programas, pues guardemos 00:16:34

esas condiciones en variables boolean 00:16:36

que son las que pueden 00:16:38

tener dos valores 00:16:40

o te cumplas o no te cumplas 00:16:42

y ahí viene esa variable 00:16:43

Muy bien. Vale, pues ahora vamos a practicar un poco con ellas aquí para acabar de entenderlas. A ver, abrimos nuestro eclipse otra vez. Ahí. Vale. Vale, entonces variables enteras, pues un poquito su manejo. 00:16:45

Venga, pues ahora vamos a declarar, a ver, voy a poner aquí variables enteras, vale, variables decimales, vale, pues por ejemplo, declaro yo mi variable decimal, double, lo que, cualquier cosa, vale, double número, ya está, una declaración de variable perfectamente válida. 00:17:25

quiero asignarle un valor 00:18:09

la sentencia de asignación 00:18:12

ya sabemos exactamente como es 00:18:16

la variable en la que le quiero asignar 00:18:17

seguido del operador 00:18:20

de asignación 00:18:22

y el valor que yo quiera asignarle 00:18:22

el valor que yo quiera asignarle 00:18:25

valor compatible 00:18:27

con double 00:18:29

vale 00:18:31

esta asignación debe ser que es válida 00:18:34

porque el compilador 00:18:41

no se ha quejado, debe ser que es válida 00:18:44

¿Os parece que es válida? 00:18:46

Claro, y 65 no lo es 00:18:54

65,0 00:18:56

Todos los enteros son números decimales 00:18:57

Todos 00:19:01

Los números enteros son un subconjunto 00:19:01

De los números decimales 00:19:05

Entonces 00:19:06

Yo pongo 65 00:19:08

¿Y qué hace él? 00:19:10

Como ve que va a un double 00:19:13

En lugar de codificarlo como entero en binario 00:19:14

Lo codifica con su parte decimal 00:19:17

Siendo su parte decimal 00:19:20

coma cero, lo codifica como 00:19:21

dabel y dice, me has dado 00:19:23

65, como vas a un dabel 00:19:25

deduzco que es 65 coma cero 00:19:27

y te lo codifico como 00:19:29

decimal, con parte decimal coma cero 00:19:31

y te lo guardo aquí 00:19:33

luego esto es válido, ¿vale? lo que pasa es que 00:19:34

va a estar guardado 00:19:37

y codificado de una manera diferente 00:19:39

a cuando yo lo guardaba en altura 00:19:41

es decir, si yo hago esto 00:19:43

altura que era entero 00:19:45

en estas dos sentencias 00:19:47

en ambas 00:19:53

se ha guardado en la variable correspondiente 00:19:54

el 65 00:19:57

y ya está 00:19:58

pero en la de arriba el 65 00:20:00

se ha codificado en decimal 00:20:03

con el coma cero 00:20:04

y en el de abajo se ha codificado en binario 00:20:07

como entero 00:20:09

pero eso nos importa nada 00:20:10

que más nos da como lo codifique 00:20:13

él internamente 00:20:15

nos da igual, a nosotros nos importa 00:20:16

que en número está el 65 00:20:18

y en altura está el 65 00:20:20

¿vale? 00:20:22

internamente está codificado distinto 00:20:23

porque esta está en dabel y esta está en in 00:20:26

pero eso a los dos nos da un poco igual 00:20:28

vamos a mostrar ahora 00:20:30

las dos variables estas 00:20:33

voy a mostrar primero altura 00:20:35

y voy a mostrar luego 00:20:40

número 00:20:44

si 00:20:46

eso es un aviso, significa que la 00:20:55

en cuanto a que la variable todavía no la has usado 00:20:56

las 00:20:59

los subrayados amarillos 00:21:01

son como sugerencias de que 00:21:04

sintácticamente esté bien 00:21:06

pero no acabo de ver yo la utilidad 00:21:08

de esto, entonces te salía porque todavía 00:21:10

no habías usado la variable y te decía 00:21:12

creas una variable en cuanto la hayas usado 00:21:13

te desaparece el amarillo 00:21:16

¿vale? entonces 00:21:18

vamos a ejecutar 00:21:22

este programa ahora 00:21:24

nos debería mostrar 2.65 00:21:25

¿verdad? vamos a ejecutarlo 00:21:28

espera, voy a poner el n aquí 00:21:30

que si no queda muy mezclado 00:21:33

¿vale? 00:21:35

pues sí 00:21:41

me ha mostrado dos 65 00:21:42

pero fijaos lo que ha hecho 00:21:45

en el system.println altura 00:21:46

que es entero 00:21:49

me ha mostrado el 65 00:21:51

porque tiene un entero 65 00:21:53

sin embargo, cuando yo he mostrado 00:21:54

número, como número 00:21:57

lo ha guardado con su parte 00:21:59

decimal, porque lo ha guardado en double 00:22:01

y double tiene su parte decimal 00:22:03

pues lo ha guardado como 65,0 00:22:05

porque en los DABEL y en los LOAD 00:22:07

existe la parte decimal 00:22:10

entonces cuando yo lo he mostrado 00:22:12

ahora ya me ha mostrado el 65,0 00:22:15

porque lo ha guardado como decimal 00:22:18

con su parte decimal 00:22:20

¿vale? 00:22:21

pero bueno, efectos prácticos de operar 00:22:23

van a ser los números iguales 00:22:25

lógicamente 00:22:27

65,0 00:22:28

que yo quiero poner un número con parte decimal 00:22:30

Pues se lo pongo tranquilamente 00:22:37

Número igual a 75, y la coma famosa es punto 00:22:42

En nuestro caso 00:22:50

¿Vale? Cuando yo quiero ya especificar una parte decimal 00:22:52

Para un double o para un float 00:22:58

¿Vale? 00:23:00

Pongo el punto, lo pongo como 00:23:05

¿Vale? 00:23:06

bueno pues aquí esta es una asignación 00:23:08

que va, encaja en double perfectamente 00:23:11

lógicamente este numerito 00:23:13

en altura no encajaría 00:23:20

esto ya si que no 00:23:22

normal 00:23:30

el compilador me dice 00:23:31

esto es un número con parte decimal 00:23:33

yo no puedo guardar 00:23:36

en una variable que has declarado de tipo entero 00:23:38

algo que no sea 00:23:40

un número entero 00:23:42

porque no puedo, porque yo solo guardo 00:23:43

números enteros, este es un número 00:23:46

con parte decimal 00:23:48

no puede ir en altura 00:23:49

¿vale? ahí sí que se queja el compilador 00:23:51

como debe ser 00:23:54

aquí sin embargo 00:23:56

no se ha quejado 00:23:58

porque 65 00:23:59

es un entero pero 00:24:01

también es un decimal, porque 65 00:24:04

también se puede ver 00:24:06

como 65,0 00:24:08

también vale 00:24:10

entonces cuando a un double le asignas 00:24:10

un int, a un decimal 00:24:13

le asignas un entero, no hay ningún problema 00:24:15

la máquina virtual hace 00:24:17

lo que se llama 00:24:21

pero bueno, tampoco quiero olvidaros ahora con tecnología 00:24:22

la promoción automática 00:24:25

que es, me has dado 00:24:26

65 para guardar en un decimal 00:24:28

no tengo ningún problema 00:24:31

lo voy a guardar en un decimal 00:24:33

y me invento yo el coma cero 00:24:34

porque el coma cero no te molesta a ti para nada 00:24:37

ese coma cero 00:24:39

pero lo contrario no lo hace 00:24:40

porque le quitaría información 00:24:42

lo contrario, tú le das un decimal 00:24:45

para que lo guarden un entero 00:24:47

podría 00:24:49

Java haberse inventado que dijera 00:24:51

pues me como la parte decimal 00:24:53

y guardo el segundo 54 00:24:56

podría inventárselo 00:24:58

pero es que sería ya quitar 00:25:00

la información que tú has dado 00:25:01

a ti te puede importar mucho ese coma 8 00:25:03

no me lo quites 00:25:05

entonces, número entero a variable decimal 00:25:06

ningún problema 00:25:10

porque 00:25:11

el programa, la máquina virtual 00:25:12

te añade el coma cero directamente 00:25:15

número decimal 00:25:17

a variable entera, no puedes 00:25:19

porque tendría 00:25:21

que cargarse información 00:25:23

que es la parte decimal y eso no lo va a hacer 00:25:25

¿vale? 00:25:27

vale 00:25:33

esto lógicamente no se puede 00:25:34

a ver 00:25:39

boolean antes de ir a char 00:25:50

¿vale? 00:25:53

veremos más ejemplos 00:25:54

lógicamente de enteros, double, float 00:25:56

esto es un poquito para tener un vistazo 00:25:58

por encima de los tipos de variables 00:26:00

yo quiero una variable boolean 00:26:01

por ejemplo, pues venga 00:26:05

llueve 00:26:07

vale, perfectamente declarada 00:26:10

las variables boolean 00:26:12

como todas las variables 00:26:14

si tienen que tener nombres que expliquen 00:26:15

lo que contienen 00:26:18

pues es un nombre muy típico de una variable boolean 00:26:19

expresa una condición 00:26:22

expresa que llueve 00:26:23

¿Vale? Como los nombres habituales de las variables boolean, la condición que expresa. 00:26:24

Terminado, es azul, amarillo, condiciones que pueden ser verdad o mentira. 00:26:29

Vale, pues mi variable boolean ahí perfectamente. 00:26:35

¿Qué ocurre? Que a mi variable boolean yo solo le puedo asignar dos posibles valores, que son verdad o mentira. 00:26:39

¿Y cómo expreso esos dos posibles valores? 00:26:49

Pues los expreso con estas dos palabras reservadas. 00:26:53

Solo admite estas asignaciones, o true o false. 00:27:06

O algo que se evalúe como true o false, pero bueno, eso ya lo veremos. 00:27:11

Ya está, no puedo tener otra cosa. 00:27:15

No puedo darle un número, no puedo darle otra cosa. 00:27:17

O true o false. 00:27:19

O algo equivalente a true o false, como ya veremos. 00:27:21

No tienen más misterio. 00:27:28

Y ahora, por último, para este vistazo así muy global de tipos de variables, la variable char. 00:27:29

¿Qué puede tener la variable char? Un único carácter, nada más. Solo puede tener un carácter. 00:27:50

Entonces, vamos a hacerle asignaciones válidas. 00:28:03

Aquí se me ha puesto rojo cuando yo he intentado hacer esta asignación. 00:28:11

¿Por qué se os ocurre que se me ha puesto en rojo? 00:28:17

se me ha puesto en rojo porque 00:28:19

como yo he dicho antes 00:28:22

cuando tú escribes algo 00:28:24

en la asignación 00:28:26

sin entre comillas y sin nada 00:28:29

la máquina virtual 00:28:30

siempre va a entender 00:28:32

que es una variable que existe 00:28:34

entonces dice A 00:28:36

B, está aquí escrito 00:28:38

pues debe ser que hay alguna variable que se llama B 00:28:40

¿vale? 00:28:42

igual que aquí, cuando yo he escrito altura 00:28:44

él ha dicho A 00:28:46

va a ser que hay una variable que se llame altura 00:28:47

o A va a ser que hay una variable que se llama número 00:28:49

¿vale? 00:28:52

entonces dice A pues va a ser que hay una variable 00:28:54

que se llama B 00:28:56

va hacia arriba y dice 00:28:56

no hay ninguna variable declarada que se llame B 00:28:58

ninguna 00:29:01

claro, es que nosotros no queríamos eso 00:29:02

nos hemos equivocado escribiendo 00:29:06

lo que nosotros queríamos era 00:29:07

asignar directamente 00:29:09

el carácter literal tal cual B 00:29:11

era lo que queríamos asignar 00:29:14

El carácter literal tal cual, no una variable que se llame B. 00:29:16

Entonces, ¿qué poníamos cuando queremos asignar algo que sea literal eso, ese texto, y no una variable que sea B? 00:29:21

Poníamos comillas, dobles, pero no, porque ponemos comillas dobles cuando son muchos caracteres, cuando es un texto. 00:29:31

Cuando es un único carácter, comillas simple. 00:29:41

si ponéis comillas dobles 00:29:44

de hecho se va a quejar 00:29:47

vale 00:29:48

comilla 00:29:50

simple, la comilla está vertical 00:29:53

simple, ahora sí 00:29:55

entonces 00:29:57

cuando yo quiero expresar un char 00:30:13

es decir, un único carácter 00:30:16

un char, tiene que ser siempre 00:30:18

con la comilla simple 00:30:20

el texto entre comillas dobles 00:30:21

es otra cosa distinta 00:30:31

el texto entre comillas dobles 00:30:33

es una cosa que se llama string, cadena 00:30:35

que 00:30:37

ahora mismo todavía no la vamos a ver porque 00:30:37

es un tipo objeto, no es un tipo 00:30:41

primitivo, ¿vale? 00:30:43

Ahora mismo quedémonos en este repaso 00:30:44

por encima de que el char 00:30:47

es un carácter único 00:30:48

entrecomillado 00:30:51

entre las comillas simples y me vale cualquiera 00:30:51

Pues si lo has 00:30:55

escrito bien 00:31:04

no se te tendría que 00:31:05

seguir quejando 00:31:08

puedes tener algo anidado 00:31:09

por arriba, abajo, cualquier carácter. 00:31:12

Vale, pues 00:31:20

estos que hemos mencionado 00:31:21

entonces, 00:31:23

estos tipos que hemos mencionado con 00:31:25

unos ejemplos muy, muy, muy 00:31:27

básicos de asignación, 00:31:29

estos son los tipos 00:31:31

de Java, 00:31:33

los tipos que 00:31:35

se llaman primitivos, 00:31:37

que son 8 00:31:40

los que hemos dicho. 00:31:46

Short, el byte se me ha escapado. 00:31:50

short, byte, long 00:31:52

bueno, los he puesto en otro orden pero da igual 00:31:55

int 00:31:56

double 00:31:58

char 00:32:02

y boolean 00:32:04

ya está, son los tipos primitivos 00:32:09

no hay más 00:32:12

y me diréis, Jolín, pues sí que vamos 00:32:13

escasos, solamente puedo 00:32:16

guardar ese tipo de datos 00:32:18

pues en tipos primitivos sí 00:32:20

que son los únicos que hay 00:32:24

Pero, ¿y si yo quiero guardar, por ejemplo, un nombre? Un nombre es Álvaro González. Álvaro González es un nombre, no es un único chat, son muchos caracteres. Ni es un número tampoco, ni es un boolean. 00:32:25

y es un dato muy natural 00:32:46

en un lenguaje, en un programa 00:32:48

trabajar con cadenas, con nombres de cosas 00:32:50

con nombres de alumnos 00:32:53

pues ahí tengo un problema 00:32:54

con estos tipos primitivos 00:32:56

y si mi aplicación es una aplicación que trabaja 00:32:58

con facturas 00:33:01

y yo necesito guardar 00:33:02

pues 00:33:05

la cantidad 00:33:05

de la factura, los ítems 00:33:09

que son un montón de cosas 00:33:11

¿qué hago? es que eso no me cabe 00:33:13

aquí, si es que solamente puedo guardar 00:33:15

un número suelto 00:33:17

entero, decimal, un char 00:33:18

suelto y un true o false, es lo único que puedo 00:33:21

guardar, ¿qué hago entonces para hacer 00:33:23

programas en los que necesito datos más complejos? 00:33:25

pues 00:33:30

tendríamos que 00:33:30

construir, que no podemos hacerlo 00:33:33

todavía, pero lo digo 00:33:35

para que sepáis que lógicamente hay soluciones 00:33:36

de almacenamiento más allá de estos 00:33:39

tipos primitivos, porque si no estaríamos 00:33:41

bien escasitos 00:33:42

pues tendríamos que construir nosotros 00:33:44

y crear y declarar nosotros por código 00:33:47

una cosa que se llaman 00:33:50

los tipos objeto 00:33:52

que ahora mismo solamente 00:33:54

lo digo pues por complejitud 00:33:59

ahora no lo vamos a ver 00:34:01

obviamente 00:34:02

entonces los 00:34:03

tenemos los tipos primitivos 00:34:06

estos que hemos visto 00:34:08

que ya sabemos por encima como funciona 00:34:10

y los tipos objeto 00:34:12

y que son los tipos objeto 00:34:15

tipos que se hacen 00:34:16

A mano y se construyen 00:34:18

Combinando los primitivos 00:34:21

Para tener un tipo más complejo 00:34:22

¿Vale? 00:34:24

Que yo necesito 00:34:26

Guardar información 00:34:27

En la que necesito 00:34:29

Un montón de char y dos números 00:34:31

Pues me construyo 00:34:33

Un tipo objeto que tiene dentro 00:34:35

Un montón de char y dos números 00:34:37

Y le doy un nombre, mi tipo nuevo 00:34:38

Ya tengo un tipo para guardar 00:34:40

Unos datos más complejos 00:34:43

Pero bueno, ahora solo lo menciono 00:34:44

y ya lo veremos más adelante 00:34:47

vale, ahora mismo nos importa 00:34:50

trabajar y manejar 00:34:51

los tipos primitivos y ya está 00:34:53

vale 00:34:56

pues vamos a parar aquí 00:34:59

en lugar de cuando suene el timbre, para que no se haga 00:35:04

demasiado largo 00:35:07

antes de seguir con lo que os iba a contar 00:35:08

20260917 Variables_4 - 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