Saltar navegación

20240923 ProgrEstruct-Variables_8 - 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 23 de septiembre de 2024 por Raquel G.

15 visualizaciones

Más información Transcripción

Descargar la transcripción

Pues que no se ría, silencio. 00:00:00
Que nadie se ría ni haga nada. 00:00:02
Vale, pues entonces, 00:00:04
The Flow at the Double, un poco más. 00:00:05
¿Vale? Sabemos que son tipos primitivos y para qué se usan. 00:00:08
¿Vale? Por ejemplo, 00:00:11
vamos a hacer una última cosita 00:00:12
antes de saltar 00:00:13
a otra cosa. 00:00:14
Por ejemplo, vamos a meter 00:00:18
un... 00:00:21
Bueno, no, no, no, porque eso nos va a llevar a otra cosa. 00:00:25
Ya lo haremos. Vale, nada. 00:00:27
bueno, pues ya está, ninguna duda sobre esto 00:00:29
vale, ¿qué más tipos de datos 00:00:31
primitivos teníamos? hemos visto 00:00:34
números enteros 00:00:35
byte, short, int y long 00:00:37
números decimales, con par de decimal 00:00:38
float y double 00:00:41
y luego el de verdadero o falso 00:00:42
muy bien, vale, algo habéis estudiado 00:00:45
vale, vale, muy bien 00:00:48
tenemos efectivamente era el char y el boolean 00:00:49
vale, bueno, pues entonces 00:00:51
vamos a 00:00:54
ver aquí en este 00:00:56
proyecto 00:00:57
de variables 00:00:58
ejemplos de variables enteras, lectura de teclado 00:01:03
vamos a hacer otra clase 00:01:05
para ejemplo char 00:01:08
claro, tenemos ya nuestra clasecita 00:01:12
lo digo porque como este proyecto lo subiré a la ola virtual 00:01:17
nuestra clasecita con los ejemplos de variables enteras 00:01:20
que hemos hecho 00:01:23
nuestro ejemplo con lectura del teclado 00:01:24
Y ahora nuestra clase cita 00:01:27
Para ejemplo 00:01:29
Y se me ha olvidado escribir 00:01:30
Pero marcar que haga solo este método 00:01:34
Pero no pasa nada 00:01:37
Porque lo sabemos de memoria 00:01:39
Entonces si no hemos marcado el check 00:01:41
Pues lo escribimos aquí estupendamente 00:01:43
Vale 00:01:45
Para que usamos 00:01:47
Para que usamos una variable 00:01:50
De tipo char 00:01:53
Única y exclusiva 00:01:54
Solo vale para una cosa, para guardar un único carácter, nada más. 00:01:56
Para guardar un único... 00:02:02
¡Silencio! 00:02:03
Para guardar un único carácter, ¿vale? 00:02:07
Para eso vale, ya está. 00:02:10
Entonces, si nosotros le queremos hacer una asignación tal cual, 00:02:12
quiero guardar el carácter dólar. 00:02:16
Pues no pasa nada, podemos asignar cualquier cosa que sea un char. 00:02:20
¿Y cómo indicamos que algo es un char? 00:02:23
Con comillas simples 00:02:26
Con comillas simples 00:02:29
Esta es la única manera de indicarlo 00:02:31
Nada de comillas dobles 00:02:33
Si yo pongo una comilla doble 00:02:34
Obviamente la he cagado 00:02:37
El compilador me da un error 00:02:40
Porque me dice, oye, este tipo no es compatible 00:02:42
Con una variable char 00:02:44
Bueno, busca en tu teclado 00:02:46
Yo la tengo arriba, debajo de la interrogación 00:02:50
entonces, cuando uno 00:02:53
quiere poner un char 00:03:05
se ve 00:03:06
el tamaño de letra se ve desde atrás 00:03:08
entonces, cuando yo quiero 00:03:11
poner un char a capón, comillas simples 00:03:20
¿vale? no hay otra 00:03:23
alternativa 00:03:24
¿y ahí qué char puedo poner? 00:03:25
el char que me dé la gana 00:03:28
cualquier carácter 00:03:30
cualquier carácter 00:03:32
de los que se escriben en un teclado 00:03:33
cualquier carácter puedo poner 00:03:35
lo que a mí me dé la gana 00:03:36
¿vale? un char 00:03:37
bueno, cuando tú necesites 00:03:38
un carácter para algo 00:03:46
pues a lo mejor estás metiendo una entrada 00:03:47
donde quieres guardar sí o no 00:03:49
lo típico, introduzca 00:03:51
S o N 00:03:53
El char ese para decir que sí 00:03:54
El char para decir que no 00:03:57
En las situaciones en las que una variable 00:03:59
Que guarda un único carácter pueda tener su interés 00:04:01
Normalmente 00:04:03
A ver, la pregunta tiene sentido 00:04:05
Porque un carácter por sí mismo 00:04:06
Es cierto que poca información tiene 00:04:08
Normalmente el char 00:04:10
Para lo que vale es para usarlo 00:04:12
En un tipo de dato ya complejo objeto 00:04:14
Y muchos char 00:04:16
Ya te hacen una cadena 00:04:18
¿Vale? Eso ya lo 00:04:19
Pero el char es un único carácter 00:04:21
Vale, ¿qué caracteres podemos poner aquí? 00:04:24
Cualquier carácter de la tabla ASTI 00:04:28
Cualquier carácter que esté recogido en la tabla ASTI 00:04:31
Vamos a buscar aquí que es una tabla ASTI 00:04:35
A ver si nos sale una bonita 00:04:39
Por ejemplo 00:04:42
Esto es una tabla ASTI 00:04:47
Que te guarda 00:04:51
Te indica 00:04:53
te indica todos los caracteres 00:04:54
imprimibles por los editores de texto 00:04:56
¿Veis? Todos, espacio, 00:04:58
ordenación, todos estos que están aquí 00:05:00
a la 00:05:02
derecha de cada columna son todos 00:05:04
los caracteres imprimibles 00:05:06
por los editores de texto. 00:05:08
Todos estos son imprimibles. 00:05:10
Estos son los de 00:05:12
toda la vida. Luego está el extendido 00:05:14
donde tienes más caracteres. 00:05:16
Estos son caracteres 00:05:19
así, lo que pasa es que estos no son 00:05:21
imprimibles, imprimibles significa 00:05:22
que si un editor de texto se los 00:05:24
encuentra, tú no los ves 00:05:26
o sea, están ahí guardados en el fichero 00:05:28
pues como el fin de línea, nueva página 00:05:30
no se ven 00:05:32
pero están ahí para indicar que hay un salto 00:05:34
de línea, que hay un fin de fichero 00:05:36
¿vale? entonces todo esto de aquí 00:05:37
son caracteres de la tabla ASCII y en 00:05:39
particular, estos de aquí son 00:05:42
los que se llaman imprimibles, entonces cuando un editor 00:05:44
de texto, un blog de notas, el WordPad 00:05:46
el que sea 00:05:48
está leyendo bits de un fichero de texto 00:05:49
él los va cogiendo de 8 en 8 00:05:52
coge el primer pack de 8 bits 00:05:54
mira a ver el numerito que codifica 00:05:56
codifica el 40, pues se va a la tabla 00:05:58
y mira que en el 40 00:06:01
hay una, un este, pues entonces 00:06:03
planta en tu blog de notas ese simbolito 00:06:04
vale, se coge el siguiente pack 00:06:07
de 8 bits 00:06:09
codifica el 139 00:06:09
pues se va a la tabla 00:06:12
139 es este, pues coge este 00:06:14
simbolito, lo ahí condieres y te lo planta en el editor de texto 00:06:16
vale, así funcionan los editores de texto 00:06:19
cogen los ficheros, van cogiendo 00:06:21
de 8 en 8, se van a la tabla 00:06:23
ASTI para ver a qué carácter 00:06:25
corresponde el numerito que hay codificado 00:06:27
en binario en esos 8 bits 00:06:29
y luego eso aparece 00:06:31
impreso y tú ya lo ves, eso forma un texto y lo que sea 00:06:33
¿vale? y cuando guardamos 00:06:35
escribimos en el blog 00:06:38
de notas un fichero de texto con el teclado 00:06:39
Pepito se fue a navegar 00:06:41
y luego le damos a guardar, pues lo mismo 00:06:43
ese editor 00:06:45
Pepito coge la P, la P 00:06:47
¿dónde está la p? aquí 00:06:49
80, vale, mando 00:06:51
un byte que codifica 80 00:06:53
al fichero, pepito, ¿dónde está la e? 00:06:55
aquí, 69, muy bien 00:06:58
pues cojo 69, lo codifico en binario 00:06:59
al fichero, ¿vale? así es como funcionan 00:07:01
los editores de texto 00:07:03
guardando en los ficheros de texto 00:07:05
números enteros 00:07:07
cada uno de ellos en 8 bits 00:07:09
8 bits, 8 bits 00:07:11
y a la hora de verlo ya y representarlo 00:07:12
en el editor, se corresponden con 00:07:15
este símbolo 00:07:17
¿Vale? ¿Te ibas a preguntar algo? 00:07:18
Vale, pues muy bien. 00:07:22
Pues entonces, como por tanto cada carácter imprimible, cada char para Java, 00:07:26
tiene una correspondencia con un número entero, pues para facilitar esa flexibilidad, 00:07:32
nosotros también podemos inicializar caracteres char de esta manera. 00:07:39
Por ejemplo, pongo ahí un entero y me lo ha permitido. 00:07:46
entonces, la máquina virtual de Java 00:07:49
al ver el 90 diría 00:07:52
este es el número entero 90 00:07:53
pero luego ve que le toca a un char 00:07:56
entonces dice, ah, vale 00:07:58
no te refieres al número entero 90 00:07:59
te refieres, justo 00:08:02
te refieres al carácter de la tabla ASTI 00:08:04
que está en la posición 90 00:08:06
entonces se iría aquí 00:08:07
y lo que estaría guardando 00:08:09
realmente 00:08:11
en ese 00:08:13
char sería la Z mayúscula 00:08:15
Vale, entonces vamos a probar esto, vale, esto está claro, que si ahora yo imprimo el carácter, vale, entonces, esto primero está claro, yo voy a darle el ampersand este 00:08:18
y cuando haga print 00:08:51
carácter, pues me mostrará 00:08:54
la ampersand, y ahora voy a darle 90 00:08:56
y voy a ver que me muestra 00:08:58
ejecutamos esto 00:08:59
donde está 00:09:02
y veis, ha mostrado 00:09:07
z mayúscula 00:09:09
claro, si tú quieres poner el carácter tal cual 00:09:10
entre comillas simples 00:09:15
simples, simples, simples 00:09:17
si son dobles, entonces es otra cosa 00:09:19
y te va a decir el compilador que no casa 00:09:20
simples 00:09:22
pero 00:09:23
vale 00:09:25
y repito, otra forma 00:09:28
de darle un char 00:09:31
es poner el numerito entero al que se corresponde 00:09:33
vale, entonces en este caso 00:09:36
esta sentencia dólar 00:09:37
y si yo busco aquí 00:09:39
el ampersand este, que es aquí 00:09:41
el 38, pues 00:09:43
aquí estoy haciendo lo mismo 00:09:47
dándole el ampersand 00:09:49
este y dándole 38 00:09:52
estoy haciendo exactamente 00:09:53
lo mismo 00:09:56
Y de hecho, si lo ejecuto, pues en ambos casos estoy mostrando la misma cosa, ¿vale? Entonces, esto da mucha flexibilidad, porque imaginaos cuando ya tengamos que elaborar condiciones, por ejemplo, podemos adelantar un poquito, imaginaos que uno quisiera expresar en Java la condición de, tiene un char, y quieres pasar la condición de ser letra mayúscula. 00:09:56
pues 00:10:25
la condición se quedaría muy compleja 00:10:27
si no tenemos en cuenta 00:10:30
que cada char se corresponde 00:10:32
con un mito entero, porque esa condición sería 00:10:35
que el carácter sea igual a A 00:10:36
o que sea igual a B, o que sea igual a C 00:10:38
o que sea igual a D, la condición sería enorme 00:10:40
tendría que hacer 00:10:43
si es igual a todas y cada una de ellas 00:10:44
pero, con esta flexibilidad 00:10:46
que me dejaba de tratar 00:10:49
indistintamente el char 00:10:50
como el número entero que codifica 00:10:53
la condición de que un char 00:10:54
sea mayúscula la podría poner 00:10:56
si ese char es 00:10:59
mayor o igual 00:11:00
que 65 00:11:03
y menor o igual que 90 00:11:04
se queda mucho más sencillo 00:11:06
¿eh? 00:11:09
no, con el mayor 00:11:12
que menor que 00:11:13
¿vale? 00:11:13
ahora cuando veamos el boolean ya podemos usarlo 00:11:16
a ver, lo que quiero decir es que 00:11:19
lo único que quería decir ahora es que 00:11:20
El hecho de que un char pueda recibir tanto el numerito entero o el char a capón con la comilla, facilita luego el escribir ciertas sentencias, lo facilita, el poder tratarlo indistintamente, ¿vale? Y con los booleans, las condiciones, lo vamos a ver más claro, ¿vale? 00:11:22
Entonces 00:11:41
Vale 00:11:44
Aquí, por ejemplo 00:11:49
Vamos a 00:11:52
Para 00:11:55
Aquí, por ejemplo, a ver qué pasa 00:11:57
Voy a poner 00:11:59
Carácter más 00:12:01
Carácter 00:12:03
Recordad que el operador más 00:12:04
Aunque todavía no hemos visto la lista 00:12:07
De operadores en detalle, que la veremos 00:12:09
Cuando veamos expresiones, cuando ya hayamos 00:12:11
Terminado los tipos primitivos de datos 00:12:13
ya más o menos estamos 00:12:15
viendo que el carácter más 00:12:18
el perdón, el operador más 00:12:20
es un operador 00:12:22
que tiene diferente comportamiento 00:12:24
en función de lo que tenga a los lados 00:12:28
el operador más 00:12:30
si tiene números, no hay duda 00:12:32
es una suma algebraica 00:12:34
claro, y si una 00:12:35
de las dos cosas, solo con que una 00:12:38
de las dos sea una cadena 00:12:40
ya, o sea algo entre 00:12:42
comillas dobles, algo entre comillas 00:12:44
dobles ya interpreta que está concatenando 00:12:46
entonces si lo estamos poniendo 00:12:48
algo entre comillas dobles más un numerito 00:12:50
lo que hace es ese numerito 00:12:52
concatenarlo como si fuera una cadena al otro 00:12:54
¿vale? pues vamos a ver aquí que pasaría 00:12:56
porque aquí es una situación rara, ¿no? 00:12:58
porque carácter, son caracteres 00:13:00
en realidad, pero les estoy dando el valor 00:13:02
de un número entero, vamos a ver aquí 00:13:04
el operador más 00:13:06
¿qué estaría haciendo? porque tenemos 00:13:07
dos alternativas, que me muestre 00:13:10
Dos ampersand seguidos 00:13:11
O que me muestre 38 más 38 00:13:14
Depende de cómo haya funcionado este operador 00:13:17
Aquí, en este caso raro 00:13:18
En ese caso 00:13:20
El carácter número 38 también va a ser ampersand 00:13:21
Sí, sí, sí 00:13:24
He buscado el 38 00:13:26
Pero de hecho es igual que este 00:13:28
De hecho cuando hemos hecho la ejecución anterior 00:13:29
Me había mostrado lo mismo las dos veces 00:13:31
Esto la mejor manera es probarlo 00:13:33
Para ver cómo funciona 00:13:36
Entonces lo 00:13:37
Probamos 00:13:38
¿Por qué me falta un...? 00:13:41
Ah, vale, sí, sí 00:13:46
¿Veis? ¿Qué me ha mostrado? 00:13:47
38 más 38 00:13:51
¿Vale? 00:13:52
Claro 00:13:55
Claro, porque aquí 00:13:56
El operador más 00:14:04
Cuando tiene caracteres 00:14:05
Hace la operación con el número entero 00:14:07
Con el número entero 00:14:10
Entonces, él hace la operación con el número entero 00:14:11
Entonces, le sale 38 más 38 00:14:13
entonces cuidado 00:14:16
con el operador más en función de 00:14:18
con lo que esté operando 00:14:21
entonces, ¿qué queremos nosotros mostrar 00:14:22
nosotros en Persan? pues efectivamente 00:14:28
podemos hacer este truco 00:14:30
entonces cada vez que nos salgan 00:14:32
cosas raras 00:14:33
con el operador suma 00:14:35
claro, entonces yo pongo este string 00:14:37
entre medias, pongo este string 00:14:40
entonces ahora ya 00:14:42
ya no tiene dos enteros a cada lado 00:14:44
porque aquí tiene una primera suma 00:14:46
porque las operaciones, cuando tengo una expresión compleja 00:14:49
con varias operaciones 00:14:51
se van haciendo de izquierda a derecha 00:14:52
entonces primero hará esta 00:14:54
aquí tiene un string 00:14:56
entonces ya interpreta concatenación 00:14:58
y ahora ya esto se ha quedado 00:15:00
como cadena 00:15:03
porque ha concatenado con una cadena de texto 00:15:04
entonces una cadena con esto 00:15:07
de nuevo 00:15:09
entonces son pequeñas cosas 00:15:10
que nos van surgiendo 00:15:13
para que, bueno, nos vayamos familiarizando. 00:15:14
¿Vale? ¿Ahora ya? 00:15:19
Ahora ya, sí. 00:15:21
Entonces. 00:15:26
Bueno. 00:15:39
a ver 00:15:40
lo que guarda, en realidad lo que guarda 00:15:48
es el número entero que se codifica 00:15:53
con la tabla ASCII y el matiz es 00:15:55
que en función del uso 00:15:57
que tú le des 00:15:59
lo va a interpretar de una manera u otra, entonces cuando lo hemos pasado 00:16:00
directamente a palo seco 00:16:03
le hemos pasado este 00:16:05
a ver, espérate que vamos a poner aquí 00:16:07
este otro 00:16:11
ahí para que se vea 00:16:12
entonces 00:16:14
aquí 00:16:16
cuando le hemos pasado 00:16:20
carácter a esto 00:16:21
dándole a carácter 38 00:16:23
está guardando 00:16:25
exactamente lo mismo que si le das esto 00:16:28
lo que guardas es lo mismo 00:16:29
el tema es, ¿quién está usando ahora esta variable? 00:16:30
¿quién la está usando? 00:16:33
pues ahora mismo la está usando esta sentencia 00:16:35
entonces esta sentencia 00:16:37
como ve que es char 00:16:39
te hace la conversión al carácter astro 00:16:41
Pero porque esta sentencia trabaja así. 00:16:43
Vale, el operador más es otra historia. 00:16:46
Entonces, el operador más ahora es otro uso. 00:16:48
Ahora, tenemos esta situación. 00:16:51
Ahora, el operador más también trabaja con estas dos. 00:16:53
El operador más no se va a mirar si echar o no. 00:16:56
El operador más, como ve que ahí tienes números enteros, 00:16:59
pues te hace la suma del número entero. 00:17:03
¿Vale? 00:17:05
Entonces, el tema no es cómo lo guarda, 00:17:06
lo guarda siempre igual, 00:17:08
sino quién lo esté usando esa variable, 00:17:09
la interpretación que hace. 00:17:12
¿Vale? Esta hace la interpretación natural, el operador más lo interpreta como número entero, entonces, bueno, son situaciones que según a uno se le van dando, pues va encontrando por qué es y solución. 00:17:13
En este caso, por ejemplo, podríamos hacer esto. 00:17:27
Y esto ya he ido recordando desde ya 00:17:31
que el operador más 00:17:33
es recordando desde ya 00:17:36
que cuando en alguno de los dos lados 00:17:39
tiene algo que es una cadena entre comillas dobles, 00:17:43
el resultado final es una cadena 00:17:46
que es la concatenación de las dos cosas. 00:17:48
Y para hacer esa concatenación 00:17:50
habrá forzado él convertir esto a texto. 00:17:51
Entonces al forzarlo automáticamente le ha salido esto 00:17:55
¿Vale? 00:17:58
Al forzarlo porque contiene eso en realidad 00:17:59
Pero si no lo has concatenado 00:18:02
El operador más hace la suma que son los números 00:18:04
¿Vale? 00:18:06
Sería en el mismo caso 00:18:08
El carácter de arriba 00:18:10
El 38 es un símbolo 00:18:13
Sí 00:18:15
Debería 00:18:16
Tú dices por ejemplo si yo no hago esta 00:18:20
Yo quito esto 00:18:24
claro, es decir, yo quito esto 00:18:25
para que se quede esto de aquí 00:18:28
¿vale? y ahora hago la suma sin más 00:18:29
¿vale? 00:18:31
¿ves? es igual 00:18:36
o sea, da igual, él 00:18:38
siempre lo va a guardar como un número entero dentro 00:18:40
pero la sentencia 00:18:42
con la que trabaja va a funcionar 00:18:44
de una manera o de otra, System.out siempre 00:18:47
va a mirar qué tipo es 00:18:48
y si es char, te mostrará el carácter 00:18:50
imprimible, pero el 00:18:52
operador más no va a mirar nada 00:18:54
Va a ver que son números enteros y los suma 00:18:56
Y se acabó 00:18:59
Vale, entonces 00:19:03
Vale, pues un carácter 00:19:05
Llega hasta donde llega 00:19:21
Que es 00:19:22
Almacenar único carácter y ya 00:19:24
Bueno, pues 00:19:26
Vamos ya a acabar con variables 00:19:31
La variable es boolean 00:19:34
¿Vale? 00:19:36
Y ya que 00:19:37
Bueno 00:19:38
Ejemplo chido 00:19:44
Venga 00:19:50
Ya nos hacemos una clase 00:19:51
Ejemplo boolean 00:19:53
Si otro 00:19:55
Nos rakanemos 00:19:57
Y esta vez si que demarco esto 00:20:00
Venga 00:20:02
¿Cómo se llama? ¿Cómo lo has llamado? 00:20:03
Ejemplo Boolean. 00:20:06
Perfecto. Ejemplo Boolean. 00:20:07
¿Cómo era de esperar? Dime. 00:20:09
Que te sale un error en el... 00:20:14
Venga, a ver. 00:20:16
Venga, Boolean. 00:20:19
Esa es la más antiintuitiva. 00:20:21
El más antiintuitivo de todos los tipos de datos, 00:20:26
pero el mejor y el más chulo. 00:20:29
callaos 00:20:32
vale 00:20:34
¿para qué utilizamos el tipo primitivo 00:20:36
boolean? pues la forma 00:20:39
más fácil de entenderlo es decir que 00:20:41
lo usamos para guardar 00:20:42
condiciones, en realidad, es la forma 00:20:44
más fácil de entenderlo, porque ¿qué es 00:20:46
una condición? 00:20:48
algo que solo tiene dos posibilidades 00:20:50
que se cumpla 00:20:53
o que no se cumpla, no hay tutía 00:20:54
una condición o la cumples o no 00:20:56
la cumples, a medias no te puedes quedar 00:20:59
¿vale? 00:21:00
Eso en la lógica de los lenguajes de programación y de las arquitecturas de programación convencionales. 00:21:02
Luego está otra cosa, que es la lógica borrosa, por si a alguien le gusta la inteligencia artificial y todo eso. 00:21:09
En la lógica borrosa, las cosas o sí o no, o un poquito, o mucho, o a medias. 00:21:16
Pero esa es otro tipo de lógica. 00:21:24
el álgebra de Boole de toda la vida 00:21:26
y la lógica de los computadores es 00:21:28
las condiciones o se cumplen 00:21:30
o no se cumplen 00:21:32
bueno, pues para guardar una condición 00:21:34
que es algo que se usa muchísimo 00:21:36
en un lenguaje de programación, las condiciones 00:21:38
se habilita un tipo de dato 00:21:40
que es el Boolean, y en el Boolean yo guardo 00:21:42
una condición 00:21:44
entonces es una idea extraña 00:21:45
porque en un entero, en un float 00:21:48
tú guardas un dato 00:21:50
guardas un número, guardas un dato 00:21:51
Y en un boolean guardas también un dato, pero un dato raro, porque ese dato es una condición, ¿vale? 00:21:53
Entonces, una variable boolean, pues yo qué sé, la vamos a llamar de cualquier manera. 00:22:02
Le voy a poner un nombrecito genérico para no olvidarnos de... 00:22:09
Vale, pues esta variable boolean, ¿qué le asignamos? 00:22:14
asignamos 00:22:18
le asignamos 00:22:19
algo que, o se puede, una condición 00:22:21
algo que se puede cumplir o no se puede cumplir 00:22:24
es decir, yo podría 00:22:26
esto es una asignación perfectamente válida 00:22:28
para una variable 00:22:30
boolean 00:22:32
porque esto es una condición 00:22:32
3 mayor que 5 00:22:36
entonces claro, tendremos que 00:22:38
estudiar 00:22:40
cómo hacer condiciones en Java 00:22:40
porque esta condición es muy sencilla 00:22:43
ser mayor que 00:22:46
pero tenemos que poder expresar condiciones mucho más complejas 00:22:47
igual que cuando hacemos expresiones 00:22:51
para obtener números como 00:22:55
sumar, multiplicar, ya he dicho 00:22:56
que uno puede hacer una expresión muy compleja 00:22:59
que involucre muchas sumas, multiplicaciones, divisiones 00:23:01
patatín, que las involucre y el resultado sea un número 00:23:03
pues también para hacer una condición 00:23:05
uno puede involucrar un montón de cosas 00:23:08
pero bueno, desde ya 00:23:10
el ser mayor que, menor que 00:23:12
mayor o igual que, o menor o igual que 00:23:14
A todos nos suena de toda la vida 00:23:16
Entonces desde ya 00:23:18
Sin tener que meterse a ver en detalle 00:23:19
Los operadores 00:23:22
El símbolo de mayor que todo el mundo sabe lo que significa 00:23:23
Y lo podemos usar para hacer condiciones 00:23:26
Entonces esta es una asignación válida 00:23:27
Y si nosotros 00:23:30
Ahora 00:23:34
Mostramos B 00:23:35
Pues lógica, ¿qué nos sale? 00:23:37
Pues nos sale el valor de esa condición 00:23:39
Uy, perdón, sí 00:23:41
Y el valor de esa condición es 00:23:43
superfalse, vale 00:23:45
entonces 00:23:47
sin embargo 00:23:50
si yo pongo 00:23:51
esto 00:23:52
y lo volvemos a ejecutar 00:23:54
pues me sale esto de aquí 00:23:57
entonces, false y true 00:23:59
son dos palabras reservadas 00:24:02
para java, hasta el punto 00:24:03
de que las podemos usar también 00:24:05
yo puedo asignar directamente una variable 00:24:07
boolean este valor 00:24:09
y esta variable boolean tiene 00:24:10
true 00:24:13
o puedo asignar a una variable boolean 00:24:14
este valor 00:24:17
y esta variable boolean tiene false 00:24:18
entonces en última instancia 00:24:20
las variables boolean 00:24:23
solo tienen uno de estos dos valores en realidad 00:24:24
true o false y son los únicos que pueden tener 00:24:27
una variable boolean 00:24:29
o tiene true o tiene false, no puede tener otra cosa 00:24:31
esta de arriba 00:24:33
¿qué tiene? esta de arriba tiene true 00:24:35
lo que pasa es que 00:24:37
a ese true va a llegar 00:24:39
evaluando una condición 00:24:41
pero tiene true 00:24:42
luego una variable boolean solo tiene 00:24:43
true o false, uno de los dos 00:24:46
¿vale? o bien 00:24:47
porque se lo he asignado directamente a capón 00:24:50
o bien porque se lo he asignado 00:24:52
a través de una condición 00:24:54
¿vale? 00:24:55
y esa condición por supuesto 00:25:00
puede involucrar variables 00:25:02
imaginaos que yo tengo aquí una variable 00:25:04
esta de aquí 00:25:06
¿vale? 00:25:08
pues esto es 00:25:14
una condición 00:25:15
perfectamente válida. 00:25:18
N mayor que 5. 00:25:19
Entonces, la máquina virtual, cuando tenga que hacer 00:25:22
esta asignación, ¿qué es lo primero 00:25:24
que hace cuando hay que hacer una asignación? 00:25:26
Recordad, lo primero que hace es 00:25:28
evaluar lo que hay a la derecha. 00:25:29
Se olvida 00:25:32
de la variable de la izquierda por ahora 00:25:33
y evalúa lo que hay a la derecha. 00:25:36
Vale, para evaluarlo 00:25:38
primero mira a ver si hay cosas 00:25:39
que sean variables. 00:25:42
Porque si son variables, tiene que ir a la cajita a ver qué tienen dentro. 00:25:43
vale, ah, pues aquí se ha encontrado una 00:25:46
n, pues lo primero que tiene que hacer 00:25:48
es irse a la cajita de la n 00:25:50
se va a la caja de la n y dice hay un 9 00:25:51
muy bien, pues ahora ya 00:25:53
construye la condición 00:25:55
con los valores ya de las cajas 00:25:57
los valores de las variables 00:25:59
9 mayor que 5, eso que me da 00:26:00
true, pues mete 00:26:03
true en boolean 00:26:05
y ya está, y cuando ejecutemos esto 00:26:07
pues nos sale aquí el true 00:26:09
que aquí hemos puesto 1 00:26:10
pues la máquina virtual 00:26:13
cuando ejecute este programa, primero se va a la expresión de la derecha 00:26:15
como involucra cajitas, variables, lo siguiente que hace es 00:26:19
me voy a ver el contenido de esas variables, se va, tiene un 1 00:26:23
muy bien, lo sustituye, una vez sustituidas todas las variables 00:26:27
evalúa la condición, 1 mayor que 5, falso 00:26:31
cuando ya tiene el falso, asigna el falso a B, luego 00:26:35
los boolean solamente tienen true o false, es lo único que pueden tener, lo que pasa es que 00:26:39
esos true o false habrán llegado, en la mayoría 00:26:43
de los casos, después de una evaluación 00:26:45
de una condición. 00:26:47
Se los puedo dar yo directamente, pero normalmente 00:26:49
el sentido que tiene es contener 00:26:51
condiciones. 00:26:53
Dime. 00:26:55
¿Cómo se pone el mayor o igual? Porque imagino que se pone el 5 mayor o igual. 00:26:56
Mayor o igual, así. 00:26:59
Así. 00:27:01
Y el menor o igual, cuando 00:27:03
veamos todos los operadores 00:27:05
ya en detalle para hacer expresiones, ya lo revisaremos 00:27:07
todos. Y el menor o igual, así. 00:27:09
Entonces, pero 00:27:12
Pero de todas maneras ya, mayor que, menor que, mayor o igual o menor o igual, para hacer condiciones sencillas, ya los conocemos. 00:27:13
Y el ser igual a, ¿ese cómo se pone? 00:27:21
Se pone así. 00:27:26
Se pone con dos iguales. ¿Por qué? 00:27:29
Porque el igual simple tiene ya un uso, que es la asignación. 00:27:31
Luego lo siento, pero ese no se puede usar para la condición. 00:27:35
Entonces, esto es una expresión perfectamente válida que es n es igual a 5. 00:27:43
¿Eso puede ser true o false? En este caso es false porque n es 1. 00:27:50
Y si lo ejecutamos, pues ala, obviamente es false. 00:27:54
Si yo aquí le pongo el 5 y ejecutamos esto, es true, claro, como era de esperar. 00:27:58
Bueno, esta es la... 00:28:11
la idea 00:28:12
de las variables Boolean 00:28:16
a falta ya 00:28:18
de ver 00:28:20
cómo hacer condiciones más complejas 00:28:21
igual que estamos a falta de ver cómo hacer 00:28:24
expresiones más complejas para obtener números 00:28:26
que sabemos sumar, multiplicar 00:28:28
dividir 00:28:30
y restar 00:28:33
y el porciento, no sabemos más 00:28:34
pues a falta de conocer más operadores 00:28:36
para hacer expresiones matemáticas 00:28:38
también estamos a falta de más operadores 00:28:40
para hacer condiciones más complejas 00:28:43
¿vale? 00:28:44
pero lo que es una variable boolean 00:28:47
pues ya lo tenemos 00:28:49
entonces esto 00:28:49
ahora ya nos permite 00:28:52
ya meternos en el mundo de 00:28:54
complicar un pelín 00:28:57
no complicar 00:29:02
sino ver cómo podemos hacer asignaciones 00:29:03
que hagan cosas un pelín más sofisticadas 00:29:06
dentro de que sean asignaciones 00:29:09
¿vale? 00:29:10
Lo que sí que tenemos claro todos llegados a este punto es que una asignación es algo que tiene este aspecto. 00:29:14
Nombre de la variable que sea igual y aquí una expresión cuyo tipo sea compatible a este de aquí. 00:29:24
Entonces, matices, que la variable tiene que estar declarada, eso lo tenemos clarísimo, que la variable tiene que estar declarada. 00:29:35
Y segundo, que el resultado de la expresión que yo ponga aquí, el tipo resultante tiene que ser igual al del tipo declarado. Salvo los matices de la promoción automática que ya hemos visto. Es decir, si esto es un int y lo guardo en un long, no pasa nada, ¿vale? Porque lo promociona. 00:29:41
si esto es un float 00:30:00
y lo guarda en un dabble, no pasa nada 00:30:02
porque lo promociona 00:30:04
si esto es un byte 00:30:05
y lo guarda en un 00:30:07
short, no pasa nada 00:30:10
porque lo promociona, entonces salvo 00:30:12
esos casos concretos 00:30:14
de la promoción automática que hemos visto 00:30:16
de tipos enteros, de menos tamaño 00:30:18
a más, y en reales 00:30:20
de float a dabble, salvo esos casos 00:30:22
que lo promocionan automáticamente 00:30:24
siempre 00:30:25
no, no, no, de int a dabble 00:30:27
no, de int a dabel ningún caso 00:30:30
aunque sea 1.0 00:30:32
no, no, de int a dabel sí 00:30:33
porque le pone el punto, sí, sí, sí, sí 00:30:36
claro, sí, creía que estaba diciendo de dabel a int 00:30:38
vale, vale, no, de int a dabel también 00:30:40
es otro ejemplo efectivamente de promoción automática 00:30:42
claro, si lo vimos el otro día 00:30:44
claro, lo vimos el otro día 00:30:46
que a un dabel le puedes asignar un int 00:30:49
porque el punto cero no quita información 00:30:50
ese es otro ejemplo efectivamente de promoción 00:30:52
automática en el cual 00:30:54
el tipo de dato de aquí, aunque no sea 00:30:55
idéntico, vale 00:30:58
si es de int a double 00:31:00
o de short a double o de byte a double 00:31:02
me da igual, o sea, de entero a double en general 00:31:04
de entero a double, o a float incluso 00:31:06
también, al revés no 00:31:08
de double o float 00:31:09
a int long, tampoco, ahí no 00:31:12
ahí no 00:31:14
habría que hacer algo para quitar 00:31:16
lo que fuera un casting, lo que fuera que ya veremos 00:31:18
¿vale? bueno, pero salvo 00:31:20
esos casos que hemos recogido ahora ya así 00:31:22
todos, en las asignaciones 00:31:24
en general, ya sabemos cómo funcionan 00:31:26
eso tiene que ser el mismo tipo de la variable declarada 00:31:28
y esto será 00:31:30
una expresión 00:31:32
una expresión que involucra variables, números, lo que sea 00:31:33
y ya está, uno la evalúa y le da el tipo 00:31:36
bueno 00:31:38
pues ahora que ya hemos introducido 00:31:38
las condiciones 00:31:42
y podemos ver una variante 00:31:43
de las asignaciones 00:31:46
interesante y útil 00:31:47
que es la asignación 00:31:49
condicionada 00:32:05
ya conocemos asignaciones, conocemos condiciones 00:32:06
Pues la asignación condicionada 00:32:11
¿Qué significa lo siguiente? 00:32:14
La sintaxis es esta 00:32:19
Yo tengo una variable, por ejemplo, esta 00:32:20
Y le voy a asignar un valor 00:32:23
Vale, pues entonces 00:32:24
Aquí puedo elegir entre dos posibilidades 00:32:28
Le quiero asignar este o este 00:32:31
En función de una condición 00:32:34
Puede ser una situación que queramos a veces 00:32:36
Yo quiero hacer una asignación 00:32:39
pero esta asignación le quiero dar 00:32:40
o este valor o le quiero dar 00:32:42
este otro y le doy este 00:32:44
en función de si una condición es verdad o mentira 00:32:46
¿vale? 00:32:49
por eso lo podemos reflejar en una sentencia 00:32:50
de asignación ¿y cómo lo haríamos? 00:32:53
pues entre paréntesis ponemos 00:32:55
ahora lo completamos 00:32:57
la condición en función 00:32:58
de la cual asigne una cosa u otra 00:33:01
y luego pongo una interrogación 00:33:02
y ahora pongo aquí 00:33:04
el primer valor que es el que asignaría 00:33:06
si la condición es true 00:33:09
luego pongo dos puntos 00:33:11
y luego el segundo valor 00:33:13
que asignaría si la condición 00:33:15
es falsa, lo pongo en comentarios 00:33:18
para, vale 00:33:20
vale, pues esta es la asignación condicionada 00:33:21
que se llama 00:33:26
entonces es una asignación porque a n 00:33:26
se le asigna un valor que es 00:33:29
o este o este, uno de los dos 00:33:31
uno de los dos, ¿de qué depende 00:33:34
asignar uno u otro? 00:33:36
del valor de esta condición 00:33:37
¿vale? 00:33:39
Por ejemplo, vamos a imaginar, ejemplo, vamos a hacer un código en el cual pedimos una edad 00:33:41
y en función de si es de una persona y en función de si es mayor de edad o es menor de edad, 00:33:56
pues poner una variable, la S o la N, para decir si es mayor o no es menor de edad. 00:34:05
Pues venga, solicitar edad e indicar en una variable char si es mayor de edad o no, indicándolo poniendo pues el carácter S o el carácter N, ¿vale? 00:34:10
Venga, pues entonces, pues sí, típico examen sorpresa que podría haber puesto dentro de 10 minutos. 00:34:39
como vamos a leer por teclado, escáner 00:34:46
importamos 00:34:48
es decir, este import 00:35:00
cuidado, que tiene que estar arriba 00:35:03
detrás de la línea de package 00:35:05
ahí 00:35:07
ahora que ya hemos importado 00:35:07
vamos a leer un numerito 00:35:10
entero, que es una edad 00:35:13
venga, lo guardamos en la variable 00:35:16
edad, bueno 00:35:17
lo he llamado scan en vez de lector porque me ha salido 00:35:19
así sobre la marcha, da igual, porque ese nombre 00:35:21
lo elige uno 00:35:23
Venga, pues scan.nextint 00:35:24
Así leíamos por teclado, ¿verdad? 00:35:29
Para que la aplicación no se quede así como muy misteriosa 00:35:31
Vamos a poner introduzca edad 00:35:36
Vale 00:35:48
Y ahora, la edad ya está leída 00:35:48
De la manera en la que leíamos números enteros 00:35:52
Números íntegros 00:35:56
Lo leíamos así 00:35:57
Con este objeto que declarábamos de esta manera 00:35:57
Bueno, pues ahora 00:36:00
¿Qué hacemos con edad? 00:36:03
Nuestro resultado de nuestro programa 00:36:06
Tiene que ser una variable char 00:36:08
¿Y esa variable char 00:36:09
¿Qué le vamos a asignar? 00:36:13
Pues depende 00:36:16
Una S 00:36:17
O una N, no sabemos 00:36:19
O le asignamos S o le asignamos S 00:36:21
N, perdón 00:36:24
O S o N, no sabemos cuál de los dos 00:36:25
Le vamos a asignar, no lo sabemos 00:36:28
Pero sí sabemos que asignamos S 00:36:29
si edad es mayor o igual de 18 00:36:32
y si sabemos que asignamos n 00:36:34
si edad es mayor o igual que 18 00:36:36
luego maravilloso porque ya hemos identificado 00:36:38
que en función de 00:36:40
que condición 00:36:43
edad mayor o igual que 18 00:36:45
o esta o esta 00:36:47
pues podemos ponerlo así 00:36:48
que edad es mayor o igual que 18 00:36:51
pongo la condición 00:36:56
asignale s 00:36:57
y si no, asignale n 00:37:00
¿vale? 00:37:02
Entonces esta es una asignación condicionada 00:37:04
O le asignas S o le asignas N 00:37:07
En función de si edad es mayor o igual que el 18 00:37:09
Y si mostramos 00:37:12
El resultado del programa 00:37:16
Para ver si la asignación lo ha hecho bien 00:37:19
Pues supone que va a dar bien 00:37:21
¿Vale? 00:37:23
Entonces ejecutamos 00:37:28
Introduzca edad 00:37:29
65, pues sí 00:37:30
Es mayor que edad 00:37:32
Has llegado un poco tarde porque me temo que os voy a echar 00:37:34
si lo vamos a ejecutar 00:37:37
introduzca edad 00:37:42
12, pues no 00:37:43
vale 00:37:45
vale, pues este 00:37:47
este operador es muy útil 00:37:50
desde ya, sin tener 00:37:54
conocimientos de la famosa sentencia de decisión 00:37:56
if, sin eso 00:37:58
nos permite ya hacer bastantes cosas 00:38:00
interesantes en 00:38:02
en código 00:38:03
pues si lo has escrito tal cual 00:38:05
no debería 00:38:07
Vale, bueno 00:38:08
Y entonces ahora ya sí que os voy a decir que os vayáis a casa 00:38:13
Para mañana ya 00:38:15
A ver si venimos un poquito más 00:38:18
Porque 00:38:20
Me duele mucho la garganta 00:38:20
Y no voy a poder 00:38:27
Pues es así de delicado y más 00:38:28
Uh, no había parado esto 00:39:00
Gracias por ver el video. 00:39:03
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
15
Fecha:
23 de septiembre de 2024 - 16:49
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
39′ 05″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
167.33 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid