Saltar navegación

20250922-ProgEstr-Variables_5 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 22 de septiembre de 2025 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues este rollo de la asignación más o menos se ve más o menos claro. 00:00:01
Luego ya iremos viendo como aquí donde yo he puesto valor, ahí pueden ir muchas cosas. 00:00:13
Con tal de que puedan convertirse en un valor realmente, pues estupendo. 00:00:21
y una variable 00:00:26
se puede convertir en un valor 00:00:28
como enseñando lo que tiene dentro 00:00:30
tengo esto, para ti 00:00:32
bueno, para ti yo 00:00:34
conservo también, claro, te doy una copia 00:00:36
vale, entonces 00:00:38
ahora ya más o menos 00:00:40
empezó a entender 00:00:42
esto de aquí, ahora volvemos 00:00:43
a lo que lo motivó, que es lo de 00:00:46
que a una variable hay que 00:00:48
asignarle valores del mismo tipo 00:00:50
por principio 00:00:52
claro, y aquí es donde vosotros me diríais 00:00:53
pero vamos a ver 00:00:56
edad 00:00:59
es de tipo int 00:01:03
porque así la hemos declarado 00:01:05
edad es de tipo int 00:01:07
y edad tocha está declarada 00:01:10
como long 00:01:13
¿cómo es que el compilador que es tan estricto 00:01:14
que lleva su lista de reglas 00:01:17
el valor tiene que ser del mismo 00:01:19
tipo que la variable 00:01:21
¿cómo es que aquí el compilador 00:01:22
se ha puesto en rojo y no se ha quejado? 00:01:24
porque ha hecho la promoción automática 00:01:26
y eso siempre se puede hacer 00:01:29
entre un número pequeñito 00:01:31
que cabe en uno grande 00:01:34
entonces edad es int 00:01:35
int 00:01:37
cabe en long 00:01:39
int cabe en long 00:01:42
porque es la mitad 00:01:44
entonces el de este valor que había en int 00:01:46
en edad 00:01:49
que era el 78 o el que fuera 00:01:50
hace la promoción 00:01:53
automática 00:01:55
y lo lleva 00:01:56
a este de aquí 00:02:08
porque no hay problema 00:02:09
porque un int cabe en un log, entonces coge el 78 00:02:14
y lo guarda aquí 00:02:17
porque no hay problema, tendrá que poner muchos ceros 00:02:19
en los bits a la izquierda, pero no pasa nada 00:02:21
entonces el compilador 00:02:23
te hace automáticamente 00:02:25
la promoción automática 00:02:27
y esto siempre lo va a poder 00:02:28
hacer entre 00:02:33
un byteusort, por ejemplo 00:02:35
porque bytecaben sort, entre un byteunit 00:02:37
entre un byte y un long 00:02:39
no hay ningún problema 00:02:41
ojo, cuidado 00:02:42
¿significa esto 00:02:45
que lo que ha promocionado 00:02:47
es la variable edad y de repente se ha hecho así 00:02:50
de grande? no 00:02:52
la variable edad sigue siendo int con 32 bits 00:02:53
la promoción 00:02:56
se ha hecho del valor solo 00:02:58
la variable edad 00:02:59
ha dado su valor que es el 78 00:03:02
y la máquina virtual 00:03:04
ha estirado el 78 00:03:06
hasta la caja edad tocha 00:03:08
lo ha estirado 00:03:11
pero la variable edad sigue teniendo su 32 00:03:11
y este su 64 00:03:15
no ha cambiado 00:03:16
el inverso 00:03:17
el compilador ya no te dejaría 00:03:22
si hacemos la asignación al revés 00:03:24
que es 00:03:27
a la variable edad 00:03:30
le voy a asignar 00:03:33
lo que tenga dentro edad tocha 00:03:36
Aquí el compilador 00:03:39
Ya sí que 00:03:42
Efectivamente 00:03:45
Bueno, tendría que ir por aquí 00:03:48
Vale 00:03:59
Aquí el compilador ya sí que se ha quejado 00:04:04
Porque dice, ojo 00:04:06
Era tocha 00:04:08
No sé qué número tiene 00:04:10
Pero podría ocurrir que tuviera un número muy tocho 00:04:12
Podría ocurrir 00:04:14
Y entonces no te dejo 00:04:15
No te dejo 00:04:18
a lo mejor ni siquiera habría problema 00:04:20
porque podría darse esta situación 00:04:22
podría darse la situación 00:04:24
de que edad tocha 00:04:27
sí, es una caja enorme 00:04:30
pero a lo mejor tiene el numerito 7 00:04:32
solo, ¿por qué no? 00:04:34
tiene el numerito 7 00:04:35
y edad es la caja más pequeñita 00:04:36
entonces podría ocurrir 00:04:40
que el numerito que tiene esta variable 00:04:43
cupiera aquí 00:04:46
pero eso el compilador no lo sabe 00:04:47
el compilador aplica sus reglas 00:04:48
luego ya cada ejecución 00:04:50
tendrá los valores que tenga 00:04:52
entonces él aplica sus reglas 00:04:54
para que sean los valores que sean 00:04:56
siempre funcione 00:04:58
entonces él te dice, a ver, edad tocha 00:04:59
sé que es una caja muy grande 00:05:02
con lo cual no sé qué valor tiene 00:05:04
pues dependerá de la ejecución 00:05:06
el valor que te meta el usuario, lo que sea 00:05:08
pero podría ocurrir perfectamente 00:05:10
que el numerito no quepa aquí 00:05:12
podría ocurrir, con lo cual ya 00:05:13
desde el tiempo de compilación y de escritura 00:05:16
de código ya desde ahí te prohíbe 00:05:18
te prohíbe ya ejecutar 00:05:20
eso porque se podría generar un error 00:05:22
gordo que es perder la información 00:05:24
si tú cortas 00:05:26
perder la información 00:05:27
entonces la promoción 00:05:29
se hace de variables 00:05:32
más pequeñas 00:05:34
a otras más grandes 00:05:36
porque no se pierde información 00:05:38
no se pierde, lo único que tienes que hacer es 00:05:39
añadir ceros a la izquierda 00:05:41
lo único que hace la máquina virtual es añadir ceros a la izquierda 00:05:43
pero al revés 00:05:46
de una variable grande a otra más pequeña 00:05:48
esa no se puede hacer 00:05:52
el compilador te dice 00:05:53
eso no te dejo hacerlo 00:05:55
aunque podría haber ejecuciones 00:05:56
en las que no pasaría nada 00:05:59
si no pasaría nada si tiene 7 00:06:00
pero si tiene 200.000 millones 00:06:02
ahí si pasaría 00:06:04
luego 00:06:06
recopilando en general 00:06:11
no olvidemos ya esta sentencia 00:06:16
¿vale? la sentencia 00:06:18
ahora ya conocemos por decirlo así 00:06:20
sentencias para 00:06:22
declarar una variable 00:06:23
tipo de dato, nombre de variable, punto y coma 00:06:25
los diferentes matices 00:06:28
y cosas que se pueden incorporar y lo vamos incorporando 00:06:30
son programas 00:06:32
declaración de una variable, ya la sabemos 00:06:33
asignar valor a una variable 00:06:36
porque una variable la declaramos 00:06:39
es decir, creamos espacio en memoria 00:06:40
para meter datos en ella 00:06:43
porque si no, ¿para qué lo hacemos? 00:06:44
bueno, pues asignar valor a una variable 00:06:45
es una sentencia que ya conocemos 00:06:47
esta 00:06:49
y ya empezamos a tener en la cabeza 00:06:50
algunas cuestiones básicas sobre la asignación 00:06:53
no todas, pero algunas básicas 00:06:57
como que el valor por lo general 00:07:00
tiene que ser del mismo tipo que el de la variable 00:07:03
salvo estos matices que nos han ido surgiendo 00:07:05
que si lo que yo le asigno 00:07:09
es una variable de 8, 32 00:07:12
y cabe en la otra 00:07:15
No pasa nada, el compilador te deja 00:07:17
Porque sabe que la máquina virtual lo estirará con ceros 00:07:19
Si es al revés, no 00:07:22
No te va a dejar 00:07:23
Esos pequeños matices que hemos incorporado 00:07:24
Bueno, pues 00:07:27
Más o menos 00:07:31
Vamos a 00:07:33
Pasar al char 00:07:35
¿Vale? Que teníamos 00:07:37
Aquí 00:07:39
Bueno, sobre números enteros 00:07:43
Sobre números enteros 00:07:47
Salvo las posibles operaciones con números enteros 00:07:48
A lo cual tendremos que ver los operadores 00:07:51
Y todo eso que no hemos visto 00:07:53
Pues crear variables enteras 00:07:55
Y crearlas 00:07:57
Y asignarles valor correctamente 00:07:59
Pues más o menos 00:08:01
Sabemos 00:08:03
Los de los doubles 00:08:04
Todavía no los hemos tocado 00:08:07
El char 00:08:09
Meto el char ahora porque se relaciona 00:08:10
Muy íntimamente con los enteros 00:08:13
Aunque no lo parezca, se relaciona muy íntimamente 00:08:15
Vale 00:08:17
Venga, pues vamos al char 00:08:18
¿cuándo declaramos una variable char? 00:08:23
cuando yo necesito 00:08:30
almacenar un carácter 00:08:31
un carácter 00:08:33
a, j, h, dólar 00:08:35
almohadilla, un carácter 00:08:37
que puede ocurrir que yo necesito almacenar un carácter 00:08:38
de hecho cuando queramos almacenar 00:08:41
texto, nombres 00:08:43
necesitaremos mucho char 00:08:44
¿vale? 00:08:46
¿cuál es el carácter de la tabla? 00:08:48
cualquier carácter de la tabla 00:08:51
no, el 1 00:08:53
también es un carácter válido 00:08:54
cualquier carácter de los que están en la tabla ASCII, 00:08:55
que son los caracteres que reconocen los editores de texto. 00:08:59
¿Vale? 00:09:03
Entonces, no, un carácter solo y de cualquiera de los de esta tabla. 00:09:04
Si volvemos a nuestra tabla ASCII, 00:09:12
esta es la tabla ASCII, 00:09:21
esta tiene 800.000 caracteres. 00:09:25
todos estos 00:09:28
como veis están los números también 00:09:31
son caracteres, todos estos, todos estos 00:09:33
todos estos 00:09:35
tropecientos mil caracteres tienen 00:09:36
muchos caracteres 00:09:39
entonces 00:09:40
estos son los caracteres 00:09:42
que los editores de texto 00:09:45
reconocen, tú puedes escribir 00:09:47
todos esos caracteres, tú puedes escribir todo esto 00:09:49
en un editor de texto y hacerte un texto maravilloso 00:09:51
con esos caracteres 00:09:53
¿vale? 00:09:55
Entonces, los editores de texto, cuando tú escribes texto en ellos, lo que hacen es, cada uno de los caracteres que se van encontrando, lo codifican como una secuencia de 8 bits correspondiente a este numerito que está aquí. 00:09:57
Aquí no aparece como los 8 bits, sino que aparece ya ese valor binario en entero, claro, porque si no, la tabla la estudiaría muy fea. 00:10:15
entonces, que tú has escrito 00:10:21
hola en el blog de notas 00:10:24
en el WordPad, en cualquier editor 00:10:26
de texto, editor, no procesador 00:10:28
el procesador es un software 00:10:30
que lleva su codificación interna al margen 00:10:32
que tú escribes en un 00:10:34
editor de texto, cualquiera, blog de 00:10:36
notas, Notepad, el que sea 00:10:38
escribes hola 00:10:40
¿qué estás poniendo? 00:10:42
una H, entonces, él lo que hace 00:10:44
es coger el 104 00:10:46
pasarlo a binario 00:10:48
y plantarte ahí el 104 en binario 00:10:50
la O 00:10:52
coge el 111, lo pasa a binario 00:10:53
y te pone ahí esos 8 bits 00:10:56
después, la L 00:10:58
coge el 108 00:11:00
lo pasa a binario y te pone ahí los 8 bits 00:11:01
después, y la A 00:11:04
coge el 97, lo pasa a binario y te pone los 8 bits 00:11:06
pues tú tienes ya ahí tus 00:11:08
4 bytes 00:11:10
que son la codificación binaria 00:11:11
del carácter que tú has escrito según la tabla 00:11:14
así, entonces como 00:11:16
todos los editores de texto 00:11:18
todos se han puesto de acuerdo 00:11:20
en usar esta 00:11:22
codificación, la de la tabla ASCII 00:11:24
todos, da igual 00:11:26
que tú escribas en un blog de notas 00:11:28
un texto y luego 00:11:30
lo hablas en otro editor distinto 00:11:32
de otro Notepad, del que sea 00:11:34
porque todos los editores 00:11:36
de texto se han puesto de acuerdo 00:11:38
para codificar en ASCII, todos 00:11:40
entonces, si yo he escrito hola en el blog de notas 00:11:42
y lo abro en el WordPad, seguirá siendo hola 00:11:44
¿vale? no hay ningún problema 00:11:46
hay batices de codificaciones 00:11:49
de algunas cosas como los saltos de línea 00:11:51
que alguno usa dos caracteres en vez de uno 00:11:53
pero es un pequeño detalle 00:11:55
todos los editores de texto usan la misma tabla 00:11:56
porque si no un texto escrito en uno 00:12:02
en otro no se podría 00:12:04
pero hombre puede haber 00:12:05
alguno pero en general que viste mucho 00:12:16
no lo sé 00:12:18
no debería, vamos, no lo sé 00:12:19
no sé a qué situación te refieres 00:12:22
es que es la manera 00:12:23
de alguna manera de poder compartir texto 00:12:30
fácilmente, porque si solamente 00:12:31
pudiéramos escribir en procesadores de texto 00:12:33
lo que yo escribo en Word solo me lo puede 00:12:35
leer el Word y los que conozcan 00:12:38
ese lenguaje 00:12:40
pero lo que yo escribo en un editor de texto 00:12:40
cualquiera que tenga 00:12:43
un editor de texto del fabricante 00:12:45
que sea, lo va a interpretar porque está entendiendo 00:12:48
esta tabla, ¿vale? 00:12:50
Bueno, pues puede ser que nosotros en nuestros 00:12:51
programas necesitemos guardar 00:12:53
alguno de estos caracteres. 00:12:56
Hombre, un carácter 00:12:58
solo sirve para poco, pero 00:12:59
es que es lo único que me permite Java 00:13:01
en sus tipos de datos, esos 8 que yo mencioné. 00:13:03
¿Qué quiere un nombre? 00:13:06
Pues tendremos que ver cómo 00:13:08
poner muchos de esos char en fila. 00:13:10
Pero eso es otra cosa que 00:13:12
veremos ahora un poquito después. 00:13:13
Vale, pues entonces 00:13:16
La variable char es para guardar cualquiera de estos caracteres. 00:13:17
Bueno, pues entonces yo declaro la variable char y ahora vamos a asignarle un valor. 00:13:24
¿Cómo le asigno yo un valor a una variable char? 00:13:30
Pues para indicar que es un carácter lo tengo que poner entre comillas simples. 00:13:33
La simple de toda la vida. 00:13:38
¿La encontraré o no la encontraré? 00:13:42
Ahí, coño. 00:13:43
Ahí. 00:13:45
Vale, la simple de toda la vida. 00:13:46
¡Hala! Ya está. 00:13:49
Ya he asignado el carácter H a la variable char C. 00:13:51
Entonces, importante las comillas simples. 00:13:57
Porque es la forma que tiene Java de entender. 00:14:06
Ah, esto es un carácter. 00:14:09
Esto es un carácter. 00:14:12
Yo lo tengo arriba, debajo de la interrogación que sube. 00:14:18
De la interrogación que cierra. 00:14:23
¿Cuál es la interrogación? 00:14:24
donde está el teclado numérico 00:14:25
debajo de la interrogación 00:14:33
que cierra, suele estar la comilla 00:14:35
simple, por lo menos en mi teclado, no lo sé 00:14:37
¿no la tienes ahí? 00:14:38
pues no sé 00:14:41
vale 00:14:42
vale, entonces 00:14:44
cuidado porque 00:14:50
aquí tendemos a lo mejor 00:15:01
a creer que cualquier cosa que suene a texto 00:15:03
son comillas dobles 00:15:05
Y no, las comillas dobles no valen. Las comillas dobles son otra cosa. Las comillas dobles indican un texto completo con muchos caracteres. Y un texto completo con muchos caracteres se guarda en otros sitios, nunca en un char. 00:15:06
En un char, cuidado, las dobles comillas no son un char. 00:15:21
Las dobles comillas sirven para envolver un texto, de uno, dos, tres, cuatro, pero un texto. 00:15:31
Y una cantidad indefinida de caraceres. 00:15:38
Y un texto nunca puede caer en un char. 00:15:40
Un texto cabe en otros sitios que todavía no hemos visto. 00:15:43
Pero en un char no. 00:15:46
Luego no podemos poner comillas dobles. 00:15:47
tenemos que poner comillas simples 00:15:49
¿no? entonces esto por ejemplo 00:15:51
sería 00:15:59
el carácter 1 00:16:01
el carácter 00:16:03
¿vale? 00:16:05
no el numerito 1 00:16:09
el carácter 00:16:10
dime 00:16:13
no, no es que tenga 00:16:13
ha puesto el ejemplo de que le asigno el char h 00:16:17
ha le asignado el 1, o sea son asignaciones distintas 00:16:18
con una estoy pisando la anterior 00:16:21
estoy haciendo diferentes ejemplos de asignaciones 00:16:22
pues aquí le meto el carácter h 00:16:25
ahora le meto el 1 con lo cual 00:16:26
el h anterior lo he pisado 00:16:29
y se queda el 1, cada asignación que hago 00:16:30
recordad que elimina el valor 00:16:33
que tenía de antes la variable 00:16:35
y ahora se queda con el nuevo 00:16:36
claro, la h ya ha desaparecido 00:16:38
vale 00:16:42
entonces vamos a recordar 00:16:43
nuestra sentencia esta de mostrar 00:16:47
por consola, vamos a recordarla 00:16:49
vale, porque aquí está claro 00:16:51
vale 00:17:04
aquí no 00:17:04
vale, voy a ejecutar este programa 00:17:09
me saldrá primero lo que hicimos el otro día 00:17:12
de mostrar 00:17:14
el mayor y menor enteros 00:17:15
y el mayor y el menor long, pero bueno, lo ignoro 00:17:18
y luego ya me va a mostrar 00:17:20
la C, a ver que me muestra 00:17:22
recordad que al 00:17:24
system.out.println 00:17:27
y si no, pues lo sacamos ahora 00:17:29
el System.out.println sirve para mostrar 00:17:33
por consola lo que yo le dé. 00:17:35
En el primer programa 00:17:38
ese de Hola Mundo, 00:17:39
pues lo usamos pasándole un 00:17:42
texto entre comillas dobles. Entonces, 00:17:43
mostraba ese texto. Pero yo 00:17:45
al System.out.println 00:17:47
le puedo pasar también 00:17:48
una variable. O sea, 00:17:51
aquí, si el System.out 00:17:55
ve un texto, hola, lo que 00:17:58
sea, ve cualquier cosa entre comillas, 00:18:00
ve algo entre comillas, pues entonces 00:18:02
él te muestra eso literal. 00:18:04
Lo que hay aquí entre comillas, literal, te lo muestro. Pero aquí en este caso no le hemos pasado un texto entre comillas, ¿vale? Aquí en este caso le hemos pasado algo que no está entrecomillado. 00:18:06
entonces exactamente igual que 00:18:25
cuando hacíamos una asignación 00:18:28
edad 1 igual a edad 2 00:18:29
por ejemplo 00:18:32
y él decía, a ver 00:18:33
voy a buscar qué cajita 00:18:35
se llama de esta manera 00:18:38
para coger su valor y asignarlo 00:18:40
aquí, pues el system.out.println 00:18:42
funciona exactamente igual 00:18:44
dirá, oye, no me has pasado 00:18:45
un texto literal entre comillas 00:18:50
me has pasado un identificador, algo 00:18:51
voy a buscar la variable que se llame así 00:18:53
voy a buscarla 00:18:56
y voy a coger lo que tenga dentro 00:18:57
para mostrarlo por consola 00:19:00
voy a coger lo que tenga dentro para mostrarlo por consola 00:19:02
bueno, pues cogerá 00:19:05
ah, me has pasado el identificador C 00:19:06
tendrá que haber alguna variable 00:19:08
que se llame C 00:19:10
pues mira para arriba 00:19:13
y dice, ah, sí, sí, sí que lo hay 00:19:14
hay una variable que se llama C 00:19:16
pues voy a coger su valor 00:19:18
que en este caso sería 00:19:20
la h y voy a mostrarlo 00:19:22
esto es lo que haría el system.println 00:19:24
busca la variable que se llame 00:19:26
así 00:19:30
mira lo que tiene dentro 00:19:31
para mostrarlo 00:19:34
pues si 00:19:37
ejecutamos esto 00:19:38
vale, si ejecutamos 00:19:40
esto, efectivamente 00:19:48
después del rollo 00:19:50
este que había de antes 00:19:53
me ha mostrado la h 00:19:55
¿vale? me ha mostrado la h 00:19:57
muy bien 00:19:59
y aquí si yo ejecuto 00:20:01
esto pues me mostraría 00:20:17
la h y luego después el 1 00:20:18
pues la variable c ha cambiado 00:20:21
entonces esto es el carácter 00:20:23
ay perdón 00:20:25
pues aquí efectivamente el primer 00:20:28
system.out.println muestra la h 00:20:34
y el segundo me muestra 00:20:36
el 1 porque yo le he pasado 00:20:40
el carácter 1 00:20:42
ya está, hasta ahí no tiene más historias 00:20:43
pero aquí ya sí que hay un matiz extraño 00:20:48
a ver, vale, aquí 00:20:51
¿qué ocurre? que tal y como hemos visto en esta pequeña tablita 00:21:10
de aquí, que no era esta tabla de aquí 00:21:14
aquí ya vemos automáticamente una correspondencia 00:21:18
entre caracteres y números 00:21:22
hay una correspondencia de caracteres y números 00:21:24
la hemos mencionado 00:21:27
los caracteres y los números 00:21:27
que los codifican en binario dentro de la máquina 00:21:31
están indisolublemente unidos 00:21:33
universalmente unidos 00:21:36
esa correspondencia 00:21:39
bueno, pues tan es así 00:21:40
que los lenguajes de programación 00:21:42
te permiten trabajar indistintamente 00:21:44
porque a veces es muy cómodo 00:21:47
con el carácter 00:21:48
o con el número entero que lo codifica 00:21:50
que permiten trabajar 00:21:53
indiscutiblemente con una cosa o con otra 00:21:55
es decir 00:21:56
esto en que se concreta 00:21:59
por ejemplo yo quiero guardar 00:22:00
el carácter A 00:22:03
mayúscula que es el 65 00:22:05
el carácter A 00:22:07
mayúscula que es el 65 00:22:09
vale 00:22:11
pues el carácter A 00:22:12
mayúscula que es el 65 00:22:15
yo haría C igual a 00:22:16
vale 00:22:21
y ahora lo muestro 00:22:23
y aquí tengo la A 00:22:28
vale 00:22:37
pero este char C 00:22:37
que está declarado como char 00:22:39
yo puedo hacer esto también 00:22:41
C igual a 65 00:22:44
y como veis 00:22:47
al compilador le parece perfecto 00:22:50
me parece maravilloso 00:22:53
es decir, a una variable declarada como char 00:22:54
a una variable declarada como char 00:22:58
le podemos dar 00:23:00
tanto algo entre comillas 00:23:03
simples, y ahí no hay duda 00:23:05
sería ese carácter tal cual 00:23:07
algo entre comillas simples 00:23:08
o le podemos dar un número entero 00:23:10
las dos cosas las va a tragar 00:23:12
cuando le demos el número entero 00:23:14
realmente que va a guardar dentro 00:23:16
lo que realmente va a guardar 00:23:18
dentro es el char 00:23:20
que en la tabla ASCII se corresponde 00:23:22
con ese número 00:23:24
En nuestro caso, pues en el 65 se corresponde la A 00:23:25
¿Y por qué va a hacer eso? 00:23:29
Porque C está declarada como char 00:23:32
Es decir, si C estuviera declarada como entero 00:23:35
En C guardaría el número 65 sí o sí, en binario, no hay duda 00:23:39
El número 65, si estuviera declarada como entero 00:23:45
Pero como C está declarada como char 00:23:48
lo que internamente se guarda 00:23:51
es el char 00:23:53
que en la tabla A 00:23:55
se corresponde con el 65 00:23:57
de hecho si nosotros ahora hacemos esto 00:23:58
como veis 00:24:04
imprime la A también 00:24:11
las dos veces 00:24:13
se ha imprimido la A 00:24:16
y yo aquí le he dado el 65 00:24:17
¿por qué no he imprimido 65? 00:24:19
no he imprimido 65 00:24:22
porque C está declarado como char 00:24:24
entonces al estar 00:24:26
declarado como char, la máquina virtual 00:24:28
interpreta que ese 65 00:24:30
en realidad es un char. 00:24:32
Entonces, como en realidad es un char 00:24:35
porque está declarado como char, 00:24:36
nada de imprimir 65. 00:24:38
Se va a la tabla ASCII 00:24:40
y busca el carácter que se 00:24:42
corresponde con el 65 y ve que 00:24:44
es la mayúscula, pues 00:24:46
ese es el que planta. 00:24:48
Entonces, si no está determinado 00:24:49
lo que hace es 00:24:51
imprimir el 00:24:56
carácter que corresponda. 00:24:57
A ver, en una variable char, en una caja char puede ir un carácter entre comillas simples o un número entero, las dos cosas. Cuando sea un número entre comillas simples es ese char, lógicamente. Cuando sea un número entero es el carácter que en la tabla ASCII se corresponde con ese número entero. Esa es la regla. 00:25:00
O sea, si la tabla llega hasta... 00:25:19
a ver, hay no imprimibles 00:25:23
hay no imprimibles 00:25:26
¿vale? entonces 00:25:28
hay un 00:25:33
ASTI extendido que son los no imprimibles 00:25:36
entonces lo que pasa es que 00:25:37
este te lo coge, este no te lo cogería 00:25:39
te diría, no, esto ya no 00:25:41
¿vale? pero este sí, ¿qué imprimiría aquí? 00:25:43
ni idea, no sé el mil cual es 00:25:45
pues mira, esta cosa tan mona 00:25:47
¿vale? 00:25:51
entonces 00:25:54
la tabla ASTI es mayor 00:25:54
que los 256 que solemos conocer 00:25:57
que son los que escribimos, tiene un montón de cosas 00:25:59
pero si te sales de lo que ya 00:26:01
es codificable, pues ya sí que te da 00:26:03
te da errores 00:26:05
vale 00:26:06
con lo cual, esto nos lleva 00:26:08
a que c igual a 1 00:26:14
y c igual 00:26:16
a 1 entre comillas 00:26:19
simples, por ejemplo 00:26:21
son dos cosas completamente distintas 00:26:22
bueno, voy a poner 00:26:25
50 porque el 1 no sé ni qué será 00:26:26
Ah, no, no, quiero esto 00:26:29
Venga, quiero que tenga eso 00:26:32
Por ejemplo 00:26:33
Esto y esto 00:26:35
Esto y esto 00:26:37
Son dos cosas completamente distintas 00:26:43
Y se imprimirían 00:26:46
Esto es el carácter 5 00:26:47
El carácter 5, tal cual, el 5 00:26:49
Sin embargo, esto es el carácter 00:26:51
Que en la tabla ASCII está asociado al 5 00:26:54
Ni idea de cuál es 00:26:57
Ni idea 00:26:58
Vamos a ejecutarlo 00:26:59
Pues no es imprimible 00:27:01
por eso me ha salido cuando no es imprimible 00:27:05
sale un cuadradito 00:27:07
este es el 00:27:08
carácter que en la tabla se está asociado al 5 00:27:11
que es uno no imprimible a saber 00:27:13
y este es el 00:27:14
carácter 5, luego esta 00:27:17
asignación y esta son completamente 00:27:19
distintas, ¿vale? 00:27:21
son completamente distintas, ambas son 00:27:23
válidas, pero 00:27:25
son dos valores 00:27:26
diferentes 00:27:29
¿vale? 00:27:30
A ver, pero cosas, hasta aquí está claro, ¿no? Vale, según vamos viendo estas cosas, pues vamos sacando pequeñas situaciones, entonces, igual, pues bueno, son muchas pequeñitas cosas que ahora mismo nos tienen que ir sonando, pues nos vamos encontrando, pero no es que sea una lista de cosas que uno tiene que tener siempre presentes. 00:27:48
Son pequeñas cositas que vamos sacando 00:28:13
Pues para que vayáis familiarizándoos un poquito 00:28:15
Con todos estos matices 00:28:17
De las variables y la asignación 00:28:19
Vale 00:28:21
Vamos a otra situación 00:28:22
Venga, de hecho voy a cambiar 00:28:24
De clase, porque para 00:28:26
Ejecutar, si no es un rollo 00:28:28
A ver 00:28:31
Este de aquí 00:28:32
Había metido aquí de todo 00:28:34
Este le voy a 00:28:36
Cambiar de nombre, lo digo porque luego cuando medio 00:28:38
lo acabemos, lo subiría a la aula virtual por si 00:28:41
voy a cambiarle a este 00:28:43
de nombre, que siempre podéis cambiar 00:28:45
a un programa que tengáis hecho 00:28:47
le podéis cambiar el nombre con refactor rename 00:28:48
si es que 00:28:51
le voy a cambiar a 00:28:52
números, porque ahí vamos a 00:28:54
enteros, porque 00:28:56
ahí voy a dejar los ejemplos 00:29:01
con números enteros 00:29:03
vale, no me ha dejado 00:29:04
cambiarlo 00:29:08
porque no me ha dejado cambiarlo 00:29:10
enteros 00:29:14
vale, entonces este voy a 00:29:27
dejar lo que teníamos de enteros 00:29:36
y lo de char lo voy a poner ya en otro 00:29:38
control x, esto lo voy a poner en otro 00:29:42
que sea caracteres 00:29:47
caracteres, vale 00:29:52
vale, pues esto es lo que hemos visto con caracteres 00:29:58
el ejemplito, bueno la idea es que 00:30:18
notéis que os vais sintiendo 00:30:25
más o menos cómodos con estos 00:30:27
conceptos, que los vais 00:30:29
entendiendo, que nada os suena 00:30:31
horriblemente raro y que os veis 00:30:33
cómodos con las cosas 00:30:35
que nos van saliendo y ya está 00:30:37
no que tengáis que tener absolutamente 00:30:39
todas las situaciones que hemos visto en la cabeza 00:30:41
bueno, pues vamos a ver otra situación 00:30:43
con los charlos, no, pero dime, dime 00:30:50
no, el lasti en otros idiomas, por ejemplo 00:30:52
el español, la ñ en otros idiomas 00:30:54
en otros idiomas que también tienen más letras 00:30:56
En el carácter ASTI están todos, en el extendido, bueno, a ver, están los que están, pero la Ñ lógicamente está en el ASTI, la cejilla, los carácteres, a ver, la puedes mirar por curiosidad, hay un montonazo de caracteres. 00:30:58
Todos los que imprimen los editores de texto 00:31:13
A ver, un editor de texto 00:31:16
Tú no puedes elegir un editor de texto 00:31:18
En japonés, por ejemplo 00:31:19
Tienes que tener tú el propio 00:31:22
Incorporar otra cosa 00:31:23
¿Vale? 00:31:25
O sea, en la tabla ASCII no están los caracteres japoneses 00:31:27
¿Eh? 00:31:30
¿Te detecta el qué? 00:31:35
Sí, pero bueno, porque tiene 00:31:37
Una extensión 00:31:39
la tabla este original no tiene los caracteres 00:31:41
japoneses, pero hoy tendría que tener 200.000 00:31:44
caracteres, que son los que tienen los caracteres 00:31:45
japoneses, entonces hay extensiones 00:31:48
con los caracteres básicos 00:31:49
de hecho el 00:31:51
char c, la variable 00:31:55
char de java, en realidad son 16 00:31:57
bits por dentro, son 16 00:31:59
con 16 ya en realidad hay un montazo de caracteres 00:32:01
entonces elevado a 16, imagínate lo que es eso 00:32:07
son muchísimos 00:32:09
Vale, otra situación, por ejemplo 00:32:10
Yo me voy a declarar una variable int 00:32:14
Cambio a otra situación a ver si entendemos lo que pasa 00:32:17
Venga 00:32:20
Me declaro una variable int 00:32:26
Vale 00:32:28
A esta variable int 00:32:29
Una variable int 00:32:33
N, por ejemplo 00:32:36
Le doy, vale 00:32:37
vale, siguiente 00:32:42
siguiente cosa que incorporamos 00:32:44
¿vale? tenemos que ir incorporando 00:32:46
cositas poco a poco porque si no 00:32:48
no podemos avanzar 00:32:50
en el momento en el que declaramos una variable 00:32:52
en el momento 00:32:54
en el que la declaramos 00:32:56
en ese momento si queremos 00:32:57
podemos ya asignarle un valor 00:33:00
si queremos, es decir, por ejemplo 00:33:02
yo quiero una variable n 00:33:04
y le quiero dar un primer valor 00:33:05
13 o 90 00:33:07
pues yo haría esto 00:33:10
¿verdad? 00:33:13
y con esto he creado mi variable 00:33:14
n, ha aparecido en memoria, se llama 00:33:17
n y luego después 00:33:19
le he asignado el valor 9, vale 00:33:21
esto está bien, es un primer valor que le asigno 00:33:23
vale, pues por comodidad 00:33:25
en la escritura de código 00:33:27
si uno quiere 00:33:28
o lo necesita 00:33:31
en el mismo 00:33:33
momento de declarar una variable 00:33:35
puedes aprovechar y darle ya 00:33:37
un primer valor 00:33:39
con lo cual esto se convertiría 00:33:40
esto que yo he escrito aquí 00:33:44
se convertiría en esto 00:33:46
¿vale? 00:33:51
asigno un primer valor 00:34:02
en la declaración 00:34:03
de la variable 00:34:07
esto lo puedo hacer 00:34:08
si es que yo quiero darle un primer valor 00:34:11
luego ya n después 00:34:13
que le quiero dar 27 00:34:14
n igual a 27, luego ya a partir de ahí 00:34:17
lógicamente lo que el programa necesite 00:34:19
puedo asignar un primer valor 00:34:20
esto es lo que se suele 00:34:22
llamar inicialización 00:34:25
de la variable, la estás inicializando 00:34:27
¿por qué? porque la estás dando un primer 00:34:29
valor, le das un primer valor 00:34:31
esto es la inicialización 00:34:33
la opción 00:34:35
¿vale? entonces no es necesario 00:34:41
que hagamos, lo hagamos 00:34:44
en dos líneas, no es necesario 00:34:46
podemos hacerlo en una línea 00:34:48
y aquí pasan dos 00:34:51
cosas, están pasando dos cosas 00:34:53
creo la variable n 00:34:54
en memoria, el espacio, le asocio 00:34:57
el nombre n y además 00:34:59
meto dentro el entero 00:35:01
90, vale 00:35:03
bueno, pues ahora me voy a declarar una variable char 00:35:04
carácter 00:35:11
por ejemplo 00:35:20
vale 00:35:22
carácter, pues yo que sé, por ejemplo 00:35:25
le vamos a dar 00:35:29
la j mayúscula 00:35:30
la inicializamos a la vez que 00:35:33
la creamos, vale 00:35:35
Pues yo he dicho antes que los enteros y los char para Java son intercambiables, porque cada char está codificado como un entero y Java los usa como valores intercambiables. 00:35:36
eso, por ejemplo 00:35:53
me permitiría a mí hacer esto 00:35:55
a carácter 00:35:58
asignarle 00:36:00
¿vale? 00:36:04
según eso me permitiría hacer esto 00:36:07
¿vale? 00:36:08
y me sale en rojo 00:36:09
¿vale? 00:36:14
¿por qué me sale en rojo? 00:36:17
porque aunque n yo aquí le he puesto 90 00:36:19
y sé que 90 00:36:21
tiene una correspondencia en la tabla ASCII 00:36:22
el compilador 00:36:25
no sabe si lo que yo he puesto ahí 00:36:27
es un número enorme 00:36:30
dentro de int, que no tiene 00:36:31
correspondencia a la tabla ASCII. 00:36:33
Entonces, esta asignación 00:36:35
así no te deja, a través 00:36:38
de una variable int, no te deja. 00:36:39
Si yo le pongo el 90 00:36:42
directamente, 00:36:43
entonces sí que te deja, 00:36:46
porque el compilador sabe que el 90 00:36:47
sí es un valor dentro de la 00:36:49
tabla ASCII. 00:36:51
Sí sabe. 00:36:53
Pero no te deja hacer esto. 00:36:55
porque el compilador va por reglas, 00:36:57
no fija, no se, no mira 00:37:00
valores concretos de las variables, va por 00:37:02
reglas, y te dice, oye, 00:37:04
vale, n a lo mejor ahora 00:37:06
tiene 90, pero 00:37:08
por principio una variable int 00:37:10
podría tener 50.213, 00:37:12
y 50.213 00:37:14
no sería un valor que está 00:37:17
en la tabla ASCII, entonces 00:37:19
el compilador te cierra 00:37:20
esa asignación. 00:37:22
Claro, si tú quieres asignar 90 00:37:24
Le pones el número 00:37:30
Espera, lo comprobamos 00:37:31
Esta asignación no nos deja 00:37:38
Porque n podría 00:37:41
Ser demasiado 00:37:50
Grande 00:37:53
¿Vale? 00:37:54
Un segundito, ahora comprobamos lo que has dicho tú 00:37:56
Esta no nos deja 00:37:58
La dejo comentada, de hecho, para que el compilador 00:37:59
No me... 00:38:03
¿Pero qué pasa con la opuesta? 00:38:06
La opuesta sí. 00:38:09
A n yo le puedo dar carácter. 00:38:11
¿Vale? 00:38:17
Esta sí que me ha dejado. 00:38:18
Esta sí deja. 00:38:21
Porque carácter no va a tener nunca un número entero que no quepa ni. 00:38:24
Porque la tabla así extendida, como mucho, son 16 bits. 00:38:30
Entonces, esta sí. 00:38:36
Pero, cuidadín con esta 00:38:37
Esta sí es posible 00:38:44
Esta sí es posible 00:38:48
Aquí sí se hace 00:38:54
Esto sería otro ejemplo, entre comillas 00:38:57
De promoción automática 00:38:59
Aunque exactamente no es así 00:39:00
Pero esta sí te deja 00:39:02
Porque un carácter 00:39:06
Internamente Java lo guarda en 16 bits 00:39:08
Que es la tabla así extendida 00:39:11
Puede tener hasta 16 00:39:13
y en una variable int cabe 00:39:14
y como los char y los int 00:39:17
son intercambiables, pues la tabla 00:39:19
a cada char le mete un int 00:39:20
pues vamos a mostrar 00:39:22
entonces a carácter le hemos dado j 00:39:27
esta asignación 00:39:29
ha sido válida 00:39:32
vamos ahora a mostrar 00:39:33
tanto 00:39:36
carácter como n 00:39:38
no, no suma nada 00:39:42
le asigna ese valor 00:39:47
es una asignación 00:39:49
no hay ninguna suma 00:39:51
Sí, pero no porque sume 00:39:52
Vamos a imprimirla, vamos a hacer las dos cosas ahora 00:39:58
Vale, no 00:40:01
Espera un momentito 00:40:02
Está claro lo que hemos hecho, ¿no? 00:40:04
El carácter tiene 00:40:09
El carácter J 00:40:10
Yo solo he podido asignar a N 00:40:11
Primero porque un char 00:40:14
Cabe en un int 00:40:18
Y porque para Java los char y los int 00:40:19
En realidad son lo mismo porque cada char 00:40:21
Tiene un número entero que lo representa 00:40:24
Voy a mostrar ahora las dos cosas 00:40:26
Ejecutamos esto 00:40:28
Esto no está ejecutado 00:40:31
A ver, es que me ejecuta otro siempre 00:40:41
Vale, ejecuto esto 00:40:44
Esta es la J 00:40:49
Este es el primer System.out 00:40:52
La J 00:40:56
Sí, yo le he dado carácter 00:40:58
Y me ha mostrado la J, maravilloso 00:41:01
Ahora le he dado N 00:41:04
le he dado n 00:41:06
y no me ha mostrado la j 00:41:08
que me ha mostrado 74 00:41:11
¿qué es 74? 00:41:14
la codificación de j 00:41:18
¿por qué? 00:41:20
¿y por qué lo hace distinto? 00:41:21
porque este sistema println 00:41:23
funciona diferente 00:41:25
si tú le das una variable declarada como char 00:41:26
hoy se la das declarada como entera 00:41:29
las dos tienen lo mismo dentro 00:41:32
Tiene el 74 en realidad 00:41:34
Las dos tienen lo mismo 00:41:37
Pero cuando tú se la das declarada como char 00:41:38
Él asume que lo que a ti te interesa 00:41:41
Es el char 00:41:43
Porque como la has declarado como char 00:41:44
Asume que te interesa el char 00:41:46
Entonces se va a la tabla ASTI 00:41:48
Ese 74, mira a ver lo que tiene 00:41:50
Y te lo muestra 00:41:53
Pero porque tú al declararlo como char le estás diciendo 00:41:54
Que me interesa la versión char, no la versión int 00:41:57
Es lo mismo 00:41:59
J y 74 son lo mismo 00:42:00
pero J es versión char 00:42:02
74 es versión int 00:42:04
si tú has declarado como char 00:42:06
él asume que te interesa su versión char 00:42:09
pues te lo imprime 00:42:12
aquí en el N 00:42:14
está exactamente lo mismo 00:42:15
los bits que forman 74 00:42:18
lo mismo 00:42:20
pero al haberlo declarado como int 00:42:21
el N que está declarado como int 00:42:23
ahí arriba 00:42:26
él interpreta que la versión que te interesa a ti 00:42:26
es la int, la entera 00:42:30
el número entero 00:42:31
porque lo has declarado 00:42:32
como int 00:42:33
pues por eso 00:42:33
te ha mostrado 00:42:34
el signo de 4 00:42:35
¿vale? 00:42:35
entonces simplemente 00:42:38
cuidado a veces 00:42:39
pues cuando se muestran 00:42:39
caracteres 00:42:40
por consola 00:42:41
los podéis haber guardado 00:42:42
esos caracteres 00:42:44
en un int 00:42:44
claro que podéis haberlos 00:42:45
guardado en un int 00:42:46
pero si los habéis guardado 00:42:46
en un int 00:42:48
le estáis diciendo a Java 00:42:48
que lo que os interesa 00:42:50
es su valor numérico 00:42:51
y si lo habéis guardado 00:42:52
en un char 00:42:54
le estáis diciendo a Java 00:42:54
que lo que os interesa 00:42:55
es su valor imprimible 00:42:57
¿ya está? 00:42:58
¿vale? 00:43:00
Venga, ahora sí que paramos 00:43:01
Luego ya comprobamos lo que has dicho del byte, etc. 00:43:03
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:
9
Fecha:
22 de septiembre de 2025 - 17:09
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
43′ 09″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
208.46 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid