Saltar navegación

20260918 Variables_7 - 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 2026 por Raquel G.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

¿A quién nos habíamos quedado? 00:00:00
Entonces, ¿esto es así inamovible para los restos de los restos? 00:00:04
Y si yo tengo un código ya larguísimo que en algún momento necesito decir, 00:00:10
a ver, es que yo no puedo declarar, no puedo cambiar la declaración de las variables, no puedo. 00:00:16
Esto está hecho en otro sitio, en otra clase, en otra parte. 00:00:22
Ya veremos cómo se programan las cosas en diferentes clases. 00:00:26
es que no puedo cambiar la declaración 00:00:29
de tipos, no puedo irme aquí 00:00:31
esta parte del código yo no la he hecho 00:00:33
no puedo cambiar esto 00:00:35
estoy condenada a no poder sacar el precio con IVA 00:00:36
no poder hacer mi programa y que me expulse 00:00:39
¿qué hago? 00:00:41
si no puedo tocar esto 00:00:43
y me han pedido 00:00:45
que saque el precio con IVA, ¿qué hago? 00:00:47
bueno 00:00:50
pues hay una cosa que se puede hacer 00:00:51
que es fea horrible del mundo mundial 00:00:53
que es el 00:00:55
castigo 00:00:57
fea horrible del mundo mundial 00:00:57
en general 00:01:00
en contextos 00:01:02
que ya veremos más adelante 00:01:04
hay que hacerla por un tema de clases genéricas 00:01:06
de para ti y de para tan 00:01:09
pero 00:01:10
no es una herramienta 00:01:11
que podamos usar 00:01:15
para solucionar problemas de compilación 00:01:16
porque lo que solemos generar son problemas más gordos 00:01:18
y ya en tiempo de ejecución 00:01:21
que es lo que no queremos 00:01:22
pero como pega aquí, pues vamos a mencionarlo aquí 00:01:23
que es el casting 00:01:27
el casting es una forma 00:01:29
de decirle a Java 00:01:31
ya sé que los tipos no son compatibles 00:01:32
ya sé que a lo mejor 00:01:35
te tienes que cargar información 00:01:36
me da igual, cámbiame este double 00:01:38
a float, aunque te comas 00:01:41
la mitad de los decimales, me da igual 00:01:42
porque yo tengo que guardar el precio 00:01:44
con IVA en un float, sí o sí 00:01:46
porque esto no lo puedo tocar 00:01:48
y esto te va a dar en double, sí o sí 00:01:49
porque es que esto no lo puedo tocar 00:01:52
entonces lo siento, cambia ese 00:01:53
de double a float 00:01:56
para lo cual puede que pierdas 00:01:58
un montón de cifras decimales 00:02:01
pero pagaré ese precio 00:02:02
eso es el casting 00:02:04
convertir a lo bestia 00:02:06
un tipo en otro 00:02:08
¿qué sale de esa conversión? 00:02:09
vete a saber, algo absolutamente 00:02:13
raro, a ver 00:02:14
de la conversión 00:02:16
de un double a un float 00:02:17
no sale nada tan raro 00:02:20
sale un numerito con unas cuantas 00:02:22
decimales que hemos quitado 00:02:24
No es tan terrible 00:02:25
Hemos perdido cifras decimales 00:02:27
Tampoco seguramente no se vaya a la vida 00:02:30
En que ese precio con IVA haya perdido 00:02:32
Unas cuantas cifras decimales 00:02:34
Pero en muchos otros contextos 00:02:35
El casting se carga el programa 00:02:37
¿Vale? Yo tengo un objeto alumno 00:02:39
Y tengo que meterlo en un objeto mesa 00:02:42
Pues es que lo siento 00:02:44
Casting de alumno a mesa 00:02:47
Vete a saber lo que te sale de ahí 00:02:49
¿Vale? El tele dice yo te lo hago 00:02:51
Yo te convierto el alumno en una mesa 00:02:52
¿Te lo va a hacer? 00:02:54
Se acaban los problemas de compilación, pero a saber qué sale de ahí, ¿vale? 00:02:55
Bueno, pues ¿cómo se usa esta herramienta de casting? 00:03:00
Simplemente, delante de lo que queramos convertir, que en este caso es todo esto, 00:03:04
quiero pasarlo a float, todo esto que es double, quiero pasarlo a float, 00:03:12
Delante de lo que queramos convertir 00:03:17
Ponemos 00:03:20
Paréntesis 00:03:22
Y dentro de los paréntesis 00:03:26
El tipo al que queremos convertirlo 00:03:28
¿A dónde quiero llevar yo esto? 00:03:31
A Float 00:03:33
Pues a la 00:03:34
A Float a lo bestia 00:03:36
Cuidado, aquí me sigue saliendo rojo 00:03:38
Porque el casting aplica 00:03:41
A justo lo que tengas pegadito 00:03:44
Cuidado, yo quiero que aplique 00:03:46
Si yo lo dejo así 00:03:47
el casting me aplicaría 00:03:48
solo a precio 1 00:03:51
este seguiría siendo double, con lo cual 00:03:52
float más double, double 00:03:54
entonces en este ejemplito concreto 00:03:56
yo quiero que me aplique a todo 00:03:58
paréntesis ahí 00:04:00
ahí sí que me hacen falta 00:04:02
entonces, este es un 00:04:03
pedazo de casting que me he cascado 00:04:07
para que todo esto 00:04:08
todo, que es un double con un montón 00:04:10
de decimales, le mande 00:04:13
los decimales 00:04:14
sobrantes a la izquierda 00:04:15
a la basura 00:04:18
y lo meta en un flowback 00:04:19
y ahora ya el compilador dice 00:04:20
ya está, te lo puedo hacer 00:04:22
pero claro, el compilador se queda 00:04:25
a los castings le encanta 00:04:27
porque él dice, uy ya está 00:04:28
me salto la regla 00:04:31
de compatibilidad de tipos 00:04:32
pero a costa de perder información 00:04:35
¿vale? 00:04:37
entonces el casting se pone delante 00:04:41
de un valor 00:04:43
un valor que puede haber venido 00:04:44
de una expresión, de donde sea 00:04:46
se pone delante de un valor 00:04:48
y lo que hace es todo ese valor 00:04:49
cambia su almacenamiento interno 00:04:51
lo transforma para que ahora ya se almacene 00:04:54
como ese tipo 00:04:55
entonces esto que estaba almacenado como dabel 00:04:56
lo transformará para que se almacene 00:04:59
como floa 00:05:02
en este caso no es grave, repito 00:05:03
porque va a implicar solo quitar cifras de formal 00:05:05
pero es que yo podría 00:05:08
hacer el casting entre tipos 00:05:10
que tienen aquel uno o el otro 00:05:11
y la máquina virtual 00:05:12
sobrevive como puede 00:05:15
pero claro, lo que sale de ahí 00:05:16
puede ser muy raro 00:05:19
el compilador se queda tranquilo porque ya dice 00:05:20
ah vale, lo has convertido en tipo compatible 00:05:23
muy bien, yo me callo 00:05:25
pero esa conversión 00:05:27
puede haber 00:05:29
resultado en cualquier valor extra 00:05:31
¿vale? 00:05:33
bueno, pues el casting 00:05:36
entonces, lógicamente con cuidado 00:05:37
cuando uno tiene un montón de errores de compilación 00:05:39
el compilador tan majo él 00:05:41
una de las soluciones que te da siempre es 00:05:43
haz un cast, claro con un cast 00:05:45
el compilador se quita el problema 00:05:47
pero nunca es la solución 00:05:49
la solución será que a lo mejor tú has diseñado 00:05:50
mal tu ejercicio, has elegido 00:05:53
mal los tipos de datos, has elegido mal las operaciones 00:05:55
y eso nunca te lo va 00:05:58
a detectar el compilador, jamás 00:05:59
¿vale? 00:06:01
si ha funcionado 00:06:11
es porque precio 1 es flow también 00:06:12
entonces como ya era float 00:06:14
esto no es un double 00:06:18
si ya es float 00:06:20
pues float a float 00:06:22
¿vale? 00:06:23
¿veis? 00:06:26
por ejemplo 00:06:27
cuando yo no lo tenía puesto el casting 00:06:27
y me daba el error 00:06:29
cuando yo lo tenía así 00:06:30
y me daba el error 00:06:33
yo pongo aquí la manita 00:06:37
y me dice 00:06:40
lo siento 00:06:41
el tipo no encaja 00:06:43
no puedo convertir de double a float 00:06:44
y si yo soy un programador desastroso 00:06:46
desastroso, hago clic ahí porque ahí el compilador me hace sugerencias, la mayoría de las cuales 00:06:48
debo desechar, lógicamente, porque él no entiende del sentido de mi programa, él solamente 00:06:56
entiende de reglas sintácticas, ¿vale? Entonces, yo voy a pasar por una puerta que me llega 00:07:04
hasta aquí. El compilador me dice, no te dejo pasar. ¿Qué sugerencia me ofrece? Que 00:07:11
me corte la cabeza. Pues yo sigo al compilador tranquilamente y digo, estupendo, me voy a 00:07:20
cortar la cabeza y voy a caer estupendamente. Pero hombre, normalmente no es esa la solución 00:07:25
que queremos adoptar. A lo mejor será, jolines, es que he elegido la puerta que no es, es 00:07:32
que yo tenía que haber llevado mi programa por aquí, que es donde está la puerta buena. 00:07:37
eso nunca me lo va a decir el compilador eso yo que he diseñado el programa entiendo los 00:07:41
requisitos soy la que me doy cuenta de que es que esa estructura está mal planteada desde 00:07:46
principio a fin vale si yo sigo al compilador pues me corto la cabeza paso por la puerta y 00:07:50
mi programa lógicamente no tiene el resultado que yo espero vale entonces si yo pulso aquí 00:07:56
no solamente deposito la mano sin pulsar 00:08:03
sino además pulso 00:08:07
él me ofrece 00:08:08
soluciones 00:08:11
y una de ellas es 00:08:12
hazle un cast 00:08:15
ala, magnífico, si yo le hago un cast 00:08:17
solucionado 00:08:19
hazle un cast 00:08:20
hago aquí mi doble clic 00:08:22
y ala, él ya me ha hecho 00:08:26
justo lo que yo habría escrito antes, un cast 00:08:29
el error de compilación ha desaparecido 00:08:31
Pero he perdido cifras decimales 00:08:34
¿Me importa? 00:08:37
¿No me importa? Pues no lo sé 00:08:39
Habrá que ver el contexto 00:08:40
Esta puede ser una solución horrible 00:08:41
¿Vale? 00:08:43
También me ofrecía otra 00:08:47
En este caso 00:08:48
Que son cosas sencillas 00:08:51
Pues hombre, no dice tantas burradas 00:08:53
Pero en general las dice 00:08:54
También me ofrecía 00:08:56
Cambia el tipo de precio con IVA a DABEL 00:08:57
Ah, vale, venga 00:09:00
Lo cambia a DABEL 00:09:03
Pues vale, ya está 00:09:03
Vale, esto sí, pero a lo mejor yo no puedo hacerlo 00:09:04
Bueno 00:09:08
¿Todo claro? 00:09:12
Matices, sí, dale, la, la, la, la 00:09:17
Sí, todo, todísimo 00:09:19
Venga, pues vamos a los char, que son más divertidos 00:09:23
Son mucho más divertidos 00:09:28
Venga, ¿dónde nos vamos? 00:09:32
Pues aquí mismo, ala 00:09:36
Char 00:09:37
esto es más divertido 00:09:39
¿qué es una variable de tipo char? 00:09:42
lo sabemos de ayer 00:09:48
una variable que vale para guardar 00:09:50
un único carácter 00:09:54
muy bien 00:09:56
he abierto los números 00:09:57
pero mal 00:09:59
vale 00:10:00
y de los boolean 00:10:02
por ejemplo esta 00:10:04
ala 00:10:06
tengo declarada mi variable char 00:10:08
que vale para guardar un único carácter 00:10:10
muy bien, solo uno 00:10:13
vale, también dijimos ayer 00:10:15
¿cómo le asigno yo un carácter a una variable char? 00:10:19
pues Java interpreta que un carácter 00:10:26
es algo que está entre comillas sencillas de estas 00:10:29
¿vale? 00:10:33
esto es un char 00:10:36
eso no es el número 8 00:10:38
no es el número 8 00:10:45
es el carácter 8 00:10:47
yo con eso no puedo operar 00:10:49
no puedo hacer sumas, restas 00:10:52
no, es el carácter 8 00:10:53
tal y como aparece en mi editor de texto 00:10:55
igual que la C es el carácter C 00:10:58
tal y como aparece en mi editor de texto 00:11:00
es otra cosa, es el carácter 8 00:11:02
¿vale? 00:11:04
y ahora la siguiente pregunta natural sería 00:11:07
¿Y cuántos caracteres puedo representar? Pues un montón, en particular, luego más, pero ahora primero empezamos en particular, todos los que están en la famosa tabla ASTI. 00:11:10
que es la tabla 00:11:27
ASTI 00:11:44
la tabla ASTI 00:11:44
muchos ya os suena 00:11:47
una forma 00:11:51
que todas 00:11:54
las máquinas han adoptado 00:11:56
para codificar caracteres 00:11:57
¿vale? 00:12:00
y usa 00:12:02
127 bits 00:12:02
usa 00:12:05
7 bits 00:12:07
como 7 no se puede impartir, en realidad se usa un byte 00:12:10
pero bueno, de esos bytes se usan 7 bits 00:12:12
127 es por los caracteres 00:12:14
que se pueden representar 00:12:17
vale, lo doy 00:12:18
entonces 00:12:19
el convenio de codificación ASCII 00:12:24
asume 00:12:27
pues que tú tienes un byte 00:12:29
aquí y 00:12:31
los caracteres 00:12:33
representas caracteres 00:12:34
mediante las combinaciones 00:12:37
de estos 7 bits de aquí 00:12:39
luego tienes para 127 caracteres distintos 00:12:41
que ya son un montón de caracteres 00:12:45
ya son un montón 00:12:46
bueno, pues la tabla ASCII 00:12:49
a cada carácter imprimible 00:12:53
en un blog de notas, un editor, donde sea 00:12:56
cada carácter imprimible 00:12:58
le asocia una combinación de estos 00:13:00
y todas las máquinas siguen ese convenio 00:13:03
entonces la C 00:13:06
en mi editor de texto 00:13:07
está representado con una combinación 00:13:10
binaria que es exactamente 00:13:13
la misma que usa 00:13:15
cualquier otro editor de texto 00:13:16
me da igual cambiar del blog de notas 00:13:18
al WordPad, cambiar el editor 00:13:21
de texto del Eclipse 00:13:23
no los procesadores, olvidados del Word 00:13:24
y de todo eso 00:13:27
el Docs, todo eso 00:13:29
esos son procesadores de texto, es distinto 00:13:31
ellos no guardan 00:13:33
los caracteres según la 00:13:35
codificación ASCII, lo guardan 00:13:36
con sus propios códigos internos 00:13:39
para poder representar 00:13:41
colores, etc. 00:13:43
Pero nosotros en programación 00:13:45
no nos importan los colores de texto. 00:13:47
Nosotros en programación hablamos con texto puro y duro. 00:13:49
Bueno, pues entonces 00:13:52
la codificación ASCII 00:13:52
fija una combinación 00:13:54
de 7 bits para cada 00:13:57
carácter posible. 00:13:59
Y esa la usan todos los editores 00:14:02
de texto, todos. Por eso cuando 00:14:04
yo escribo en mi blog de notas 00:14:06
un poema y ahora ese poema 00:14:08
lo abre Pepito en otro 00:14:10
editor de texto distinto, el Notepad 00:14:12
que tiene él, pues ve mi poema tal cual 00:14:14
porque ambos han seguido 00:14:16
la misma forma de codificar 00:14:18
los caracteres, la misma 00:14:20
si cada ordenador usara para codificar 00:14:21
caracteres una forma distinta 00:14:24
lo que yo escribo en mi blog de notas 00:14:26
lo abre 00:14:28
Juanito en su Notepad 00:14:29
y no... 00:14:32
no entendería más nada 00:14:34
Bueno, pues esta codificación, ¿cuál es? Pues la tenemos en la famosa tabla ASTI, ¿vale? La famosa tabla ASTI que rápidamente la podéis localizar en internet porque hay millones de páginas que te muestran la tabla ASTI, que sería una cosa como esto, ¿vale? 00:14:35
Las dos primeras columnas 00:14:58
Olvidaros del hasti extendido 00:15:06
Las dos primeras columnas 00:15:07
Como veis 00:15:10
Llegamos hasta 126 sol 00:15:11
Son los caracteres 00:15:13
Más habituales 00:15:15
Los únicos que podemos imprimir 00:15:17
Pero eso ahora lo vemos después 00:15:19
¿Vale? Son los más habituales 00:15:21
Todos estos que están aquí 00:15:23
Que son caracteres especiales 00:15:24
Los de control 00:15:28
Pues nueva página, tabulador 00:15:28
Nueva línea 00:15:32
son caracteres de control, no son cosas que se vean con los ojos, ¿vale? 00:15:32
El tabulador no lo vemos, el salto de línea no lo vemos, 00:15:37
pero aunque no lo veamos está ahí codificado, lógicamente, 00:15:41
porque el salto de línea tiene un efecto y el tabulador tiene un efecto, 00:15:43
aunque físicamente no se vea, ¿vale? 00:15:46
Pues los de control serían estos primeros de aquí, estos de aquí. 00:15:49
Y luego tenemos los 32 primeros, ¿vale? Serían los de control. 00:15:56
Y luego tenemos ya los que vemos con los ojos, los que se llaman imprimibles, que son estos de aquí, que veis aquí en negrita. Las mayúsculas, las minúsculas, los números, ¿vale? Veis que faltan un montón, pero bueno, eso ya lo solucionamos después. 00:16:02
veis que no está la ñ por ejemplo 00:16:21
hay muchos que no están 00:16:23
los de otros alfabetos 00:16:26
pero esta es la tabla ASTI de toda la vida 00:16:27
entonces 00:16:30
¿qué vemos en esta tabla? 00:16:32
vemos en esta tabla 00:16:36
que cada carácter 00:16:37
tiene asociado 00:16:38
un numerito 00:16:41
¿veis? 00:16:42
ese numerito ¿qué es? 00:16:45
es precisamente 00:16:47
su representación binaria 00:16:48
¿Cómo se representa la A mayúscula internamente? Pues se representa internamente con el 65, que el 65 pues lo que sea en binario, será 32 más 16, ¿cuánto es? 48, pues no me cabe uno más, 64 más 1. 00:16:50
64 es 00:17:20
2 elevado a cuánto 00:17:24
2 elevado a 4 es 32 00:17:27
2 elevado a 5 es 64 00:17:29
entonces sería 00:17:31
un 1 aquí 00:17:33
del primer dígito 00:17:35
0, 1, 2, 3 00:17:37
y 4 00:17:40
y todo eso ceros 00:17:41
y todo lo demás ceros 00:17:42
1, 2, 3, 4 00:17:51
5, 6, 7 y 8 00:17:53
Bueno, eso, si no me he equivocado 00:17:54
Es 65 en binario 00:17:57
¿Vale? 00:18:00
Pues así es como internamente 00:18:06
Se representaría 00:18:08
La A mayúscula 00:18:10
No os da igual 00:18:11
La representación binaria no os da lo mismo 00:18:13
Me da igual si me he equivocado 00:18:15
El 1 va más a la izquierda 00:18:17
Me da lo mismo 00:18:19
Es que de hecho creo que me he equivocado 00:18:21
Porque esto es 00:18:23
claro, es más a la izquierda 00:18:24
es que este es pequeñísimo 00:18:26
vale, este sería 00:18:27
vale, es que ya lo veía yo 00:18:30
el 1 muy pequeñito 00:18:32
vale, pues esta es la expresión binaria 00:18:33
que nos da un poco igual 00:18:36
saber pasar a binario 00:18:38
no nos importa nada, es cultura general de informática 00:18:40
que aprendéis en sistemas, no nos importa 00:18:42
vale, pero simplemente saber 00:18:44
que este numerito 00:18:46
de aquí representa 00:18:48
si lo pasamos a binario 00:18:50
cómo se codifica dentro de la máquina. 00:18:52
Pero representa además algo mucho más útil para nosotros, 00:18:57
que es que para Java los char y los int son intercambiables. 00:19:02
Es decir, para Java el carácter A mayúscula, este, 00:19:08
lo puedo escribir tanto como A mayúscula entre comillas simples, 00:19:14
como con el 65. 00:19:19
es decir, el numerito entero 00:19:20
que está en la tabla 00:19:24
y el carácter al que acompaña 00:19:25
son perfectamente intercambiables 00:19:27
y eso nos da unas posibilidades enormes 00:19:30
para trabajar con textos 00:19:34
¿vale? ahora lo vemos 00:19:37
¿vale? luego quedémonos 00:19:38
primero con esto 00:19:43
que en la tabla ASCII hay una correspondencia 00:19:45
única, universal 00:19:47
entre carácter y un número 00:19:49
que es su representación binaria 00:19:52
común para todos 00:19:53
y ahora nosotros cuando programamos 00:19:55
en un lenguaje de programación, en concreto en Java 00:19:58
me da igual referirme 00:20:00
a un carácter como el carácter en sí 00:20:02
con copias simples que como con el número 00:20:04
que acompaña, me da igual 00:20:06
a Java le da lo mismo 00:20:08
vamos a verlo 00:20:10
a ver, esto, estamos aquí 00:20:19
vale, yo aquí he puesto el char 8 00:20:22
de hecho yo ahora lo imprimo 00:20:25
carácter 00:20:27
me va a salir después 00:20:30
de precio con IVA y me sale el carácter. Para no confundirlo, haber elegido un número 00:20:35
ya es liarla, voy a elegir el K. El carácter K minúscula. Yo ejecuto esto y aquí me sale 00:20:45
el carácter K minúscula. Vale, perfectamente. Ahora yo a carácter le voy a asignar, por 00:20:57
ejemplo, 69. Anda, pues también se lo ha tragado. Y esto no es un carácter entre comillas 00:21:08
simples, ¿vale? Que yo he dicho que en Java los caracteres se expresan como el carácter 00:21:18
que yo quiera, entre comillas simples. Pues aquí a un char le da un número entero. Y 00:21:24
Y eso está tranquilo, porque, por lo que he dicho antes, para Java, el carácter en sí y el número al que acompaña son perfectamente intercambiables. 00:21:32
Entonces, yo ahora aquí imprimo otra vez carácter y a ver qué me sale. 00:21:46
¿Me sale la E mayúscula? 00:21:58
Va a ser que la E mayúscula es la que está colocada en el 69. 00:22:01
Va a ser, vamos a ver, pues efectivamente, la E mayúscula estaba colocada aquí. 00:22:06
Entonces, desde el momento en que yo puedo trabajar con caracteres como los números a los que acompañan, 00:22:31
pues se me abre una posibilidad bastante chuli, que es operar con caracteres. 00:22:39
Si cada carácter tiene asociado un número, pues yo podría hacer sumas, ¿no? 00:22:45
Porque tiene asociado un número. 00:22:51
Pues sí, podría hacer sumas. 00:22:53
Por ejemplo, voy a hacer ahora, carácter 2, voy a declarar un carácter 2, char carácter 2, ¿vale? 00:22:56
Igual a h. 00:23:14
Vale. 00:23:20
y ahora a carácter 00:23:20
la variable de arriba 00:23:26
le voy a asignar 00:23:28
el carácter 2 00:23:29
más 00:23:32
¿vale? 00:23:37
entonces 00:23:42
me sale un error de compilación 00:23:43
¿vale? entonces 00:23:45
primera cosa, ya que hemos quedado 00:23:47
no acabamos de decir que 00:23:49
los char tienen un número 00:23:52
asociado 00:23:54
entonces puedo sumarlos 00:23:55
multiplicarlos 00:23:58
perdón, multiplicarlos 00:23:59
bueno, podría, pero para qué quiero hacer eso 00:24:01
normalmente yo quiero para bajar 00:24:03
puedo sumarlos, restarlos 00:24:05
aquí no he podido sumarle 00:24:08
a una cosa 00:24:10
claro, pero porque aquí 00:24:11
aquí estoy mezclando tipos 00:24:13
estoy mezclando tipos, cuidado 00:24:15
estoy mezclando tipos 00:24:18
aquí no estoy sumando char 00:24:20
entre sí 00:24:21
¿por qué? 00:24:22
que he dicho yo antes al principio de la clase 00:24:24
que cuando a Java 00:24:26
tú le sueltas un número, así plantado 00:24:28
para hacer algo con él, le suelto el 10 00:24:30
él automáticamente 00:24:32
interpreta 00:24:34
que esto es un int 00:24:36
y te lo guarda 00:24:38
en 32 bits 00:24:40
como si fuera un numerito el 10 00:24:42
¿vale? 00:24:44
entonces por eso no me deja 00:24:46
porque me dice, estás mezclando 00:24:48
un int con un char 00:24:49
bueno, no, perdón, esto lo acabo de decir 00:24:52
no está bien 00:24:54
o sea, si me deja hacer la suma 00:24:55
a carácter le puede sumar 00:24:58
el 10, porque carácter tiene un número 00:25:00
carácter dentro 00:25:02
tiene un número, vamos a ver qué numerito tiene 00:25:04
vamos a ver 00:25:06
la h minúscula 00:25:08
qué numerito tiene 00:25:10
la h minúscula tiene el 104 00:25:11
vamos a ponerlo aquí 00:25:14
¿vale? 00:25:17
entonces 00:25:21
Esta operación, en realidad, él internamente sí la puede hacer. Estará sumando el 104, este que me habéis dicho, estará sumando el 104, lo estará sumando con el 10, esto sí, y le habrá salido 114. 00:25:21
La suma sí que puede hacerla 00:25:44
Porque hemos dicho que un char 00:25:48
Es tanto el propio char 00:25:49
Como el número que representa 00:25:52
¿Dónde ha llegado el problema? 00:25:53
Que al mezclar char con int 00:25:55
Al igual que al mezclar 00:25:59
Float con dabble 00:26:02
Convertía en dabble 00:26:04
Al mezclar int con long 00:26:05
Convertía en long 00:26:07
Los ejemplos que hemos visto 00:26:08
Pues al mezclar char con int 00:26:10
Lo convierte al tipo más grande 00:26:12
char es más pequeñito 00:26:14
int en 32, lo convierte a int 00:26:16
entonces al mezclar char con int 00:26:18
esto 00:26:20
lo interpreta como 00:26:21
numerito int 00:26:24
y ahora ya sí que llega la incompatibilidad 00:26:25
de tipos, me dice 00:26:28
oye, no puedo asignar int 00:26:30
a char, porque carácter 00:26:32
es char 00:26:34
vale, hasta aquí vale 00:26:35
¿por qué sale este error? 00:26:47
porque esto es un poco 00:26:50
rollo, hasta que uno lo maneja 00:26:51
completamente es un poco rollo 00:26:53
sin embargo 00:26:55
si le hubiéramos sumado a carácter 00:26:57
2 en lugar de sumarle 10 00:26:59
le hubiéramos sumado esto 00:27:01
por ejemplo, vale 00:27:03
carácter 2 00:27:05
ah bueno, no, no, es que perdón 00:27:07
da igual, porque la suma siempre la 00:27:09
vale, en cuanto él se encuentra 00:27:11
una suma 00:27:13
vale, el operador 00:27:14
suma siempre 00:27:17
siempre implica que el 00:27:19
resultado va a ser, lo va a guardar como número 00:27:21
siempre, o sea el operador 00:27:23
suma siempre 00:27:25
lo interpreta como 00:27:27
número, lo va a guardar como número 00:27:29
¿vale? entonces 00:27:31
¿para qué nos sirve sumar char? 00:27:33
porque nosotros intuimos 00:27:35
que nos debería servir para esto 00:27:37
yo tengo el numerito de 00:27:39
le sumo 00:27:41
dos 00:27:43
y me debería salir el f, intuimos 00:27:44
que para eso sirve sumar a los char 00:27:47
tiene toda la pinta 00:27:49
tengo la D, le sumo 2 y voy a la F 00:27:50
tengo la D, le sumo 10 y voy a la N 00:27:54
tiene la pinta de que me serviría para eso 00:27:57
pero jolines 00:28:00
si no me está dejando el compilador 00:28:01
porque se empeña, se empeña 00:28:04
en cada vez que yo sumo 00:28:07
char entre sí o char con int 00:28:10
convertirlo a char, a int, perdón 00:28:11
jolín 00:28:14
¿de qué me sirve? 00:28:16
bueno, pues es que aquí 00:28:18
y aquí en este contexto 00:28:21
sí que es uno en los cuales 00:28:23
tenemos que usar el casting 00:28:25
aquí sí, ¿vale? 00:28:27
yo tengo mi char, carácter 2 00:28:30
que sé que internamente es 104 00:28:31
le sumo 2 00:28:33
perfectamente puedo sumarlo 00:28:35
104 más 2, 106 00:28:37
me lo deja guardado como int 00:28:39
pero yo ese 106 no quiero 00:28:41
su versión int, de ese 106 00:28:43
quiero su versión char 00:28:46
quiero su versión char que es 00:28:47
esta 00:28:50
esta es su versión char 00:28:52
de 106, vale 00:28:57
entonces, para cambiar 00:28:58
de la versión int 00:29:01
a la versión char 00:29:02
porque yo estoy trabajando con char 00:29:04
y se me han pasado a int 00:29:06
al hacer operaciones 00:29:08
que al hacer operaciones te pasan a int 00:29:10
ahí, en ese contexto 00:29:12
es uno de los cuales sí 00:29:15
podemos poner nuestro 00:29:16
casting 00:29:18
¿Vale? 00:29:19
Repito, tengo el carácter 2 00:29:22
Mi H 00:29:23
O 104, es lo mismo 00:29:24
Le sumo 2 00:29:26
Que lo puedo hacer porque 00:29:28
H es 104 en el fondo 00:29:30
Le sumo 2, 106 00:29:32
Me lo guarda como número 00:29:34
No, perdona, como número 00:29:36
No lo quiero, lo quiero en su versión 00:29:39
Char, pues no pasa nada 00:29:41
Le haces un casting 00:29:43
¿Vale? 00:29:45
Le haces un casting 00:29:49
y en este caso tan feliz 00:29:50
este es un caso controlado 00:29:53
vamos a comprobar 00:29:55
que efectivamente 00:30:11
me imprime 00:30:13
104 más 2 00:30:15
que es 106 00:30:17
y 106 es 00:30:19
hemos dicho 00:30:22
vamos a comprobar que 00:30:26
nos imprime J 00:30:29
que es la versión char 00:30:31
de 106, ¿vale? Aquí la tenemos, la J, la versión char de 106. Recopilamos hasta aquí, los char, las variables de tipo char 00:30:33
sirven para guardar un único carácter. ¿Ese carácter cómo lo expreso? Pues lo puedo expresar como el carácter 00:31:13
en particular 00:31:24
con comillas simples 00:31:25
o como el número 00:31:27
que lo representa 00:31:29
en la tabla ASCII 00:31:32
me da igual una cosa que otra 00:31:33
me da igual asignar 104 que asignar H 00:31:34
es lo mismo 00:31:38
al char 00:31:39
es lo mismo 00:31:40
entonces 00:31:42
al tener el char 00:31:45
una representación interna numérica 00:31:47
que es lo que tiene una representación interna numérica 00:31:50
puedo 00:31:52
sumar y restar char, puedo operar con ellos 00:31:53
pero cuidado 00:31:55
porque al sumar char 00:31:59
o a sumar char con un int 00:32:01
o lo que yo quiera 00:32:03
el resultado de esa operación 00:32:04
Java lo va a guardar como int 00:32:07
entonces, ¿hay algún problema en que lo guarde 00:32:09
como int? 00:32:11
no, el número está ahí, el número es 106 00:32:13
ahí está el número 00:32:16
pero al guardarlo como int 00:32:16
cuando yo le hago la asignación a char 00:32:18
la máquina virtual me dice 00:32:22
no puedo, int de 32 00:32:23
no cabe en char del 16 00:32:25
ahora decimos sobre la longitud de char 00:32:27
no puedo, no puedo 00:32:29
pero ojo 00:32:31
yo quiero la interpretación char 00:32:32
de 106, no quiero la int 00:32:35
ningún problema 00:32:37
casting 00:32:39
y ahí la tenemos 00:32:42
esto que era el 106 00:32:42
en int 00:32:46
ahora es el 106 pero en char 00:32:46
Y eso en la tabla A si es el J que hemos visto 00:32:49
Entonces operar con char es muy útil en realidad 00:32:53
Para cosas como por ejemplo, pues lo típico 00:33:09
Yo quiero pasar de mayúscula a minúscula 00:33:13
Pues como tenemos la suerte de que las letras están todas en orden 00:33:18
Primero las mayúsculas del alfabeto 00:33:22
Aquí las minúsculas desde la A 00:33:24
Pues entre las mayúsculas y las minúsculas hay una diferencia neta de 97 menos 65 que es 32, ¿verdad? 00:33:27
Entonces b más 32 es b minúscula, d menos 32 es d mayúscula. 00:33:37
Entonces una forma fácil de pasar de minúsculas a mayúsculas es restando o sumando 32. 00:33:44
Por ejemplo, vamos a pasar carácter 2 a mayúscula. 00:33:52
Pues venga, mi carácter 2 mayúscula ahora va a ser el carácter 2 antiguo menos 32, hemos dicho, ¿no? 00:33:58
Y con el problema de que esto me lo convierte en int, pues no pasa nada a achar. 00:34:26
Y aquí, cuidado, es la primera vez que hemos incorporado una expresión que se use la variable que va a recibir el valor dentro de la propia expresión. 00:34:35
Es la primera vez que lo hemos usado. 00:35:04
entonces normalmente una variable 00:35:06
le asignábamos un valor 00:35:09
relacionado con 00:35:11
otra variable multiplicada o restada 00:35:13
o lo que fuera, aquí estamos usando 00:35:15
la propia variable 00:35:17
a la que asignamos valor, la propia 00:35:19
dentro de la expresión 00:35:21
es grave, pasa algo 00:35:22
lo que está ocurriendo es que 00:35:24
para evaluar esta 00:35:27
expresión 00:35:29
primero evaluamos la expresión 00:35:30
bueno, la máquina virtual de Java 00:35:34
la evalúa usando el valor de carácter 2, el que sea. La evalúa y cuando ya tiene el 00:35:37
resultado final, lo guarda en carácter 2, con lo cual sobrescribe, pisa el valor que 00:35:43
tenía de antes. ¿Vale? No pasa nada. Es como si yo hago la expresión x igual a x 00:35:51
por 2. Entonces yo tengo mi variable x, que tiene un numerito. Lo primero que hace la 00:35:58
máquina virtual al encontrarse esta sentencia, lo primero, evalúa la expresión. x que tiene 00:36:08
x, 7, 7 por 2, 14, muy bien, ya tengo el 14 ahí esperando para hacer algo con él. Ahora, 00:36:15
¿A qué hago con el 14? 00:36:22
Toca asignar. 00:36:24
¿A quién se lo asigno? 00:36:25
A X. 00:36:26
El 7 de antes, sobrescrito, y nos quedamos con el 14. 00:36:27
No pasa nada. 00:36:32
Puedo usar perfectamente la variable que va a recibir el valor en la expresión. 00:36:34
No pasa nada. 00:36:41
Lo que pasa es que el valor original desaparece. 00:36:42
Vale. 00:36:46
Pues ya está, ha desaparecido. 00:36:46
Yo quería que esta variable multiplicara por 2 su valor, pues no he conseguido. 00:36:47
lo ha multiplicado por 2 00:36:52
no pasa nada 00:36:53
¿vale? 00:36:55
luego siempre podéis usar 00:36:58
en una expresión 00:37:00
cualquier variable, aunque sea la propia 00:37:01
que va a recibir el valor 00:37:04
lo que pasa es que una vez evaluada la expresión 00:37:05
con el valor antiguo 00:37:08
cuando se haga la asignación, que es lo último 00:37:09
que se hace 00:37:12
la asignación es lo último que se hace 00:37:13
pues cuando se haga, el valor original 00:37:15
ha desaparecido, se ha visto sobre escrito 00:37:18
ya está, no pasa nada 00:37:21
Bueno, pues aquí estoy haciendo lo mismo, carácter 2 lo estoy usando para hacer esta operación y el resultado final lo sobrescribo en carácter 2. 00:37:22
Entonces, esto debería, si hemos hecho bien lo del 32, esto debería mostrarme lo que tuviera carácter 2 en mayúscula. 00:37:35
carácter 2 tiene h 00:37:49
si ejecutamos esto 00:37:51
vale, pues efectivamente 00:37:54
me lo muestra en mayúscula 00:37:58
si le pongo la x 00:37:59
carácter 2 menos 32 00:38:03
pues efectivamente la x mayúscula 00:38:09
dime 00:38:14
pero has empezado de una minúscula 00:38:14
y le has restado 00:38:21
a ver si le has sumado 00:38:23
o has empezado desde una mayúscula 00:38:24
y la has sumado, tienes que restárselo 00:38:26
bueno, es que puede que te salga un número 00:38:30
porque ya te ha salido 00:38:37
o sea, si tú, si yo 00:38:38
a cualquiera, bueno 00:38:43
a la E 00:38:45
le resto un valor 00:38:47
él se viene hacia arriba y me saldrá 00:38:49
este número 00:38:51
o igual es que has sumado algo y te ha salido de la tabla 00:38:52
no lo sé, pero vamos, lo que te haya salido 00:38:55
¿qué operación has hecho? 00:38:58
como carácter has puesto la B 00:39:03
minúscula o mayúscula 00:39:04
minúscula, vale, luego estamos en 00:39:05
y a 98 00:39:09
le has sumado 00:39:16
a la B le he sumado 10 00:39:17
le has sumado 10 00:39:19
bueno, pues si le sumamos 10 00:39:21
te tendría que salir lo que hay en 108 00:39:23
que es la L, minúscula 00:39:25
pues entonces no has hecho eso 00:39:27
seguro que sale un 1, a ver si es una L 00:39:29
no estarás jugando el 1 con la L 00:39:30
bueno, pues entonces yo os he enseñado 00:39:33
esta tabla ASTI, ahí digo 00:39:46
fijaos que cantidad de cosas 00:39:47
podemos representar 00:39:49
ya, pero si eres ruso 00:39:52
pues estás fastidiado porque te faltan 00:39:53
todos los caracteres, si no te digo si eres chino 00:39:56
¿vale? te faltan ahí 00:39:57
un montón 00:39:59
de caracteres, hombre 00:40:01
pues debería esto ser 00:40:03
un poquito más 00:40:06
pues entonces 00:40:06
Aunque el ASCII es la codificación base que se originó para poder hacer compatibles unos editores de texto con otros 00:40:09
Lógicamente se tuvo que ir ampliando 00:40:20
¿Y cuál es la ampliación natural del ASCII? 00:40:23
Pues el Unicode 00:40:28
Y Unicode usa 16 bits 00:40:30
Entonces, con unicode ya sí que podemos representar caracteres de, no sé si es de todos los idiomas del mundo, pero casi. 00:40:36
Y tenemos la suerte de que Java internamente representa los char en 16 bits y en unicode. 00:40:49
Con lo cual, en un char de Java podemos guardar cualquier carácter de unicode. 00:41:00
Entonces, de hecho, vamos a experimentar un poco, porque Unicode ya es la leche, es muy amplio, tiene muchas cosas, entonces Unicode, si buscáis la página oficial de Unicode, pues te saca aquí, vamos, un montón de caracteres, de historias, de cómo se, fijaos qué cantidad de símbolos, 00:41:16
vale 00:41:42
de hecho 00:41:44
esa es la documentación oficial 00:41:48
creo, no, espérate 00:41:50
esa es la página oficial de Unicode 00:41:52
que te, claro 00:41:54
aquí ver una tablita, sin más 00:41:56
si buscáis página oficial 00:41:59
de Unicode, pues os saldrá esto 00:42:00
unicode.org 00:42:02
aquí en una tablita no te los pueden mostrar todos 00:42:03
porque es que ya son muchos, no son 127 00:42:06
como así, son la leche 00:42:08
entonces aquí están divididos por 00:42:10
idiomas, por todo 00:42:12
pues el dibes 00:42:14
acuro este, yo que sé que es esto 00:42:16
pero fijaos que símbolos 00:42:18
tan raros tiene 00:42:20
y todos estos son representables 00:42:21
en unicode, vale 00:42:24
uy perdón, perdón, perdón 00:42:26
vale, pues lo que 00:42:29
estaba yo mostrando era 00:42:30
la página oficial 00:42:31
unicode.org 00:42:33
que una tablita única 00:42:35
no te puede poner porque son la leche 00:42:38
Entonces, este lo viene aquí dividido, pues eso, por idiomas y el kawi, pues no sé qué es, de Indonesia. Pues eso, fijaos qué simbolitos tiene tan monos. Todo esto es representable en un char de Java, porque el char tiene 16 bits. 00:42:40
Entonces, esto de aquí 00:42:59
Vamos a probar 00:43:02
Esto puede que sea 00:43:04
Que esté en hexadecimal 00:43:06
¿Vale? 00:43:07
Bueno, vamos a probar cosas, por ejemplo 00:43:10
Vamos a en un char 00:43:11
Le voy a llamar 00:43:14
Carácter raro 00:43:17
Porque es en el que vamos a hacer pruebitas 00:43:18
Yo esto no lo he probado mucho 00:43:20
Pero yo caracteres extraños, lógicamente, no uso 00:43:22
Carácter raro 00:43:24
Le vamos a dar, por ejemplo 00:43:26
si yo le doy 00:43:28
este 00:43:29
me lo coge, llega un momento en que hay uno que ya no 00:43:34
veis porque ya se sale 00:43:37
de lo que cabe en 16 bits, ya se sale 00:43:39
pero este me lo coge 00:43:41
vamos a ver que carácter es este 00:43:43
desde luego no es de la tabla ASCII 00:43:45
no sabemos saber que carácter es esta cosa 00:43:47
carácter raro 00:43:49
entonces, carácter raro 00:43:53
pues esta cosa es 00:43:58
ese carácter es 00:44:04
esa cosa 00:44:05
Y si yo le pongo este 00:44:06
Un, dos, tres, cuatro, cinco 00:44:11
Este ya es muy grande, claro 00:44:12
Si yo le pongo este 00:44:14
Pues este, mira 00:44:17
He dado con un chino, con un japonés 00:44:18
Mira que guay 00:44:21
Vale, pues es este 00:44:22
Entonces 00:44:24
Normalmente 00:44:27
Los caracteres 00:44:29
Como son sucesiones de bits 00:44:31
Se suelen representar en hexadecimal 00:44:33
¿Vale? Entonces, bueno, vamos a parar aquí 00:44:36
Luego ya 00:44:37
O sea, para aquí un segundo 00:44:38
Antes de volvernos más locos 00:44:40
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado básico
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado medio
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado superior
      • Primer Curso
      • Segundo Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
4
Fecha:
22 de septiembre de 2026 - 10:49
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
44′ 43″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
194.70 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid