Saltar navegación

20250917-ProgEstr-Variables_2 - 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 21 de septiembre de 2025 por Raquel G.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues el miércoles habíamos empezado la programación estructurada con los conceptos básicos. 00:00:00
Primero, pues, ¿qué es la programación estructurada? 00:00:09
La que se basa solamente en combinar en secuencia asignación de lectura y salida de datos, decisiones y bucles. 00:00:12
Ya está, ¿vale? 00:00:21
Y más o menos podemos intuir un poquito de qué van las sentencias de decisión y las de bucle. 00:00:22
Pero bueno, esa es un poquito más adelante, ¿no? Entonces, ya en la parte de lo relacionado con mover los datos, que también lo hacen los programas estructurados, sacar datos para que yo vea los resultados y meter datos, ahí entraba el concepto de variable, ¿verdad? 00:00:29
y ya dijimos que una variable es un espacio en memoria RAM 00:00:45
un espacio en memoria RAM para guardar un dato 00:00:56
y ese espacio en memoria RAM recibe un nombre 00:00:59
lógicamente para que el programa lo identifique 00:01:02
bueno, entendido que es fundamental la existencia de variables 00:01:04
en cualquier lenguaje de programación 00:01:09
en cualquier programa 00:01:10
porque es la única manera en la cual un programa 00:01:12
puede recibir datos y sacar datos 00:01:18
a través de variables, entiende la importancia 00:01:20
pues ya dimos, venga, vamos a ver en Java 00:01:22
en Java en particular 00:01:24
cómo hago yo 00:01:28
qué sentencias, de qué sentencias dispongo 00:01:30
para crear variables 00:01:32
porque eso es lo primero que hacemos 00:01:34
¿verdad? yo ya he 00:01:37
me han dado un enunciado, lo he analizado, lo he leído 00:01:38
he visto más o menos lo que tengo 00:01:41
que hacer, me he hecho un primer diseño, ah vale 00:01:42
primero pide números, cuando tengas 00:01:44
los números ya guardaditos en variables 00:01:46
hace estas operaciones, ahora no sé qué 00:01:48
cuando yo tengo ya un primer diseño de lo que tengo que hacer 00:01:51
y ya arranco 00:01:53
lo primero normalmente será 00:01:54
crear las variables 00:01:57
que van a recibir los datos, eso será lo primero 00:01:59
crear las variables, yo ya he identificado 00:02:00
que necesito, necesito dos, necesito tres 00:02:03
vale, una vez lo he identificado 00:02:05
y ya me pongo a teclear 00:02:06
código, ya me pongo a teclearlo 00:02:09
pues lo primero será, venga vamos a 00:02:11
crear las variables, vale pues 00:02:13
como se hace la creación de variables 00:02:15
en Java, que es lo que se llama 00:02:17
declaración de variables. 00:02:19
La declaración de variables 00:02:27
que viene a ser crear la variable, 00:02:28
hacer que aparezca en RAM, 00:02:31
hacer que aparezca. 00:02:33
Dijimos, primero, 00:02:34
selecciono su nombre. 00:02:37
Nombre lo más explicativo posible 00:02:39
para que el programa sea elegible 00:02:41
para otra persona que no sea 00:02:43
el que lo ha hecho. Nombre lo más explicativo. 00:02:45
Edad, nombre, contraseña, 00:02:47
lo que sea, por ejemplo 00:02:49
vamos a leer un número 00:02:51
pues bueno 00:02:52
pues por ejemplo el nombre de mi variable 00:02:54
número, vale, muy bien 00:03:00
pero en Java 00:03:01
al ser un lenguaje de los que se llama 00:03:03
tipado 00:03:05
Java es un lenguaje tipado 00:03:06
a diferencia de Python por ejemplo 00:03:09
y de algunos otros 00:03:11
al ser un lenguaje 00:03:12
tipado 00:03:15
me obliga en el momento en el que 00:03:16
creo la variable 00:03:19
importante, creo, su espacio en memoria 00:03:20
me obliga a decir 00:03:23
qué tipo de dato va a haber ahí 00:03:25
me obliga a decir 00:03:27
vale, ¿dónde pongo yo el tipo de dato 00:03:28
que va a haber ahí en este espacio? 00:03:31
lo tengo que poner antes 00:03:33
ahora estoy, esto es código, esto es lo que teclaría 00:03:34
directamente, entonces aquí 00:03:37
antes 00:03:39
tengo que poner 00:03:41
el tipo de dato 00:03:43
que va a contener esa variable 00:03:45
si va a contener números, caracteres 00:03:47
qué va a contener, el tipo de dato. 00:03:50
¿Por qué es importante 00:03:53
especificar el tipo de dato que va a contener? 00:03:55
Porque así, cuando la máquina 00:03:58
virtual se pone a ejecutar esto y dice 00:03:59
ah, ¿qué quieres crear? Una variable, número. 00:04:01
Vale, si me dices el tipo 00:04:04
te creo un espacio 00:04:05
adaptado a lo que 00:04:07
ocupa en memoria ese tipo de datos. 00:04:09
Eso no es lo de la caja. 00:04:12
Sí, sí, sí. 00:04:14
La variable es espacio y memoria es la caja. 00:04:15
Inicialmente yo dije 00:04:18
una caja para meter datos. 00:04:19
Pero esa caja, ¿dónde está? 00:04:20
En la memoria RAM, ¿vale? 00:04:22
En la memoria RAM, vale 00:04:24
Entonces, si a la máquina virtual 00:04:25
Le decimos, oye 00:04:29
Créame una caja o espacio 00:04:30
En memoria RAM para un dato 00:04:33
Y que se llame 00:04:35
Número, entonces 00:04:37
Él te va a crear un espacio 00:04:38
Y le va a asociar internamente 00:04:40
Le va a asociar un nombrecito 00:04:43
Por ejemplo, número 00:04:44
Se lo va a asociar, vale 00:04:46
Luego ya el dato, lógicamente 00:04:48
será el que sea, eso ya cuando el programa 00:04:50
funcione, meterá ahí lo que quiere 00:04:52
y lo cambiará cuando le dé la mano 00:04:54
pero el nombre con el que el programa 00:04:56
se va a poder referir a este espacio 00:04:58
ya está fijado 00:05:00
y es este inamovible, eso ya no se cambia 00:05:02
¿vale? 00:05:04
bueno, pues si a la máquina virtual 00:05:06
en el mismo momento de decirle 00:05:07
oye, créame el espacio 00:05:10
para un dato y vamos a llamarle 00:05:11
número para entendernos 00:05:14
si en ese mismo momento le decimos el tipo de 00:05:15
dato que va a haber, si va a haber un número 00:05:18
entero, si va a haber un número con muchos decimales 00:05:20
si va a haber una cadena, si yo se lo digo 00:05:22
pues él ya crea 00:05:24
un espacio 00:05:26
con un tamaño 00:05:27
adaptado a ese tipo de datos 00:05:29
porque no necesitan los mismos bits 00:05:31
un número entero con un número decimal 00:05:34
por ejemplo, ¿vale? no lo necesitan 00:05:35
entonces, esa es la 00:05:37
ventaja de los lenguajes 00:05:40
tipados que se llaman, que son los lenguajes 00:05:41
que te obligan 00:05:44
a especificar el tipo de 00:05:45
dato en el momento en el que creas la variable, ¿vale? Y eso es lo que hace Java. El tipo 00:05:48
de dato cuando se crea la variable, ¿vale? Se crea la variable. Vale, yo muchas de las 00:06:10
cosas que digo, y voy a decir muchas, debería añadir siempre en letra pequeña con matices. 00:06:38
Porque todo tiene sus matices que todavía no puedo matizar porque nos falta mucha información 00:06:46
y porque no podemos meterlo todo de golpe 00:06:52
a mogollón 00:06:55
entonces esto 00:06:55
tiene sus matices 00:06:58
porque versiones más recientes de Java 00:07:00
pues permiten que tú 00:07:03
declares una variable 00:07:05
y no pongas todavía el tipo 00:07:06
sino que pongas una cosa 00:07:09
y lo dejes abierto 00:07:10
y luego ya cuando la usas la primera vez 00:07:12
defines el tipo 00:07:15
pero eso es una incorporación, una tonterita 00:07:16
que ni nos afecta 00:07:19
Y ahora mismo no tenemos en cuenta lo que ahora tenemos que tener claro 00:07:20
es que tenemos que especificar el tipo de dato cuando creo la variable, ¿vale? 00:07:31
Por estas razones. 00:07:37
Y la razón no es solo que los lenguajes tipados al obligarte optimizan el uso de la memoria, 00:07:38
porque te crean espacios adaptados al tipo de dato que tú vas a usar. 00:07:44
no solo la optimizan, la memoria 00:07:48
sino que además 00:07:50
hacen que el programa 00:07:52
sea más robusto, falle menos 00:07:54
¿por qué? porque si tú 00:07:56
desde el principio cortas 00:07:59
mucho las libertades 00:08:00
y dices, en la variable número solo puede haber 00:08:02
un número, obligadísimo 00:08:04
porque me has dicho que es un número 00:08:06
lo siento pero te voy a dar error 00:08:07
de compilación una vez tras otra 00:08:10
una vez tras otra, error de compilación 00:08:12
como te empeñes en meter cosas que no son números 00:08:14
es un lenguaje tipado 00:08:16
corta las libertades 00:08:18
y convierte al compilador 00:08:20
ahí en un 00:08:22
en un jefe 00:08:24
que te dice 00:08:27
perdona, número me has dicho que es entero 00:08:28
ahora vemos como decirlo 00:08:30
como me metas algo que no sea entero 00:08:31
es que no puede seguir 00:08:34
error de compilación 00:08:36
entonces al cortar las libertades que ocurre 00:08:37
que el programa 00:08:39
satisface un montonazo de reglas 00:08:40
y ya cuando se ejecuta 00:08:44
es muy difícil que de errores 00:08:45
porque lo tienes todo hiper mega controlado 00:08:47
porque el compilador ya te ha hecho 00:08:48
pasar revista antes 00:08:51
¿vale? 00:08:53
pero a cambio 00:08:55
el tiempo de desarrollo 00:08:57
es muy pesado, porque si 00:08:59
utilizas que una variable tiene que ser número 00:09:01
entero, solamente 00:09:03
puedes meter un número entero, tienes muy poca libertad 00:09:04
hay otros lenguajes 00:09:07
de programación como Python 00:09:09
que son lo contrario 00:09:10
que es 00:09:13
cuando tú crees una variable 00:09:14
no digas qué tipo de dato vas a meter en ella 00:09:16
y luego mete lo que te dé la gana 00:09:19
es decir, errores de compilación en Python 00:09:20
son muy pocos, porque ahí cabe 00:09:22
todo, cabe todo, pero claro 00:09:24
cuantas más libertades tienes 00:09:26
más cuidadoso tienes que ser 00:09:28
porque como nadie 00:09:31
te lo va a prohibir, luego a la hora de ejecutar 00:09:33
la pues caga 00:09:35
¿vale? entonces ese es un compromiso 00:09:35
en general en el desarrollo 00:09:39
y en otras disciplinas 00:09:40
técnicas, el compromiso entre 00:09:41
cuánta libertad te dejo 00:09:45
en bases de datos básicos 00:09:47
también, si yo dejo mucha libertad 00:09:48
al desarrollador 00:09:51
su escritura de código va a ser súper ágil 00:09:52
porque como le permito cualquier cosa 00:09:55
pero luego el programa es muy probable 00:09:57
que te dé errores de ejecución 00:09:59
porque no te has dado cuenta, porque como yo 00:10:01
desde la fase de compilación te he dejado hacerlo todo 00:10:02
y ese es un extremo 00:10:05
y el otro extremo, perdona 00:10:07
mi lenguaje de programación 00:10:09
te pone muchas reglas 00:10:10
muchas, va a ser un rollo 00:10:12
la escritura del código, porque te ponen muchas 00:10:15
pero si las satisfaces todas 00:10:17
vas a encontrarte muchos 00:10:18
menos errores luego de ejecución que tengas que 00:10:21
solucionar, porque ya te has pegado 00:10:23
antes, te has pegado antes 00:10:25
eso pasa en bases de datos 00:10:26
las bases de datos relacionales 00:10:28
¿por qué, aunque tienen 00:10:31
200.000 años 00:10:33
no hay manera de sacarlas del mercado? 00:10:34
porque te quitan 00:10:38
todas las libertades del mundo 00:10:39
cuando uno diseña las tablas 00:10:40
tiene que cumplir mil restricciones 00:10:42
de claves primarias 00:10:44
de no sé qué 00:10:46
entonces ¿qué ocurre? que son muy robustas 00:10:47
es muy difícil que una aplicación 00:10:50
que va contra una base de datos 00:10:52
que funciona usando 00:10:54
una base de datos relacional falle 00:10:56
porque la base de datos ha satisfecho 00:10:58
tantas restricciones que es que 00:11:00
es muy robusta 00:11:01
pero claro, a cambio el diseñador de la base de datos 00:11:03
pues te... 00:11:05
bueno, pues entonces 00:11:06
Esto venía a cuento 00:11:10
De que como Java es tipado nos obliga a especificar el tipo 00:11:12
Pues Java nos tiene que decir 00:11:15
¿Cuántos tipos tenemos para elegir? 00:11:17
¿Cuántos tipos tenemos para elegir? 00:11:19
Pues ahí, 4, 5, 6, 7 00:11:22
¿Vale? 8, ¿y cuáles son? 00:11:24
8 si los he contado bien, si no lo vamos a contar ahora 00:11:30
¿De tipo numérico? 00:11:32
No, no, no, tipos primitivos 00:11:34
Sí, entonces vamos a 00:11:36
Empezar, primero 00:11:37
Esencialmente, números 00:11:39
Caracteres 00:11:42
Y booleanos 00:11:43
Ahora lo decimos 00:11:45
¿Qué tipos de datos me ofrece Java? 00:11:47
A ver, para que quede aquí más claro 00:11:51
Ahora lo... 00:11:53
Tipos de datos en Java 00:12:11
¿Vale? 00:12:13
Ahora vamos a añadir la coletilla de primitivos 00:12:17
Cuando ahora ya entendamos qué significa 00:12:19
¿Sería lo mismo decir tipos de booleanos? 00:12:20
Sí, sí, sí 00:12:23
O sea, tipos de... 00:12:24
Sí, si te entiendes mejor así. 00:12:26
Vale, pues a ver, esencialmente son números, caracteres o booleanos, 00:12:30
ahora veremos que son booleanos. 00:12:33
Pero son números enteros. 00:12:36
Ahora veremos qué posibilidades tenemos. 00:12:41
Números enteros. 00:12:43
Todos sabemos lo que es un número entero. 00:12:45
¿Vale? 00:12:48
Números enteros. 00:12:53
Números decimales. 00:12:55
Caracteres. 00:13:04
¿Y booleanos? 00:13:08
No, no, no. 00:13:14
Es que cada uno de ellos engloba otro. 00:13:14
O sea, estoy poniendo los cuatro conjuntos 00:13:17
de tipos. Ahora los especificamos. 00:13:19
Vale, entonces. 00:13:23
Estos son cuatro, 00:13:26
las cuatro posibilidades, pero cada una 00:13:28
de ellas tiene subconjuntos. 00:13:30
Entonces, en general, todavía no he dicho 00:13:32
tipo de acto específico. En general, podemos tener 00:13:34
números enteros, 00:13:36
decimales, caracteres o booleanos. 00:13:38
En general. Ahora especificamos 00:13:41
un poco más que es booleano, cuando lleguemos a ahí. 00:13:42
Y no hay 00:13:45
más cosas con las que pueda trabajar el programa. 00:13:46
No hay nada, solo puede trabajar con eso. 00:13:49
Si tú quieres trabajar con algo 00:13:51
un poco más complicado, como, perdona, pero es que 00:13:52
mi aplicación no trata 00:13:54
de numeritos o trata de caracteres. 00:13:56
Mi aplicación trata 00:13:58
de alumnos de mi instituto. 00:14:00
Y mi alumno no es 00:14:02
ni un número, ni un carácter, 00:14:04
ni un booleano. ¿Qué hago? 00:14:07
No pasa nada. Java 00:14:08
construye tipos 00:14:10
complejos montados 00:14:12
sobre estos 00:14:15
que se llaman tipos objetos. 00:14:16
Por eso ya, por la parte de la ciencia de la ciencia. 00:14:19
Pero están montados sobre esto. 00:14:21
Uno de esos tipos objetos 00:14:23
complejos, si uno entra adentro 00:14:24
a ver lo que tiene, solo puede tener 00:14:27
o números o caracteres 00:14:29
o booleanos, ya está, porque eso es lo único 00:14:31
que hay por debajo de los datos. 00:14:33
No hay nada más. 00:14:34
Cualquier cosa que queramos representar, 00:14:37
pues mi aplicación 00:14:40
trabaja con facturas. 00:14:40
pues vale, y tu factura tendrá 00:14:42
muchas características, pero todas ellas 00:14:45
tienes que ser capaz de representarla 00:14:48
o con números o con caracteres 00:14:50
o con booleanos, no hay más 00:14:52
bueno, pues entonces 00:14:53
ahora esto como se traduce en lenguaje Java 00:14:55
pues para números enteros 00:14:58
hay cuatro posibilidades 00:15:03
que mi número 00:15:05
con el que yo voy a trabajar sea muy pequeñito 00:15:06
que me quepa en 8 bits 00:15:08
que sea como mucho 00:15:09
de menos 127 a 127. 00:15:12
El código binario, el contorno. 00:15:15
Vale, pues si es un número entero, 00:15:17
muy pequeñito. 00:15:18
Dime. 00:15:20
¿VAR entraría como un número complejo? 00:15:22
¿V-A-R? 00:15:25
No, VAR es una especie de la variable 00:15:26
que se queda abierta, la crearé cuando 00:15:28
me la uses por primera vez. 00:15:30
No es un tipo de dato. 00:15:31
No, no, no es un tipo de dato ni es nada. 00:15:33
VAR es otro concepto que no, 00:15:35
olvídalo por ahora. 00:15:37
Vale, entonces, byte, eso ya es byte, 00:15:38
ya sí que es un término de datos. 00:15:40
bytes significa un número entero 00:15:41
que cabe en 8 bits 00:15:44
entonces si mi programa 00:15:45
va a usar numeritos comprendidos 00:15:51
entre menos 127 00:15:53
y 127 aproximadamente 00:15:54
que es lo que cabe en 8 bits 00:15:57
con el complemento negativo 00:15:58
complemento a 1, complemento a 2 00:16:00
pues ya está, es un byte 00:16:02
que yo voy a usar 00:16:04
números un poquito más grandes 00:16:07
que necesito hasta 16 bits 00:16:08
para representarlos, hasta 16 00:16:10
Pues hay otro tipo de dato que es el tipo de dato short 00:16:12
Y ahí me reserva hasta 16 bits 00:16:16
Normalmente el tipo byte y short no lo solemos usar 00:16:22
Porque cuando uno trabaja con números 00:16:31
Pues suele necesitar números más grandes que los que caben en 16 bits 00:16:33
¿Cuál es el que normalmente siempre se usa? 00:16:36
Pues el int, que es número entero 00:16:41
Pero que la máquina virtual me deja hasta 32 bits 00:16:45
hasta 32 00:16:50
en 32 bits 00:16:52
caben números enteros muy grandes 00:16:55
seguramente más de los que 00:16:56
nunca podamos 00:16:59
vayamos a usar 00:17:00
bueno, el int 00:17:01
tendrá desde 00:17:09
menos 2 elevado a menos 30 00:17:10
menos 2 elevado a 31 00:17:12
hasta más 2 elevado a 31 00:17:14
porque el último bit es el del signo 00:17:16
¿Habéis visto ya la representación en complemento a 1 o en complemento a 2 en el sistema? 00:17:18
En sistemas informáticos, ¿habéis visto ya la representación en complemento a 1 o en complemento a 2? 00:17:22
Bueno, pues en 32 bits cabe desde menos 2 elevado a 31 hasta 2 elevado a 31, 00:17:26
que es un montón, es mucho. 00:17:30
Siempre ponemos sí, siempre ponemos sí, porque es lo más habitual, lo más... 00:17:38
Pero, si necesitamos números mucho más grandotes, 00:17:43
tenemos el tipo de dato long 00:17:47
en el que me caben hasta 00:17:50
en el que la máquina virtual me da hasta 64 bits 00:17:54
que ya es un huevo de bits 00:17:59
hay veces que usamos el long 00:18:02
porque estamos representando conceptos 00:18:06
que sí que deberían tener tamaños de ficheros 00:18:08
yo que sé, algo así 00:18:12
vale, pues entonces 00:18:13
que yo estoy haciendo un programa 00:18:15
en el que voy a usar una variable 00:18:18
entera 00:18:20
para representar la edad de alguien 00:18:21
pues en Java directamente 00:18:24
que escribiré en mi trozo 00:18:26
de código ese que va dentro del main 00:18:28
entre llaves 00:18:30
¿qué escribiré ahí 00:18:31
para crear esa variable? 00:18:34
pues escribiré 00:18:37
primero selecciono el tipo de dato 00:18:38
pues sí, porque un número entero 00:18:40
solemos coger siempre 00:18:42
primero el tipo de dato 00:18:43
y espacio 00:18:45
el nombre de la variable 00:18:47
el que yo haya elegido lo más explicativo posible 00:18:49
punto y coma 00:18:52
punto y coma 00:18:54
y se acabó 00:18:56
esta sentencia 00:18:58
ya es una sentencia válida 00:18:59
de Java 00:19:02
bloque de código 00:19:02
y cuando la máquina virtual 00:19:06
llega a ella 00:19:08
¿qué hace la máquina virtual? 00:19:09
pues hace aparecer 00:19:12
un espacio en memoria RAM 00:19:14
¿de cuánto? 00:19:16
de 32 bits 00:19:18
porque int ocupa 32 00:19:20
y le asocia 00:19:22
internamente un nombre 00:19:27
el nombre que yo ya he dicho, en este caso 00:19:28
le asocia el nombre edad 00:19:30
y ya está, y ahí se queda 00:19:31
a ver, físicamente 00:19:34
en los bits que forman 00:19:37
una memoria RAM o un disco duro 00:19:40
físicamente no puede haberla nada 00:19:41
físicamente siempre tiene que haber 0 o 1 00:19:43
porque esos son los transistores, los destables 00:19:46
los dispositivos 00:19:48
Y eso tiene cero y tiene uno 00:19:49
Entonces, bueno, internamente 00:19:51
Él lo inicializa 00:19:53
Inicialmente lo inicializa a cero 00:19:56
Pero esta inicialización 00:19:58
A cero no nos vale para nada 00:20:00
Porque Java 00:20:01
No nos permite usar esta variable 00:20:03
Para hacer cosas con ella 00:20:06
Hasta que no le demos un valor 00:20:07
¿Vale? Pero para dar valores a variables 00:20:09
Ahora lo vemos después 00:20:11
Pero bueno, que sepamos que además de crearla 00:20:12
Con el tamaño correspondiente 00:20:15
Y asociarle un nombre 00:20:17
la llena de algo, porque no puede dejar 00:20:18
los bits indefinidos, bueno, pues la llena 00:20:21
de todo cero y ya está, pero no nos sirve 00:20:23
para nada ese valor 00:20:25
no podemos usarlo para nada 00:20:26
vale, pues números está claro 00:20:28
cuando necesitemos números enteros 00:20:31
seleccionamos el tipo de dato y ya está 00:20:33
que normalmente va a ser siempre 00:20:34
in, porque si es tanto, para trabajar con números 00:20:37
enteros, porque 32 bits 00:20:39
no son tanto y el problema ahora 00:20:41
no es la rampa 00:20:42
todavía en programas de hace mil años 00:20:45
pues podríamos igual pretender optimizar 00:20:47
un poquito más pero ahora ya 00:20:49
vale, eso en cuanto a números 00:20:50
enteros, pero yo resulta 00:20:53
que mi aplicación tiene que trabajar 00:20:55
con decimales 00:20:57
pues como tiene que trabajar con 00:20:58
decimales no me valen ninguno de estos 00:21:01
tipos de datos 00:21:03
una cosa que yo hago 00:21:04
un byte 00:21:12
la persona que más 00:21:14
ha vivido creo que eran 120 00:21:17
y resulta que ahora hay uno que tiene 140 00:21:18
No puedes cambiar. 00:21:21
La variable edad ya no te vale. 00:21:25
Tienes que crear otra variable edad 00:21:26
para esa nueva edad. 00:21:29
La variable edad, desde el momento en que tú 00:21:31
ya la has declarado así, 00:21:33
te has puesto 00:21:35
byte edad. 00:21:36
En esta variable el programa 00:21:41
no te va a dejar meter 00:21:42
números mayores que los que caben 00:21:44
en un byte. Se acabó. No puedes cambiar. 00:21:47
A esta variable ya no le puedes 00:21:49
cambiar el tipo. No se puede. 00:21:51
No se puede. Una vez 00:21:53
que la variable está declarada con un tipo 00:21:55
asignado, se acabó. 00:21:57
Ese es su tipo para siempre. 00:21:59
No puedes borrar una variable. 00:22:02
Esa variable está así 00:22:04
para siempre. 00:22:05
No puedes. 00:22:07
Eso es otra cosa. 00:22:12
Ahora lo veo. Cuando veamos los tipos 00:22:14
de datos, ahora ya vamos a meterle valores. 00:22:15
Pero una vez que la variable 00:22:17
está declarada y tiene un tipo, 00:22:19
Esa variable se acabó, solamente tienes espacio y memoria, y eso no puede cambiar. 00:22:21
Entonces, ¿que necesitas meter ahí un número mayor de 127? Pues te creas otra variable para ello. 00:22:27
No hay otra. 00:22:34
Claro, los nombres de las variables tienen que ser únicos, aunque sean diferentes tipos. 00:22:37
¿vale? de nuevo aquí digo 00:22:47
con matices porque depende 00:22:49
del bloque de código en que estés, pero eso 00:22:51
ya nos meteremos cuando tengamos 00:22:52
diferentes bloques de código, ámbito de 00:22:55
variable esto sería, pero 00:22:57
respondiendo a tu pregunta 00:22:58
el nombre de la variable tiene que ser único dentro de 00:23:00
tu programa, dentro de tu programa 00:23:03
tiene que ser único aunque sea de diferente tipo 00:23:05
¿vale? porque si no 00:23:06
si tú le llamas 00:23:09
al programa para decirle 00:23:11
suma n más 3 00:23:12
y n tiene su 00:23:15
un decimario, un entero, 00:23:17
a los dos podría sumar de tres. 00:23:18
El programa dirá, ¿a qué n quiere sumar? 00:23:20
Tendría una confusión. 00:23:23
Entonces, los nombres de variables 00:23:25
tienen que ser únicos en nuestro programa, 00:23:27
que el tipo sea distinto. 00:23:29
No puede ser ni a esa variable. 00:23:40
Esa variable va a vivir siempre 00:23:42
mientras el bloque de código en el que esté 00:23:44
se esté ejecutando. 00:23:46
Cuando ese bloque de código ha terminado, 00:23:48
pero esto ya es una cosa más esotérica, 00:23:50
ya esa variable desaparece 00:23:52
es que el programa ha terminado 00:23:55
pero una vez que está esa variable 00:23:56
va a estar ahí siempre con ese nombre 00:23:59
y ocupándole el tamaño by 00:24:01
eso ya no vale 00:24:02
y no las puedes eliminar 00:24:04
no pueden desaparecer 00:24:07
no hay ninguna sentencia para 00:24:09
haz desaparecer esta variable 00:24:10
claro, cambiar el nombre de la variable 00:24:12
ahora ya vemos como asignar valores a variables 00:24:17
y todo, le puedes tú cambiar 00:24:19
el contenido 00:24:21
y darle el contenido que quieras 00:24:23
¿No? A edad, ahora, pues ahora cuando veamos la asignación, pero vamos, es muy sencillo, yo quiero meter en edad 7, pues edad igual 7, esto es edad de asignación, vale, pues en este momento edad se queda con el 7 dentro. 00:24:24
que ahora quiero que edad tenga 18 00:24:41
porque ha llegado otro usuario 00:24:44
edad igual a 18 00:24:45
y ahora edad tiene 18 dentro 00:24:48
pero la variable edad 00:24:49
con sus 32 bits de espacio 00:24:52
esa va a estar siempre ahí con sus 32 bits 00:24:54
y de ahí no se mueve 00:24:56
lo que va a cambiar simplemente 00:24:57
lo que va dentro 00:25:02
aquí va un 7 00:25:05
y después de haber ejecutado 00:25:07
esta pues irá 00:25:09
un 18, pero lo que es 00:25:11
el espacio en ra, y el nombre 00:25:14
asociado, ese ya se queda de por vida 00:25:15
desde el momento en el que tú has hecho 00:25:17
la declaración 00:25:19
¿vale? eso se llama 00:25:20
declarar una variable 00:25:23
hacerla aparecer con su 00:25:24
nombre, su tipo, y terminando en el punto y con 00:25:27
vale, entonces 00:25:30
si yo no necesito 00:25:35
una entera, sino lo que 00:25:38
necesito es una variable decimal 00:25:39
pues no me vale 00:25:41
ninguno de los cuatro tipos que hemos dicho. 00:25:43
¿Qué tipos tengo? 00:25:47
Bueno, me da dos posibilidades Java 00:25:49
en función de la precisión. 00:25:51
Si yo quiero menos decimales o más. 00:25:53
En función de la precisión 00:25:56
me da dos posibilidades. 00:25:57
O el tipo 00:25:59
Float 00:26:00
o el tipo Double. 00:26:04
Me da estas dos opciones. 00:26:09
Este es el que se llama 00:26:12
en simple precisión 00:26:13
y en doble precisión. 00:26:14
En este hay más precisión, más cifras decimales 00:26:16
Puedo poner 00:26:19
Y este menos cifras decimales 00:26:20
El float 00:26:22
Ocupa 32 bits 00:26:23
Y el dabble 00:26:26
64 bits 00:26:28
¿Vale? 00:26:30
¿Cómo se codifica por dentro un dabble, un float? 00:26:37
No da igual, igual que incluso 00:26:40
¿Cómo se codifica por dentro? No da lo mismo 00:26:41
Lo asignamos el valor y ya está 00:26:43
¿Vale? Pues ya está 00:26:45
Entonces 00:26:47
Estos son los dos tipos, decimales 00:26:48
si yo quiero un número decimal 00:26:50
pero puede 00:26:52
que yo no quiera 00:26:56
un número, ni entero ni decimal 00:26:58
sino que mi dato sea 00:27:01
un carácter 00:27:02
solo uno, porque Java no me permite guardar más 00:27:04
con estos tipos de datos 00:27:07
entonces 00:27:09
si yo quiero un carácter 00:27:12
A, B, C, J, H 00:27:15
dólar, almohadilla 00:27:17
cualquiera de los caracteres de esa famosa tabla ASCII 00:27:18
que ya mostramos el otro día 00:27:21
cualquiera de sus caracteres, yo quiero que un dato 00:27:23
tenga un carácter 00:27:25
el tipo que tengo que declarar 00:27:27
es el 00:27:30
char 00:27:31
tipo char 00:27:32
¿eh? 00:27:34
sí, c-h-a-r 00:27:37
ahora cuando ya en el código pongamos 00:27:39
variables, asignaciones, etc. 00:27:42
pues ya lo vamos a ver más claro 00:27:44
ahora los estoy enunciando para ver los que son 00:27:45
entonces llevamos ya 00:27:47
7, los 4 enteros 00:27:49
estos dos, 6 más ese 7 00:27:51
nos falta el octavo 00:27:54
vale, pero repito 00:27:55
que tú dices 00:27:57
oye, perdona, pero es que lo que pasa en la aplicación 00:28:01
son nombres de personas 00:28:03
un nombre de persona 00:28:04
no me cabe en un número, evidentemente 00:28:06
y en un único char no me cabe un nombre de persona 00:28:09
pues hay que usar 00:28:12
hay que construir 00:28:14
un tipo complejo 00:28:16
basado en estos 00:28:18
y el tipo complejo basado en estos 00:28:19
en este caso será 00:28:22
muchos char juntos 00:28:23
muchos char juntos 00:28:26
ya sé que pueden ser un nombre 00:28:28
¿cómo construimos 00:28:30
un tipo complejo 00:28:33
basado en esos 00:28:34
o lo que es lo mismo, pegando muchos de esos? 00:28:35
pues ya lo veremos 00:28:39
en el procedimiento de objetos 00:28:40
pero afortunadamente 00:28:41
algunos de esos tipos 00:28:43
de datos complejos que están basados 00:28:46
en muchos de esos pegados 00:28:48
afortunadamente algunos ya están hechos 00:28:50
los podríamos usar desde ya 00:28:52
como el string 00:28:54
pero eso lo haremos después 00:28:56
por ahora olvidaos de eso 00:28:57
bueno, pues el char es el tipo de datos 00:28:59
y yo quiero guardar un único carácter 00:29:02
punto pelota 00:29:04
¿y cuál nos falta? 00:29:05
el tipo de dato booleano 00:29:08
que es el más complicado de entender 00:29:09
¿cuándo necesito yo que una variable 00:29:11
sea booleana? porque a mí los 00:29:14
los números y los caracteres 00:29:16
me suenan, son los de toda la vida 00:29:18
mis datos son números o son texto 00:29:19
es de lo que se trata todo en la vida, no números o textos 00:29:22
que no hay más 00:29:24
y luego combinación de eso, pero ya está 00:29:25
y esto de booleano, ¿qué es? 00:29:28
esto de booleano tiene que ver 00:29:31
con que para los programas es muy importante 00:29:32
información relativa 00:29:34
a si algo 00:29:36
está pasando 00:29:38
o no está pasando 00:29:40
es decir, todos tenemos 00:29:41
claro que los números y los caracteres 00:29:44
son datos para el programa 00:29:46
opera con números, opera con caracteres 00:29:48
Dejamos el texto y descansamos un momento. 00:29:51
Todos tenemos claro que los números y los caracteres son datos, 00:29:53
que el programa opera con datos, eso está claro y seguro. 00:29:56
Pero es que para un programa, un dato también es si algo pasa o no. 00:29:59
Por ejemplo, si está lloviendo o no está lloviendo. 00:30:04
Eso también es un dato, ¿vale? 00:30:08
¿Por qué te mueves así por la buena? 00:30:11
¿Por qué te mueves así por la buena? 00:30:13
¿Vale? Pero porque he dicho, acabo ahora y ya paramos un momento. 00:30:16
Ah, entendí que acabaste. 00:30:18
No, no he dicho, acabamos esto y ya paramos un momento 00:30:19
Ah, no, no 00:30:22
¿Qué? 00:30:24
Ya, pero si 00:30:27
Sí, pero no se lo pude ver que desconectáis 00:30:27
Después de hablar 00:30:30
Porque a mí me han dicho 00:30:31
No hables nunca más porque yo no soy 00:30:34
Porque nadie dice 00:30:35
Bueno, vamos a acabar esto de booleano 00:30:37
Vale, y nada 00:30:41
Paramos dos, tres minutos y salimos antes 00:30:42
Igual de 00:30:44
Porque está bueno estar 00:30:45
Vale, pues entonces, para un programa, algo como está lloviendo o no está lloviendo es un dato también. 00:30:47
Algo como el número es par o el número es sin par es un dato también. 00:30:59
Luego, cosas, enunciados, que pueden ser solamente o verdad o mentira, también son datos. 00:31:04
¿Vale? Los datos son algo que 00:31:13
Pueden ser números, 3, 5, 7, 8 00:31:16
Los datos son algo que 00:31:18
Pueden ser caracteres, A, C, J 00:31:20
Pero los datos también son algo que 00:31:22
Pueden ser, ¿verdad o mentira? 00:31:24
¿Cómo? ¿Está lloviendo? No está lloviendo 00:31:26
¿Hace calor? Hace calor 00:31:28
Eso también es un dato 00:31:30
Pero claro, ese dato solo tiene dos posibles valores 00:31:32
¿Qué es? 00:31:35
¿Es verdad o mentira? 00:31:36
Son los únicos dos posibles valores que tiene eso 00:31:38
Pues para eso sirven las variables 00:31:40
Booleanas 00:31:42
el tipo de dato, ¿cómo se llama? 00:31:43
Boolean. 00:31:46
Se llama Boolean. 00:31:47
Y cuando uno declara una variable Boolean, 00:31:49
yo que sé, 00:31:53
una variable Boolean cualquiera, 00:31:54
pues esa variable de tipo Boolean 00:31:56
solo puede tener 00:31:58
dos posibles valores, 00:32:00
que son, ¿verdad? 00:32:02
Mentira. 00:32:05
Ya están dos posibles valores. 00:32:06
Igual que una variable float puede tener infinitos, 00:32:07
bueno, infinitos porque 00:32:11
que los que quepan en 32 bits. 00:32:12
Una variable char puede tener mogollón, 00:32:14
los de la tabla ASTI. 00:32:18
Una variable boolean solo puede tener 00:32:19
dos valores posibles, verdad o mentira. 00:32:21
Y de nuevo diréis, 00:32:26
¿pero para qué me sirve una variable boolean? 00:32:27
Pues me sirve para guardar en ella 00:32:31
enunciados sobre cosas que pueden ser 00:32:33
verdades o mentiras. 00:32:36
Enunciados del tipo, pues, 00:32:37
está lloviendo, no está lloviendo, 00:32:38
algo puede ser verdad o mentira. 00:32:39
¿cómo? ¿cómo guardamos 00:32:41
esos enunciados a una variable boolean? 00:32:43
¿cómo guardo un número aquí? está claro 00:32:45
le meto el número, ¿cómo guardo 00:32:47
algo que puede ser verdad o mentira 00:32:49
que es más abstracto a una variable 00:32:51
boolean? bueno, pues ya lo veremos 00:32:53
¿vale? pero ahora mismo 00:32:55
que quede claro que sirven para 00:32:57
guardar valores 00:32:59
que solo son dos posibilidades 00:33:01
¿es verdad o es mentira? 00:33:03
¿vale? venga, paramos unos 00:33:05
minutos 00:33:07
es una condición 00:33:08
Gracias por ver el video. 00:33:11
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
10
Fecha:
21 de septiembre de 2025 - 13:40
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
33′ 12″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.87

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid