Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 25-09-23 - 1 - 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 25 de septiembre de 2023 por Raquel G.

13 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues eso estábamos, ¿verdad?, estábamos poniendo ejemplos sencillos, porque ahora mismo es todo muy sencillo lo que podemos hacer a nivel de código Java, es muy sencillo lo que podemos hacer, y eso estábamos viendo, ejemplos de declaración de variables, por ejemplo, enteras, recordad que vimos los 7, 4, 5, 6, 7, 8, 8, ¿verdad?, 4 enteros, 2 de decimales, 1 char y 1 boolean, 8, 00:00:01
que habíamos mencionado los únicos ocho tipos de datos en Java que hay 00:00:25
que se les llama primitivos porque son los que vienen de serie 00:00:32
y solo tenemos esos ocho, no hay más 00:00:36
que luego queremos usar estructuras de datos más complejas 00:00:38
como nombres, como conceptos, como una variable alumno 00:00:42
que quiero que incluya su nombre, su edad 00:00:49
Pues una variable alumno no tiene sentido porque no encaja con ninguno de los datos primitivos 00:00:52
Pues habrá que inventarse algo 00:00:57
Pues es inventarse algo más adelante 00:00:59
Pero tipos de datos son estos, no hay más en Java 00:01:02
Que son los llamados primitivos 00:01:05
El tipo int era 1, así lo declarábamos 00:01:07
Ahora ya con este le asigno valor 00:01:13
Vimos que a la vez que declaro podemos ya de partida dar un valor si queremos 00:01:15
una primera asignación, esto es lo que se suele 00:01:21
llamar inicializar la variable 00:01:23
inicializarla, que es 00:01:25
darle su primer valor, inicializar 00:01:27
una variable es darle su primer valor 00:01:29
nada más, y luego ese valor puede 00:01:31
cambiar todas las veces que haga 00:01:33
falta, como consecuencia 00:01:35
de que la máquina virtual ejecute esto 00:01:37
en la cajita 00:01:39
número 1 00:01:41
se habrá creado el número 00:01:42
habrá 00:01:45
como consecuencia 00:01:46
de la declaración ya sabemos que aquí 00:01:51
se ha creado esta variable, esto ha pasado como consecuencia 00:01:55
de esta declaración de aquí, se ha creado 00:02:12
un espacio en memoria de ¿cuántos bits? 00:02:16
¿cuántos bits? 00:02:22
después de esta declaración 00:02:25
¿cuántos? 32 00:02:26
32, porque la variable entera int reservaba 32 bits 00:02:30
bueno, pues cuando la máquina virtual ya ha entrado a ejecutar esto 00:02:36
que va a poder hacerlo porque no tiene errores de compilación 00:02:39
entonces podemos entrar a ejecutar esto, cuando haya entrado a ejecutarlo 00:02:44
se habrá creado esta cajita de memoria de 32 bits 00:02:47
se le habrá asociado un nombre 00:02:51
y ahora ya las asignaciones, puede haber todas las que uno le dé la gana 00:02:54
obviamente, con esta primera asignación 00:03:00
que es la que se llama inicialización porque es la primera 00:03:02
aquí ha ido a parar un 5 00:03:04
vale, pues estupendo, ha ido a parar un 5 00:03:06
que ahora después 00:03:08
le asignamos un 15 00:03:10
pues como consecuencia 00:03:12
de la ejecución de esta sentencia 00:03:14
este 5 00:03:15
fuera, ha desaparecido 00:03:17
y ahora ya ha aparecido 00:03:19
un 15 00:03:23
¿no? ya está 00:03:25
así funcionan las asignaciones 00:03:27
cada vez que yo haga una asignación a la variable 00:03:29
el valor que tenía de antes desaparece 00:03:33
es pisado por el nuevo y ya está, así funcionan las asignaciones 00:03:36
y recordad que su sintaxis siempre es esta 00:03:40
nombre de la variable 00:03:44
operador de asignación igual y a la izquierda 00:03:47
del operador de asignación solo puede ir el nombre de la variable, no puede haber nada más 00:03:52
el nombre de la variable 00:03:57
que recibe el valor 00:03:58
y a la derecha 00:04:00
el valor que le damos 00:04:02
¿vale? el valor que le damos 00:04:04
yo ahora mismo le estoy dando un valor 00:04:06
así, a capón, el 15 00:04:08
hombre 00:04:11
para que esto sea un poquito más operativo 00:04:12
obviamente 00:04:15
y tenga más sentido 00:04:16
ese valor pues vendrá 00:04:18
de haber leído del teclado 00:04:20
de haber leído de un fichero 00:04:21
bueno, con los mecanismos que ya veremos 00:04:22
el primero de todos es leer del teclado 00:04:25
para que el usuario pueda meter el número que él quiera, claro, ¿vale? 00:04:26
Pero yo ahora mismo, como todavía no sé leer del teclado, estoy probando a hacer las asignaciones 00:04:30
a la cascándole un valor a palo seco, ¿vale? Venga, el 15, y así funciona, 00:04:34
y así puedo hacer yo todas las que quiera. 00:04:40
Aquí puedo cascar un valor a palo seco o cualquier cosa que como resultado de su evaluación me dé un valor. 00:04:43
Esto está claro que esto es una asignación compatible, ¿no? 00:04:54
Porque 15 es un número entero 00:04:56
15 es un número entero y se lo estoy asignando 00:04:58
A una variable entera 00:05:00
Es una asignación compatible 00:05:02
Claro, si yo le asigno algo 00:05:03
Que no es un número entero, me va a decir 00:05:06
No, no puedes 00:05:08
Si yo le hago 13.8 00:05:10
El punto 00:05:13
El punto 00:05:15
Es el carácter que usa Java 00:05:16
Como coma decimal, ¿vale? 00:05:18
No es la coma, es el punto 00:05:20
Bueno, pues entonces yo aquí 00:05:22
Estoy tratando de asignar 13.8 00:05:24
un número decimal a una variable que se entera 00:05:26
el compilador obviamente se queja 00:05:29
y dice, a ver, esta asignación 00:05:33
esta sentencia de asignación no es válida 00:05:35
porque esta variable la has declarado como entera 00:05:37
eso implica que solamente puede recibir 00:05:40
valores enteros, solamente 00:05:44
entonces estas son las implicaciones 00:05:47
de que Java sea un lenguaje tipado 00:05:51
que se llama, es decir, que compromete los tipos antes 00:05:53
La implicación que tiene es que condiciona mucho el código 00:05:56
Te dice, oye, número 1 a partir de ahora la tienes que asignar entero, sí o sí, no hay otra 00:06:01
Entonces eso podría uno pensar que es un poquito rígido 00:06:06
Y efectivamente lo es 00:06:10
A lo mejor se queda todo más abierto con un lenguaje de programación 00:06:11
En el cual yo digo, voy a utilizar una variable que se llame número 1 00:06:16
Y no digo qué tipo va a ser, simplemente digo que voy a utilizar una variable número 1 00:06:20
y luego le voy dando que ahora me interesa un entero 00:06:25
le doy un entero, que ahora me interesa un decimal 00:06:27
le doy un decimal 00:06:29
eso para el programador es más libre, es más abierto 00:06:30
le da mucha más libertad 00:06:33
va a ser más fácil escribir el código 00:06:34
pero puede 00:06:36
que a la hora de ejecutar las cosas 00:06:39
ocurran efectos 00:06:41
secundarios, cosas con las que no cuentas 00:06:43
de partida 00:06:45
porque como el lenguaje de programación te ha permitido hacer todo 00:06:46
a lo mejor tú has escrito algo mal 00:06:49
no querías poner aquí el puntito 00:06:51
y lo has puesto por error 00:06:52
Y no te lo detecta en fase de compilación 00:06:54
Porque como él te deja hacer de todo 00:06:57
En la fase de compilación no te lo ha detectado 00:06:59
Y es que tú a lo mejor te has equivocado 00:07:01
Luego llega el momento de ejecutarlo 00:07:03
Y te sale un error 00:07:06
Y tienes que encontrar dónde has ido 00:07:07
Y no es fácil encontrar qué es 00:07:09
Que tú te equivocaste en un momento 00:07:10
Y pusiste un punto donde no querías ponerlo 00:07:13
¿Vale? 00:07:15
Entonces de nuevo 00:07:17
Pongo de manifiesto 00:07:18
Este compromiso 00:07:21
entre lenguajes que te ponen muchas reglas, muchas restricciones 00:07:23
ahora de escribir código, que te limitan mucho 00:07:28
que esa fase te la hacen muy pesada, pero cuando consigues 00:07:32
completar todo un código, seguramente tengas muchos menos errores de ejecución 00:07:36
todo eso frente al otro extremo, lenguajes 00:07:40
que te lo dejan todo abierto, pero que 00:07:44
te puedes encontrar con cosas que tú no querías hacer, el lenguaje te ha dejado 00:07:47
hacerlas y luego tienes el problema cuando es más grave 00:07:52
que es cuando ya el programa 00:07:54
está entregado, ejecutándose, etcétera 00:07:56
cuando es más grave 00:07:58
vale, entonces bueno 00:07:59
son las dos filosofías 00:08:00
y cada lenguaje opta un poquito en función de 00:08:05
las aplicaciones prácticas que tiene cada lenguaje 00:08:08
suele optar un poquito por tender 00:08:10
más a una o por tender más a otra 00:08:12
aunque la tendencia normal es 00:08:13
a tiparlo quizá un poco 00:08:16
porque ahora mismo que las aplicaciones 00:08:18
las ejecutan millones de personas 00:08:20
pues en millones de condiciones 00:08:22
distintos, no es como antes 00:08:24
que a ti te pedía un cliente un software 00:08:26
y ese software lo ejecutaba su secretario 00:08:28
y su no se que 00:08:30
ahora la mayoría de las aplicaciones que hacemos 00:08:31
son aplicaciones que se ponen en el servidor web para que ejecute cualquiera 00:08:33
entonces queremos 00:08:36
como no controlamos, no podemos controlar 00:08:37
las condiciones en las que le van a ejecutar millones de personas 00:08:40
no podemos controlarlas 00:08:42
queremos programas 00:08:43
lo más 00:08:45
libre de errores posible 00:08:47
Para eso, si el lenguaje es más cerrado, mejor 00:08:49
Bueno, pues dicho este rollo 00:08:53
Venía esto a que si yo aquí le doy 00:08:55
Le asigno un valor que no es compatible con el tipo de dato 00:08:58
Ahí ya salta el error de compilación 00:09:02
Y si uno lo mirara aquí, pues diría 00:09:05
El tipo no coincide 00:09:08
Type mismatch, no puedo 00:09:10
Pues automáticamente, ah, sí, sí, es verdad 00:09:12
Que estoy asignando, no, que no es 00:09:15
¿Vale? Entonces, lo que pongamos aquí tiene que ser un tipo de dato igual que el que le hemos dicho aquí, ¿vale? Entonces, lo que pongamos aquí o bien es un valor a capón o bien es una expresión, algo cuya evaluación, cuya evaluación conduce a un valor de ese tipo, ¿vale? 00:09:16
Yo aquí estoy poniendo un valor directamente, pero podría poner cualquier expresión que a resultas de su evaluación, de la evaluación de esa expresión, el resultado final es un tipo de dato como el de la variedad declarada, ¿vale? 00:09:43
Por ejemplo, obviamente, yo puedo poner aquí, venga, ahora voy a cambiar número 2, la voy a cambiar y número 2 va a ser 65 por 9, ¿vale? 00:09:58
Entonces tenemos como siguiente parte, ahora un poquito después, ver cómo construir expresiones válidas, porque claro también hay reglas sintácticas para construir expresiones válidas, también hay reglas sintácticas, entonces tenemos que saber cuáles son las reglas que me da Java para construir expresiones válidas. 00:10:08
Bueno, algunas son de cajón 00:10:27
Los operadores más, menos, por y división 00:10:30
Pues son los de toda la vida 00:10:34
Entonces, a lo que íbamos 00:10:36
Lo que yo pongo a la derecha del operador de asignación 00:10:41
Puede ser cualquier expresión 00:10:44
Ya veremos que reglas para construir expresiones tenemos 00:10:47
Cualquier expresión 00:10:50
De tal forma que al evaluarla me dé un contenido válido 00:10:51
65 por 9, pues me da un valor entero 00:10:55
pues entonces lo puedo asignar 00:10:58
y siguiente salto 00:11:00
los valores que yo pongo aquí 00:11:03
pueden ser valores 00:11:06
directamente tal cual que yo los estoy escribiendo 00:11:07
o pueden ser a su vez variables 00:11:10
que es donde cobra interés 00:11:13
obviamente ya el código 00:11:15
por ejemplo yo quiero 00:11:17
que número 2 tenga 00:11:19
el doble de lo que tiene número 1 00:11:21
y yo no sé lo que tiene 00:11:23
número 1 00:11:25
vale, vamos a hacer que número 2 tenga el doble del valor que tiene número 1 00:11:26
no sabemos que valor tiene número 1, si lo supiéramos podríamos poner 2 00:11:53
por ese numerito que sabemos cual es, no lo sabemos 00:11:57
pero bueno, yo puedo construir una expresión 00:12:00
de asignación que sea esta, verdad, número 1 por 2 00:12:03
vale, y esta asignación de nuevo es perfectamente válida 00:12:09
Porque aquí hay una expresión que hay que evaluar y que me conduce a un número entero. 00:12:13
Entonces, siguiente salto, importantísimo y interiorizar. 00:12:20
Las expresiones que se ponen aquí para obtener valores, para asignar, esas expresiones pueden contener variables, por supuesto, no hay ningún problema. 00:12:26
Y entonces, ¿qué es lo que hace la máquina virtual de Java cuando ejecute esto? 00:12:37
Cuando se encuentra aquí un nombre, dice, uy, vamos a ver, número 1, esto tiene que ser una variable, pues se va a buscar si la variable está declarada, ay, sí, sí, qué bien, está declarada, porque si no estuviera, diría, uy, estás tratando de usar una variable que no existe, y te haría un error de compilación. 00:12:45
entonces lo primero que hace es 00:13:06
me estás diciendo que use 00:13:10
el valor de una variable, vale, vale 00:13:12
lo uso, voy a ver primero si la tienes 00:13:14
declarada, la tienes declarada, vale 00:13:16
ahora que ya ha verificado 00:13:18
que la tiene declarada, se va a buscar 00:13:20
el valor que tiene en este 00:13:22
momento, en el momento de ejecutar esta sentencia 00:13:24
el valor que tiene 00:13:26
se va a buscarlo, pues bueno 00:13:27
en este caso en particular la última 00:13:29
asignación que se hizo fue esta 00:13:32
esta fue la última que se hizo 00:13:33
Pues entonces, la máquina virtual lo que hace es 00:13:35
Coger el valor que tiene esta variable 00:13:40
Que en este caso concreto es 138 00:13:43
Pero bueno, porque es lo último que le hemos asignado 00:13:45
Multiplicarlo por 2 00:13:48
Y como eso devuelve un número entero 00:13:49
La asignación es perfectamente compatible 00:13:53
Y no da ningún error de compilación 00:13:56
Luego, este es el primer avance interesante 00:13:57
Que tenemos que tener claro 00:14:03
En la expresión que se pone, en la expresión que se usa para obtener el valor a asignar a una variable, a una variable, puede haber a su vez otras variables, ¿vale? 00:14:04
Y podría haber muchas más 00:14:34
Podría haber todas las variables involucradas que yo quisiera 00:14:37
Por ejemplo, podría poner esta expresión 00:14:42
Número 1 por 2 menos número 1 00:14:44
Podría perfectamente poner esta expresión 00:14:48
El contenido de la variable número 1 00:14:51
El contenido que tenga en ese momento lo multiplico por 2 00:14:55
Y el resultado le resto número 1 00:14:58
Perfectamente 00:14:59
Y no solo eso 00:15:01
podría incluso 00:15:04
usar 00:15:09
siguiente salto 00:15:11
importante de entender y tener claro 00:15:13
podría usar 00:15:16
en la expresión que 00:15:17
construyo 00:15:19
para obtener el valor a asignar 00:15:20
en la expresión que construyo, podría usar 00:15:23
la propia variable número 2 00:15:25
no hay ningún problema 00:15:27
vale, podría usarla 00:15:28
bueno, pues esta 00:15:31
Esta sentencia en particular, ¿qué es lo que implicaría a la hora de ejecutarla? 00:15:34
¿Qué es lo que haría la máquina virtual cuando se encontrara esta sentencia? 00:15:41
Pues primero, evalúa la expresión, evalúa la expresión con los valores que tenga número 1 y número 2 en ese momento. 00:15:45
En este momento, pues número 1 tiene lo que tuviera, 138, y número 2 tendrá lo que tenga, en este caso el resultado de haber hecho esto, lo que sea, me da igual. 00:15:54
Bueno, pues usa los últimos valores que tenía esas variables, los últimos que es el único que tiene, vamos, construye, evalúa la expresión, evalúa la expresión y una vez que ha obtenido el valor, lo asigna a número 2 pisando el que tuviera antes, ¿vale? 00:16:09
el que tuviera antes lo pisa, luego para evaluar la expresión coge el valor de número 2 que tenga en ese momento, lo evalúa y cuando ya lo tiene, número 2 se queda pisado por el nuevo valor, vale, por ejemplo, si esta fuera la situación, para hacer los cálculos rápido, resulta que yo ahora he hecho esto, yo ahora hago esto, esta asignación, pues me da igual los valores que hubiera de antes, 00:16:28
Número 1 y número 2 se quedan pisados 00:16:57
Y se quedan así 00:17:00
Vale, aquí tengo mis dos variables 00:17:02
Número 1 y número 2 00:17:21
A número 1 le he puesto un 4 00:17:22
Pues venga, a número 1 le he puesto un 4 00:17:24
Ala, ya tiene un 4 00:17:28
Lo que tuviera de antes se acabó 00:17:30
Imposible recuperar ese valor de antes 00:17:32
Se acabó, cuando uno hace una asignación 00:17:34
El valor anterior de la variable 00:17:36
Para siempre ha desaparecido 00:17:38
La variable se queda con el nuevo 00:17:39
Que yo doy, se queda con el nuevo 00:17:41
Luego a resultas de esto, número 1 se queda valiendo 4 00:17:43
Y lo que hubiera de antes, imposible recuperarlo 00:17:49
Vale, a resultas de esto, número 2 se queda valiendo 5 00:17:52
Y lo que hubiera de antes, imposible recuperarlo 00:17:57
Vale, ahora ya llega esta sentencia 00:18:02
Bueno, pues la máquina virtual primero se va aquí, primero se va ahí 00:18:05
es lo primero que mira, la parte derecha, la izquierda la ignora por el momento 00:18:09
y dice, vale, una expresión en la que me están dando 00:18:14
nombres que se supone que serán nombres de variables 00:18:19
vamos a verificar si están declaradas, ah pues sí, están declaradas 00:18:21
pues ahora voy a coger sus valores y voy a operar con ellos 00:18:26
el valor de número 1 es 4, pues coge 4, 4 por 2, 8 00:18:31
ahora me toca coger el valor de número 2, cojo número 2 que es 5 00:18:35
8 menos 5, 3, a número 2 va 3 00:18:39
Pues ya está, entonces ahora este valorcito 3 00:18:42
Lo usa para pisotear lo que hubiera en número 2 00:18:45
Y de lo que hubiera antes nunca más se supo 00:18:49
Entonces el resultado de esta expresión es que en número 2 00:18:51
Se queda ahora el 3 00:18:55
Se queda el 3 y ya está 00:19:02
¿Vale? 00:19:05
Bueno, ¿está claro? 00:19:11
Entonces, a la derecha de una asignación se puede poner cualquier expresión, siempre y cuando siga, use unos operadores y siga unas reglas que tendremos que ver. 00:19:13
Se puede poner cualquier expresión, punto uno. 00:19:26
Y punto dos, esa expresión a su vez puede involucrar variables, puede involucrarlas, claro, no hay problema, no tiene por qué ser siempre con valores que yo le ponga así a capón, puede involucrar variables. 00:19:29
Y para involucrar variables las referencio con su nombre 00:19:38
De ahí la importancia de declarar una variable y darle el nombre 00:19:42
Porque luego me tengo que poder referir a ella cuando la quiero usar 00:19:46
Pero yo puedo referirme de alguna manera 00:19:49
Pues me refiero a ella por su nombre 00:19:50
Bueno, pues esa expresión puede involucrar variables 00:19:53
Que quede muy clara obviamente la diferencia entre usar esta cadena de caracteres así y así 00:19:56
Así no tendría ningún sentido esta asignación 00:20:06
Cuando en Java y en cualquier lenguaje de programación prácticamente 00:20:11
Uno pone una cadena de caracteres entre comillada 00:20:15
Lo que está diciendo es 00:20:20
Esa cadena de caracteres literal tal cual 00:20:22
Eso, no el contenido de la variable que se llama así 00:20:25
No, sino esa cadena tal cual 00:20:28
Entonces aquí multiplicar una cadena de caracteres por dos 00:20:30
¿Qué sentido tiene eso? Ninguno 00:20:34
Una cadena de caracteres no se multiplica por dos, por dos se multiplican números, no se multiplica una cadena de caracteres. 00:20:36
Entonces, obviamente, aquí el compilador dice, pero ¿qué estás haciendo? 00:20:43
Si me lo entre comillas, no me estás diciendo la variable que se llama número uno, me estás diciendo la cadena de texto número uno. 00:20:46
Y esa cadena de texto, ¿qué sentido tiene multiplicarla por dos? Ninguno. 00:20:54
Esa cadena de texto puede tener su sentido en otras sentencias que queramos usar con cadenas de texto, 00:20:59
pero en esta obviamente ninguna 00:21:05
¿vale? 00:21:06
entonces sin entrecomillar 00:21:09
sin comillas dobles 00:21:11
solo hay una interpretación de eso 00:21:12
solo hay una 00:21:15
que es 00:21:16
el contenido de la variable que se llama así 00:21:18
¿vale? 00:21:21
cuando vemos un identificador 00:21:22
un identificador sin comillas 00:21:24
un identificador 00:21:27
solo tiene una interpretación 00:21:28
que es el contenido de la variable 00:21:30
que se llama así 00:21:32
y con ese contenido ya cogemos para operar y para hacer lo que toque 00:21:33
multiplicar, restar, sumar, dividir, lo que sea 00:21:38
y como consecuencia de esa expresión nos da un valorcito 00:21:41
y eso ya lo asignamos 00:21:44
vale, pues esto estamos con asignaciones 00:21:48
hasta aquí todo clarísimo 00:21:55
vale, esto 00:21:58
hay muchas posibilidades 00:22:01
desde los cuales os parezca 00:22:04
evidente 00:22:06
hasta los que nunca os hayáis 00:22:07
aproximado a ese tipo de cosas 00:22:10
y os pueda parecer algo evidente 00:22:11
pero si no lo volvéis a pensar 00:22:15
luego por vuestra cuenta, mañana ya 00:22:16
no lo hacéis mal 00:22:18
¿vale? entonces 00:22:19
cuidado con aunque os parezca 00:22:22
evidente, aunque os parezca 00:22:26
en algunos casos, si no habéis trabajado 00:22:28
nunca con esto 00:22:30
Luego tenéis que darle vuestro vistazo 00:22:31
Y interiorizarlo todo, siempre 00:22:33
Recordad que insisto 00:22:35
Vuestra parte es, ahora mismo 00:22:36
Atender y escuchar 00:22:39
Si algo no queda claro, preguntarme 00:22:41
En casa 00:22:44
Mirarlo y estudiarlo todo 00:22:45
Y a la cabeza 00:22:47
Y lo que no haya quedado claro 00:22:48
Después de ese proceso, al día siguiente preguntarlo 00:22:52
Esa es la parte vuestra 00:22:54
¿Vale? 00:22:55
Bueno, pues seguimos con asignaciones 00:22:58
asignaciones, matices de asignaciones 00:23:00
que tenemos que ir matizando 00:23:04
aquí claro, es que hay muchísimas cosas 00:23:08
que hay que ir incorporando, muchísimas cosas 00:23:11
hasta que se puede empezar a hacer unas cositas 00:23:14
y luego después si hay muchísimos contenidos que hay que ir incorporando 00:23:17
entonces bueno, vamos poco a poco 00:23:20
vale, pues más matices relacionados con asignaciones 00:23:23
Andrés me distraes 00:23:26
con el ruido de fondo 00:23:31
que me distraes con el ruido de fondo 00:23:35
hablando 00:23:37
vale, pues a ver 00:23:38
hemos dicho que 00:23:40
una asignación para que el compilador 00:23:42
no diga, ¿qué estás haciendo? 00:23:45
le tenemos que dar como valor de asignación 00:23:48
un valor del tipo de dato 00:23:50
que hay aquí 00:23:53
Bueno, esto tiene matices 00:23:54
Matices que nos dan un poquito de flexibilidad 00:23:58
Que son los matices que vamos a incorporar ahora 00:24:00
¿Vale? Lo voy a poner aquí 00:24:02
Luego este proyecto 00:24:04
Lo subo a la virtual 00:24:06
Por si a alguien los comentarios o algo le viene bien 00:24:08
Tenerlos ahí subidos 00:24:10
¿Vale? 00:24:12
Matices en cuanto a 00:24:16
La compatibilidad 00:24:18
de datos 00:24:21
en las 00:24:24
asignaciones 00:24:29
matices, vale 00:24:30
a ver, nosotros hemos dicho 00:24:32
que números 00:24:35
enteros 00:24:37
tenemos varias posibilidades 00:24:37
tenemos el tipo byte, el short, el 00:24:40
int y el long, ¿verdad? todo eso lo tenéis 00:24:43
memorizado 00:24:44
¿y por qué elegimos uno? 00:24:45
¿por qué elegimos otro? pues en función 00:24:49
de cómo de grande pueden llegar 00:24:50
a ser los números que van a 00:24:52
caer en esas variables 00:24:54
byte es que solo tiene 8 bits 00:24:55
ocupa poquito en memoria RAM, no molesta 00:24:58
pero con 8 bits hay muy poquitos números 00:25:00
que se puedan guardar, 2 elevado a 8 00:25:02
es poquito 00:25:04
con short un poquito más, 2 elevado a 16 00:25:05
pero short tampoco es muy grande 00:25:08
int es el que más se suele usar 00:25:10
porque son 32 bits, con 32 bits 00:25:12
se pueden codificar valores absolutos muy grandes 00:25:14
y con long muchos más 00:25:16
bueno pues entonces 00:25:18
int y long son relativamente usados 00:25:20
entonces 00:25:23
vamos a suponer que declaramos aquí una variable long 00:25:25
porque vamos a utilizar un número 3 00:25:27
una variable número 3 00:25:29
que preveo que va a tener valores muy grandotes 00:25:33
vale 00:25:35
bueno pues entonces 00:25:37
vamos a suponer 00:25:39
que a número 3 00:25:41
yo le voy a asignar ya directamente por ahorrar 00:25:42
una línea en la declaración 00:25:45
le voy a hacer 00:25:47
una primera asignación, lo que se llama inicializar 00:25:49
y le asigno el 6 00:25:51
entonces la máquina virtual lo que hace 00:25:52
cuando ve esta inicialización 00:25:55
pues coge ese 6 00:25:56
lo codifica binario 00:25:59
pero lo guarda en una variable de 64 bits 00:26:01
que es número 3 00:26:04
ahí están los 64 bits 00:26:05
aunque en este caso solamente están ocupados 00:26:07
los primeritos porque el 6 es muy pequeño 00:26:09
ahí están los 64 bits 00:26:12
bueno, entonces resulta 00:26:13
que yo ahora quiero a la variable 00:26:16
número 2 00:26:17
a la variable número 2 00:26:18
le quiero asignar lo que tenía la 3 00:26:21
esto en principio 00:26:24
tiene sentido, porque ambas 00:26:26
tienen números enteros, y resulta que 00:26:28
en algún momento de mi aplicación a mi me ha llegado una variable 00:26:29
long, me ha llegado una variable 00:26:32
y yo quiero recoger su valor en una variable mía 00:26:33
pero tengo restricciones en esa variable 00:26:35
mía y tiene que ser int, porque esa variable tiene que ser 00:26:38
int por cuestiones 00:26:40
varias, tengo restricciones 00:26:42
pero yo quiero recoger el valor que me han pasado 00:26:43
en esa, son situaciones 00:26:45
que se dan mucho cuando nos pasan valores a través de 00:26:48
métodos, cuando ya veamos lo que son métodos 00:26:50
o hoy te pasan un valor, te lo pasan 00:26:51
de un tipo que no puedes elegir, te lo pasan 00:26:54
del tipo que a él le dé la gana, no puedes 00:26:56
elegirlo y a lo mejor tampoco puedes 00:26:58
elegir la variable en la que cae el valor 00:27:00
que te han dado, a lo mejor no puedes elegirlo porque estás haciendo 00:27:02
una parte del programa y no puedes 00:27:04
modificar lo demás, bueno pues esa situación 00:27:05
esa situación muy habitual 00:27:08
cuando estamos utilizando código o cogiendo 00:27:09
podría ser esta 00:27:12
yo quiero asignar a mi variable 00:27:14
número 2, que está aquí declarada 00:27:16
y es entera 00:27:18
le quiero asignar 00:27:19
lo que tenga la variable número 3 00:27:22
y ambas son números enteros 00:27:24
entonces tendría sentido que yo quisiera 00:27:26
hacer esto, esto tiene sentido 00:27:28
es defendible 00:27:29
o sea, no sería defendible 00:27:31
si yo a una 00:27:34
variable boolean le quiero asignar 00:27:36
lo que me han pasado en una int 00:27:38
algo has diseñado mal en tu programa 00:27:40
es estúpido que tú quieras una variable boolean 00:27:42
asignarle lo que te lleva a una int, no tiene ningún sentido 00:27:44
la variable boolean solo puede tener true o false 00:27:46
eso 00:27:48
algo te has planteado muy mal en tu programa 00:27:49
pero que a una variable log 00:27:52
le quieras asignar 00:27:54
lo que te han traído en una int 00:27:55
o viceversa, si que tiene sentido 00:27:58
pues en números enteros 00:28:00
vale, pues eso es lo que vamos a hacer aquí 00:28:01
vamos a asignar a mi variable número 2 00:28:04
lo que me ha venido por la número 3 00:28:05
vale 00:28:07
yo hago esto 00:28:10
bueno, pues como podíais sospechar 00:28:11
Como podíais sospechar 00:28:14
El compilador 00:28:16
Que es muy 00:28:19
Toca pelotas 00:28:20
Pues dice 00:28:22
No, lo siento mucho 00:28:24
Dice 00:28:26
Lo siento, tipos 00:28:28
Los tipos no encajan 00:28:30
Ahí hay un mismatch 00:28:32
No encajan los tipos 00:28:34
No encajan 00:28:35
Pues sí, que sea tipado está muy bien 00:28:36
Pero no me puedo creer 00:28:40
Que yo no pueda asignar 00:28:42
un número entero a otro 00:28:44
¿cómo puede ser que no pueda ser un número entero a otro? 00:28:45
es que es demasiado, demasiado restringido 00:28:47
bueno, tiene sentido 00:28:50
que te haga esta restricción, tiene sentido 00:28:52
porque lo que te está diciendo es 00:28:54
cuidado 00:28:55
si yo te dejo hacer esta asignación 00:28:57
puede que pierdas información 00:29:00
porque número 3 aquí es 6 00:29:02
nosotros en este caso en particular 00:29:04
en este caso sabemos que no perderíamos 00:29:06
información porque el 6 00:29:08
cabe en 32 bits 00:29:09
¿verdad? el 6 cabe en 32 00:29:12
entonces yo puedo asignar 00:29:14
el 6 que en este caso 00:29:16
puntualmente tiene número 3 00:29:18
lo puedo asignar al número 2, porque cabe 00:29:20
pero si yo aquí en número 3 00:29:22
pongo un número muy grandote 00:29:24
me he pasado 00:29:26
bueno, es que no quiero 00:29:28
poner esto todavía, bueno, vamos a 00:29:37
pongo un número muy grandote 00:29:38
uno muy grande 00:29:40
que no cabe 00:29:42
en 32 bits 00:29:44
pongo uno muy grande que no cabe en 32 bits 00:29:46
tendría sentido el compilador se queje 00:29:48
porque me diría, oye, es que no cabe 00:29:50
yo vale, yo te guardo 00:29:53
los 32 bits menos significativos 00:29:55
de tu variable long 00:29:57
pero el número va a cambiar completamente 00:29:58
el número va a cambiar, vas a perder información, está claro, ¿no? 00:30:01
si 64 bits 00:30:03
solo nos quedamos 00:30:05
con los 32 primeros 00:30:07
si coincide que los 32 últimos eran 0 00:30:08
no pasa nada 00:30:11
como en el caso de 6, 69, no pasa nada 00:30:12
pero si no eran 0 00:30:14
hemos cambiado el número 00:30:16
entonces tiene sentido el compilador haga esto 00:30:17
¿vale? entonces la asignación 00:30:20
de long a int no te la deja hacer 00:30:22
no te la deja hacer 00:30:24
podemos hacer un apaño del que hablaremos luego 00:30:25
para que me deje porque yo tengo esa 00:30:28
restricción sí o sí y me han 00:30:30
dado un número en long y yo tengo 00:30:32
que guardar una variable en int para poder seguir 00:30:34
y me arriesgo, si alguna vez me lo pasan muy grande 00:30:36
pues me arriesgo a perder información 00:30:38
asumo que la mayoría de las veces no será tan grande 00:30:40
entonces tengo un truco 00:30:42
para poder saltarme este error 00:30:43
que veremos después, pero tiene sentido 00:30:46
que el compilador no me deje 00:30:48
¿vale? entonces esto 00:30:49
cuadra con lo que he 00:30:52
dicho antes de que las asignaciones 00:30:56
tienen que ser compatibles, lo que yo 00:30:58
asigno, mismo tipo de datos 00:31:00
que la variable a la que va a parar 00:31:02
pues cuadra con esto 00:31:04
que me está pasando aquí, cuadra 00:31:06
vale, pero claro y si yo luego al revés 00:31:07
si que no tendría sentido que el compilador se pusiera 00:31:10
pejiguero, o sea, si yo a una variable 00:31:14
long le asigno 00:31:16
una variable int 00:31:19
ahí no tiene sentido 00:31:20
que me diga, oye, no es el mismo tipo 00:31:22
porque es que ahí nunca se va a perder 00:31:24
información, ¿no? una variable int 00:31:26
ocupa 32 bits, si yo su valor 00:31:28
lo asigno a una long, lo único que va a 00:31:30
ocurrir es que los 32 más significativos 00:31:32
se van a rellenar con ceros, nada más 00:31:34
pero el valor de la variable 00:31:35
el valor absoluto no se va a tocar 00:31:38
va a ser perfectamente el mismo 00:31:39
entonces hombre, ahí ya si transige 00:31:42
vale 00:31:44
aquí ya si que transige 00:31:45
voy a dejar esto comentado 00:31:48
y si yo a número 3 00:31:49
le asigno 00:31:53
lo que tiene 00:31:55
número 2, aquí el compilador 00:32:02
no me dice nada 00:32:04
vale, se calla 00:32:05
y no es verdad 00:32:07
que el tipo sea el mismo 00:32:10
número 2 es tipo int y número 3 00:32:11
es tipo long 00:32:14
vale 00:32:15
Pues es que la excepción en la regla general que yo he dicho, la excepción en la regla general que el valor que se pone de asignación tiene que ser del mismo tipo asignado, la excepción es cuando tú puedes convertirlo sin perder información, cuando nunca vas a perder información. 00:32:17
hay muy pocas situaciones en las que eso ocurra 00:32:38
pues una es esta 00:32:41
que es la típica, la estándar 00:32:41
asignar un valor int a una variable long 00:32:44
se puede hacer 00:32:47
el compilador te deja, porque no quieres 00:32:49
información, y esto es lo que se llama 00:32:51
promoción automática 00:32:53
lo voy a escribir aquí en comentarios 00:32:54
vamos a ver 00:32:56
la siguiente asignación 00:32:57
no la podemos 00:33:03
hacer 00:33:07
porque podríamos perder 00:33:07
parte del valor 00:33:12
parte del 00:33:24
contenido de número 3 00:33:29
parte del contenido de número 3 00:33:35
si este 00:33:39
ocupa más de 32 bits 00:33:41
¿verdad? 00:33:43
aquí podríamos perderlo, si el valor de número 3 00:33:49
ocupa más de 32, que podría ser 00:33:51
porque es una variable log, lo perderíamos 00:33:53
entonces el compilador 00:33:55
no te deja, esta no te deja 00:33:57
Pero sin embargo 00:33:59
La siguiente 00:34:04
Si podemos 00:34:10
Porque nunca 00:34:12
Perderíamos 00:34:16
Información 00:34:20
Como lo queréis expresar 00:34:22
En el contenido de número 1 00:34:25
Perdón, de número 2 00:34:27
Número 2 00:34:30
Nunca lo perderíamos porque número 2 00:34:39
Son 32 bits 00:34:41
¿Vale? 00:34:42
Entonces, ¿qué es lo que hace la máquina virtual cuando ve eso? 00:34:44
Dice, estupendo, no pasa nada, número 2 es entero 00:34:47
Vale, no es long, bueno, no pasa nada 00:34:49
Pero el número 2 ocupa 32 00:34:52
Entonces no pasa nada, ¿qué es lo que hace? 00:34:53
Coge ese valor 00:34:56
Le pone los ceros que hagan falta 00:34:56
Hasta llegar a los 64 00:35:00
Y ahora ya ese valor ya almacenado 00:35:01
Como 64 bits, siendo el mismo 00:35:04
Si es 69, pues es de 9 00:35:06
Siendo el mismo, pero ya como 64 bits 00:35:07
Lo guarda en número 3 00:35:10
¿Vale? Pero lo amplía hasta 64 bits 00:35:12
porque lo tiene que guardar en la variable número 3 00:35:14
y número 2 por supuesto sigue siendo la variable entera 00:35:17
en ningún momento número 2 cambia ese tipo de datos 00:35:21
número 2 sigue siendo un espacio en RAM de 32 00:35:23
pero su contenido cuando se ha extraído su contenido para copiarlo 00:35:25
su contenido es el que se ha ampliado a 64 00:35:32
pero número 2 sigue siendo su espacio de 32 00:35:35
pues este proceso que hace la máquina virtual 00:35:37
que hemos dicho de coger el contenido, ampliarlo a 64 00:35:40
porque no pierde valor con eso 00:35:43
y llevarlo a número 3 00:35:45
esto es lo que se llama 00:35:47
promoción automática de variables 00:35:49
promoción automática 00:35:52
sin de variable 00:35:56
que eso es más confuso 00:35:58
promoción automática se llama 00:35:59
este es un caso en el que se hace y se puede hacer en algunos otros 00:36:01
vale bueno pues 00:36:07
vamos a 00:36:08
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
13
Fecha:
25 de septiembre de 2023 - 12:53
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
36′ 10″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
690.25 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid