Saltar navegación

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

Clase 26-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 26 de septiembre de 2023 por Raquel G.

13 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues estábamos con declaración y asignación de variables. 00:00:01
¿Alguna duda o pregunta de lo de ayer que ya todos os habéis estudiado, mirado y lo tenéis ya todo grabado en la cabeza? 00:00:05
Vale, los char tenían el matiz desde que dijimos que indistintamente podíamos hacer asignaciones a char con el número entero o con el carácter. 00:00:14
y si cuando hacemos una asignación a char 00:00:25
Java ve un número entero 00:00:28
lo interpreta como el carácter 00:00:30
de la tabla ASCII, ¿verdad? 00:00:33
y eso tiene luego implicaciones 00:00:34
a la hora de usarlo tiene implicaciones 00:00:36
vimos pues algunas de ellas 00:00:38
algunos ejemplitos y según uno vaya 00:00:40
usando variables char 00:00:42
pues a lo mejor a veces le sale algo 00:00:44
que no entiende, pero si rápidamente 00:00:46
se da cuenta, ah cuidado 00:00:49
que es que es el número entero 00:00:50
y el número entero interpretado como char 00:00:53
Teniendo clara esa idea, podréis entender casi cualquiera de las diferentes casuísticas que podáis ir trabajando con char. 00:00:54
De las cuales aquí hemos ejemplificado alguna. 00:01:01
Una que dijimos fue esta. 00:01:03
Si yo hago con un operador algebraico suma, resta, la operación entre dos char, me deja hacerla. 00:01:05
Uno diría, pero ¿cómo se pueden sumar char? Los char no se pueden sumar. 00:01:13
claro, precisamente por este matiz 00:01:16
de que los char java 00:01:19
los trata como numeritos enteros 00:01:21
pues sí que deja sumarlos 00:01:23
pero ¿cuál es el problema? 00:01:25
que si ponemos un operador aritmético 00:01:28
él entonces lo interpreta como 00:01:30
número entero y ya automáticamente 00:01:31
hace la suma del número entero 00:01:33
número entero y el system.out.println 00:01:35
saca la interpretación 00:01:38
entera de eso 00:01:39
la interpretación entera 00:01:41
porque hemos usado un operador aritmético 00:01:42
que queremos la interpretación 00:01:44
char, no la interpretación entera 00:01:47
pues el casting 00:01:48
he puesto esta situación porque es la que 00:01:50
a veces a lo mejor se nos da más 00:01:52
y nos puede dar más 00:01:54
dudas de por qué sale eso 00:01:55
y nada más, poco más 00:01:59
que esto puede haber 00:02:00
meter un casting ahí no tiene riesgo 00:02:01
no, no, no, porque tú sabes exactamente 00:02:03
lo que quieres, que C1 tenía 00:02:06
27, C2 tenía 32 00:02:08
y tú quieres el carácter que está en la tabla ASCII 00:02:10
colocado en 27 más 32 00:02:12
entonces como tú sabes que eso es lo que quieres 00:02:14
y el casting sabes que lo que te hace 00:02:16
precisamente es transformar a chat 00:02:18
según la que hablas 00:02:20
tienes un numerito 00:02:22
claro, tiene peligro 00:02:23
siempre que tú no sepas exactamente 00:02:26
qué es lo que va a hacer 00:02:28
entonces aquí sabes qué es lo que va a hacer 00:02:29
y sabes que lo que va a hacer es lo que tú quieres 00:02:31
en el caso de arriba 00:02:33
en el caso de que estábamos viendo números enteros 00:02:35
sabemos el casting que te hace 00:02:37
que si es casting de long high end 00:02:39
sabes que te corta los 32 00:02:41
significativos, sabes lo que hace 00:02:43
que no te importa porque el número es pequeño 00:02:46
lo haces, que si te importa 00:02:48
porque pierdes datos, no lo haces 00:02:49
entonces lo importante del casting es que tú sepas 00:02:51
qué te va a hacer 00:02:54
si lo que te va a hacer casa con lo que tú quieres 00:02:54
lo haces, ¿vale? 00:02:58
pero si no sabes lo que te va a hacer, no 00:02:59
entonces a lo mejor tenemos, ahora mismo solo estamos 00:03:01
viendo tipos primitivos 00:03:03
pero cuando ya veamos tipos objeto 00:03:05
pues tenemos un tipo de dato que es alumno 00:03:07
y otro tipo de dato que es profesor 00:03:10
que son tipos de datos también, pero no serían primitivos 00:03:11
entonces yo tengo que asignar 00:03:14
un alumno a un profesor, el compilador me dice 00:03:16
no, plante un casting 00:03:18
y hasta el compilador se calla, pero no tenemos ni idea 00:03:19
de ese casting, como va a hacer por dentro la conversión 00:03:21
no lo sabemos, entonces nunca haremos un casting 00:03:24
que no sabemos como va a funcionar 00:03:26
por dentro, esto si lo sabemos 00:03:28
estos ejemplos que hemos visto 00:03:30
vale, entonces 00:03:32
los usamos cuando lo que va a hacer 00:03:34
nos cuadra 00:03:36
bueno 00:03:37
esta clase de aquí la abrimos para hacer char y boolean 00:03:39
vamos a avanzar rápidamente 00:03:49
porque luego según vayamos viendo ejemplos y ejercicios 00:03:52
pueden ir saliendo pequeños matices y detalles de los tipos de datos 00:03:55
que igual no tiene sentido ahora a lo mejor 00:04:00
hacer tanta, tanta, tanta clase teórica de esto 00:04:02
porque luego van a salir esos pequeños detalles en los ejercicios 00:04:06
Entonces vamos a ver un poquito lo mínimo para entenderlo. 00:04:10
Bueno, pues venga, siguiente tipo de dato que nos interesa, el único que nos falta, ¿verdad? 00:04:13
El tipo Boolean. 00:04:19
Entonces, el tipo Boolean sobre todo lo usamos para una variable, 00:04:22
una variable que la información que va a contener es una información que nos cuesta más entenderla, 00:04:30
pero también es información, que es si algo es verdad o algo es mentira. 00:04:36
Eso también es información. 00:04:42
Los números son información, lo tenemos claro. 00:04:44
Estamos acostumbrados a que la información sean números y letras, texto, contenido. 00:04:46
Eso es información, lo tenemos claro. 00:04:50
Y se guarda en variables numéricas y chat. 00:04:51
Pero también hay una información que es, esto pasa, esto no pasa. 00:04:55
Entonces, esa información yo la guardaría en variables Boolean. 00:04:59
Por ejemplo, puede ser que yo tenga una aplicación que está trabajando con facturas, con lo que sea, y hay una información que me interesa, que es si una factura está pagada o no. 00:05:02
Eso en sí ya es una información, estar pagada o no estar pagada, eso es una información. 00:05:14
Lo podríamos codificar a través de una variable entera, que la pongo a cero si no está pagada y a uno si lo está, podríamos hacer muchos diseños, claro. 00:05:20
pero si tenemos la variable boolean 00:05:28
a lo mejor podemos hacer un diseño que es más claro a la vista 00:05:30
que es el siguiente 00:05:32
que es, me declaro yo 00:05:34
una variable de este tipo primitivo 00:05:36
boolean 00:05:38
a la que le doy un nombre lo más explicativo 00:05:39
posible, como siempre, los nombres 00:05:42
cuanto más explicativos mejor, pagado 00:05:44
y esta variable boolean 00:05:46
pues ya recibirá 00:05:48
un valor, recibirá el valor true 00:05:50
cuando yo quiera 00:05:52
indicar que eso está pagado 00:05:54
y recibirá el valor false cuando quiera indicar 00:05:56
que no, vale, entonces estas variables se prestan 00:05:58
sobre todo a eso, a hacer programas más claros, más legibles 00:06:02
porque si yo veo aquí un boolean pagado, automáticamente ya me viene a la cabeza 00:06:06
que es una información interesante de esta aplicación si algo está pagado 00:06:10
o no, sin embargo si lo veo en un 00:06:14
int, me puede dar más confusión 00:06:18
porque si lo veo en un int digo, oye 00:06:22
A lo mejor lo que va a contener esta variable 00:06:24
Es la cantidad que se ha pagado 00:06:28
Si se han pagado 27.000, si se han pagado 35.000 00:06:29
Me crea más confusión 00:06:32
Y a lo mejor no, la hemos puesto ahí 00:06:34
Porque nuestro diseño es 00:06:35
Cero si está pagado, uno si no 00:06:37
Entonces el programa es un poco más confuso 00:06:40
Gracias a que tenemos las variables boolean 00:06:42
Aunque no sean necesarias 00:06:44
Pues a la vista es más claro 00:06:45
Ah vale, solo hay una posibilidad 00:06:47
Y es que esta variable codifique sí o no 00:06:49
Solo hay una 00:06:51
pues ya sé que una información interesante de mi programa 00:06:52
es si esto pasa o si esto no pasa 00:06:55
y todo lo que sea hacer una aplicación clara 00:06:57
legible a efectos de código 00:07:00
va a implicar hacer una aplicación mantenible 00:07:03
y una aplicación mantenible es una aplicación 00:07:05
pues que se va a vender, que va a funcionar 00:07:08
una aplicación no mantenible no 00:07:10
porque en cuanto haya, se detecte cualquier error 00:07:12
se detecte cualquier chorrada 00:07:14
arreglar esa aplicación es una locura 00:07:16
entonces, bueno pues entonces esta variable boolean 00:07:18
Ay, lo que no subí ayer es el proyecto este al aula virtual 00:07:22
Sirven para eso 00:07:27
Para guardar información 00:07:32
Sobre si algo ocurre o no 00:07:35
Bueno, y la asignación 00:07:39
Pues solo le puedo asignar uno de los dos posibles valores 00:07:46
Solo tiene dos 00:07:49
Que algo pase o no pase 00:07:50
Pues el valor, los dos valores posibles son el true 00:07:51
Que se escribe tal cual 00:07:54
es una palabra reservada de Java 00:07:55
que la escribimos así, tal cual 00:07:57
o esto 00:07:59
son los únicos dos valores que le puedo asignar 00:08:00
no le puedo asignar más cosas 00:08:03
que esto 00:08:05
¿vale? que algo ocurra o que algo no ocurra 00:08:06
por supuesto 00:08:10
la puedo inicializar al principio 00:08:15
entonces claro 00:08:17
estas asignaciones en una aplicación 00:08:24
ya que tenga pues todo un recorrido 00:08:26
pues el sentido tendrá 00:08:28
yo pondré esta variable 00:08:30
si he evaluado previamente una condición 00:08:31
y he visto que en la base de datos 00:08:34
hay una cantidad 00:08:36
pues entonces pongo pagado a true 00:08:37
bueno, usaremos 00:08:39
las variables booleanas 00:08:42
dentro de programas 00:08:43
que necesiten condiciones para funcionar 00:08:45
y a su vez 00:08:48
las variables booleanas nos funcionan 00:08:50
nos sirven 00:08:52
como condiciones 00:08:53
para luego una sentencia de 00:08:55
selección, recordad que 00:08:58
En la programación estructurada tenía las sentencias de selección, 00:09:00
las que llamaba de decisión, que son las que te dicen, 00:09:05
si esto ocurre, haz una cosa, y si esto no ocurre, haz otra. 00:09:07
Pues las variables booleanas precisamente son eso, 00:09:11
son ese algo que ocurre o no, son condiciones, ¿vale? 00:09:14
Entonces vamos a ponerlo aquí. 00:09:19
Las variables booleanas expresan condiciones, 00:09:20
porque las condiciones solo tienen dos alternativas, 00:09:24
una condición o se cumple 00:09:27
o no se cumple, por definición 00:09:29
eso es una condición 00:09:31
una condición es un hecho 00:09:32
que puede cumplirse 00:09:35
o puede no cumplirse, eso lo tiene dos alternativas 00:09:37
no puede cumplirse a medias 00:09:39
no puede cumplirse a medias 00:09:40
al menos en términos 00:09:42
de programación 00:09:45
si uno se metiera en lógica borrosa 00:09:47
que son otros patrones de programación 00:09:49
las condiciones se pueden cumplir a medias 00:09:51
pero aquí no estamos en la lógica borrosa 00:09:53
sino en el álgebra de Boole, las condiciones, los hechos, o se cumplen o no se cumplen. 00:09:56
Estamos trabajando en ceros y unos, aquí no hay intermedios. 00:10:01
Pues una variable booleana o se cumple o no se cumple. 00:10:04
Entonces las variables booleanas en realidad representan condiciones 00:10:07
y el concepto de condición es importante, porque una condición es lo que usaremos 00:10:14
en nuestra sentencia selectiva para si se cumple o no se cumple. 00:10:23
Si no se cumple por un lado o por otro ya lo veremos. 00:10:26
es decir, hechos que se cumplen o no se cumplen, ¿vale? 00:10:27
De repente han condiciones. 00:10:46
Vale, pues entonces, asignaciones a variables booleanas, 00:10:51
hombre, asignar true o false está claro, yo puedo asignar true o false, 00:10:57
son los dos posibles valores que puede tener. 00:11:00
Pero igual que a las variables numéricas, yo le podía asignar directamente, 00:11:02
Yo a una variable numérica le podía asignar directamente el numerito, 138, el numerito, como a la variable booleana le asigno true, o también le puedo asignar una expresión como esta o una expresión como esta, cuyo resultado de evaluarla me dé un numerito, ¿verdad? 00:11:07
Lo importante es que yo lo que ponga en la asignación sea algo que a resultas de su evaluación me dé algo compatible con la variable. 00:11:28
Esto me da algo compatible con la variable, me da un número entero. 00:11:38
Esto también, porque número 1 es variable entera, número 2 es variable entero. 00:11:40
Una operación algebraica con eso me da un número entero. 00:11:46
Entonces ya hemos visto aquí que lo que nosotros ponemos a la derecha 00:11:49
No tiene por qué ser un valor tal cual 00:11:54
Sino también una expresión 00:11:56
Una expresión correctamente escrita 00:11:58
Y esto de correctamente escrita tendremos que revisarlo 00:12:01
Para ver cuáles son las reglas de construcción de expresiones 00:12:04
Pues una expresión correctamente escrita 00:12:08
De tal forma que la evaluación de esa expresión nos dé un valor 00:12:10
Compatible 00:12:14
Bueno, pues con las booleanas igual 00:12:16
Yo no tengo por qué asignar, no es obligatorio que la asignación de las booleanas sea PAF o true o false, los únicos dos posibles que tiene. 00:12:17
No, a una variable booleana le puedo asignar una expresión cuyo resultado de la evaluación sea un valor compatible, es decir, un valor verdad o mentira. 00:12:24
Por ejemplo, vamos a poner algunos ejemplos. Voy a indicarlo aquí. A una variable booleana se le pueden asignar expresiones también, igual que a los números, siempre y cuando esas expresiones solo tengan dos posibles resultados. 00:12:37
si o no 00:13:07
vale 00:13:09
siempre, cuando solo tengan dos posibles 00:13:23
porque son los únicos dos posibles que se le puede asignar a true 00:13:25
igual que aquí 00:13:27
esta expresión puede tener 00:13:29
miles de resultados 00:13:31
posibles, claro 00:13:34
en función de los valores que tenga número número dos 00:13:35
miles de resultados, claro, pero es que 00:13:37
a la variable número dos por ser entera 00:13:39
se le pueden dar miles de resultados 00:13:41
claro, pero es que a este 00:13:43
solo se le puede asignar 00:13:45
true o false, con lo cual lo que yo ponga 00:13:47
ahí tiene que ser una expresión 00:13:49
cuyo resultado final solo pueda ser 00:13:50
se cumple o no se cumple 00:13:53
y que expresiones 00:13:55
solo me pueden dar como resultado 00:13:57
se cumple o no 00:13:59
pues ahora enseguida lo vamos 00:14:00
con ejemplos, vais a decir, claro 00:14:03
las expresiones que llamamos 00:14:05
relacionales, a las cuales 00:14:07
volveremos para aprender a construirlas, por ejemplo 00:14:09
número uno 00:14:11
mayor que 00:14:14
Número 2 00:14:17
¿Vale? Esto 00:14:18
Ah, claro, es que número 1 está sin declarar 00:14:22
Porque estaba en otra clase 00:14:26
Voy a declarar aquí dos variables enteras 00:14:27
Cuales quiera, por ejemplo 00:14:30
Y número 1, le voy a asignar ya un valor 00:14:31
Le voy a inicializar 00:14:36
Y número 2, 65 00:14:39
Vale, tengo dos variables enteras 00:14:42
Y además inicializadas 00:14:44
Con una primera asignación 00:14:46
Bueno, pues esta expresión es una expresión construida con un operador de los que llamamos relacionales 00:14:48
Este no es un operador algebraico 00:14:58
Los operadores algebraicos son suma, resta, multiplicación, división, los que hacen operaciones algebraicas 00:14:59
Estos son relacionales, los que relacionan menor que, mayor que, igual que 00:15:05
repito por enésima vez 00:15:11
todos estos operadores y cómo usarlos 00:15:13
para construir expresiones válidas 00:15:15
en Java, lo tenemos que repasar 00:15:17
todo en plan chorizo 00:15:19
pero 00:15:20
podemos adelantar algunas cositas para entender 00:15:21
el concepto de variable 00:15:25
esto es una expresión 00:15:27
perfectamente construida 00:15:30
número uno mayor que número dos 00:15:31
no es una expresión aritmética 00:15:34
no es una suma, no es una resta 00:15:35
pero es una expresión relacional 00:15:36
está construida con un operador relacional 00:15:39
y compara dos valores 00:15:42
que se pueden comparar 00:15:43
relacionalmente, porque son números 00:15:46
los puedo comparar por mayor que y menor que 00:15:47
bueno, pues esta expresión 00:15:50
es una expresión 00:15:51
que si yo la evalúo solo tiene dos posibilidades 00:15:53
o se cumple o no se cumple 00:15:56
no hay tutía, o se cumple o no se cumple 00:15:58
no hay más, bueno pues 00:16:00
esa expresión es perfectamente válida 00:16:01
para asignársela a pagado 00:16:03
entonces cuando coincida 00:16:05
que la variable número 1 es mayor que número 2 00:16:07
pagado tendrá true 00:16:10
está claro 00:16:11
si resulta que número 1, llegados a este punto 00:16:12
es menor o igual 00:16:16
que número 2, pues pagado tendrá false 00:16:17
¿vale? pero lo que importa es 00:16:19
dime 00:16:22
si, las tengo aquí declaradas como numéricas 00:16:22
y aparte les he dado un valor 00:16:27
pues por darle algo 00:16:29
vale, entonces esta expresión 00:16:30
es perfectamente válida porque solamente 00:16:46
tiene como resultado final 00:16:48
ocurre o no ocurre 00:16:49
Claro, esta no sería, si yo pongo aquí pagado igual a número 1 más 6 00:16:51
El compilador me dice, ¿cómo que pagado igual a número 1 más 6? 00:16:57
Número 1 más 6 es una operación aritmética cuyo resultado es un número 00:17:02
Y un número no es compatible con cumplirse o no cumplirse 00:17:06
Entonces, esta asignación no es válida, ¿vale? 00:17:10
Esta no sería válida porque el resultado no es un valor booleano, no es true o false, sino es un número. 00:17:19
Entonces, esta no nos vale. 00:17:45
¿Vale? Entonces, luego ya veremos cómo construir expresiones booleanas o relacionales todo lo complejas que uno quiera. 00:18:01
Porque muchas veces en una aplicación tenemos que expresar una condición. 00:18:10
que el alumno sea mayor que edad y haya pagado tantas matrículas 00:18:13
como la suma de las que se haya matriculado los tres juegos anteriores 00:18:17
en las aplicaciones muchas veces hay condiciones muy elaboradas 00:18:20
pues hay que saber construir esas condiciones 00:18:25
y para saber construirlas tendremos que conocer las reglas y los operadores 00:18:27
de los que disponemos para construir expresiones booleanas y relacionales 00:18:33
que pueden ser mutochas, esta es muy sencilla 00:18:37
pero pueden ser muy tochas 00:18:40
bueno, pues esto en cuanto a 00:18:42
primer vistazo por encima 00:18:48
de la declaración de variables 00:18:50
de tipos primitivos 00:18:52
de la asignación de variables 00:18:55
a tipos primitivos 00:18:59
y de algunos 00:19:00
pequeños matices de funcionamiento 00:19:01
vale, y para 00:19:05
rizar ya el rizo 00:19:07
vamos a aprovechar y ver 00:19:09
ahora ya que conocemos las variables booleanas 00:19:15
que representan condiciones 00:19:20
y que conocemos lo que son las asignaciones 00:19:22
que es dar valor a una variable 00:19:25
pues vamos a ver 00:19:26
una posibilidad que tenemos en Java 00:19:28
una posibilidad 00:19:34
que es la de hacer asignaciones 00:19:34
asignaciones condicionadas 00:19:38
¿Vale? 00:19:40
Que a veces nos facilita mucho la tarea 00:19:45
Vale, entonces una asignación 00:19:47
Ya sabemos lo que es 00:19:50
A una variable 00:19:51
Nombre de variable 00:19:54
A la izquierda del operador siempre el nombre de variable 00:19:56
A la izquierda nunca puede ir nada 00:19:58
En una asignación que no sea el nombre de la variable 00:20:00
Nunca 00:20:02
¿Vale? Lo digo porque cuidado 00:20:03
Porque muchas veces 00:20:05
Hacéis esto 00:20:06
O cosas parecidas al principio 00:20:08
¿Vale? 00:20:12
a la izquierda nombre de la variable 00:20:14
que recibe el valor 00:20:20
operador igual y a la derecha 00:20:21
valor que yo asigno 00:20:24
resultado una expresión o valor ahí calcado 00:20:26
bueno, pues las asignaciones son esto 00:20:28
normalmente, vale, pero puede ocurrir 00:20:30
que yo quiera asignar 00:20:32
o bien un valor o bien otro 00:20:33
en función de una condición 00:20:36
si una condición se cumple 00:20:38
asigno un valor y si no se cumple 00:20:40
asigno otro 00:20:42
vale, bueno, es una situación 00:20:43
que se da muchísimo 00:20:46
la podemos hacer con la sentencia 00:20:47
selectiva, porque de hecho 00:20:50
la sentencia selectiva 00:20:51
es si algo ocurre, hago una cosa y si algo ocurre 00:20:54
hago otra, pero la sentencia selectiva 00:20:56
es como más general, si algo ocurre 00:20:58
hago una cosa, que puede ser todo lo tocha que sea 00:20:59
y si no ocurre hago otra, aquí estoy hablando 00:21:01
de un caso muy particular, que es 00:21:04
solamente a la hora de asignar 00:21:05
cuando yo voy a asignar un valor a una variable 00:21:07
Si ocurre una condición 00:21:10
Le quiero asignar el 4 00:21:13
Y si ocurre otra condición 00:21:14
Le quiero asignar el 6 00:21:16
Por ejemplo 00:21:19
¿Vale? 00:21:19
Vamos a ponerlo aquí 00:21:22
Queremos asignar 4 00:21:24
A número 1 00:21:28
Si pagado 00:21:31
Está true 00:21:32
O 6 00:21:33
Bueno, vamos a poner 0 y 1 00:21:38
Que a lo mejor podría tener sentido 00:21:40
cero si pagado, la variable la pongo ya a cero 00:21:42
porque luego esa se usa para sumador 00:21:44
como contador de las facturas por pagar 00:21:46
podría tener más sentido así 00:21:48
o uno 00:21:50
si no pagado 00:21:53
si no está pagado 00:21:55
vale, pues yo que sé 00:21:58
se nos da esta situación, que este número uno 00:22:00
es una especie de indicador de contador 00:22:02
que lleva cuenta de las pagadas 00:22:04
o no, lo pongo a cero 00:22:06
si no está pagado, o sea, si está 00:22:08
pagado ya no queda nada por pagar 00:22:10
y la quiero poner a uno 00:22:11
si no lo está, por ejemplo 00:22:13
bueno, es una situación muy habitual 00:22:16
una asignación que yo tengo dos posibles valores 00:22:19
dos posibilidades concretas 00:22:22
o esta o esta otra 00:22:24
¿cuál quiero? ¿asignarle 0? 00:22:26
no lo sé, depende de pagado 00:22:29
¿asignarle 1? no lo sé, depende de pagado 00:22:30
¿qué le asigno? ¿0 o 1? 00:22:32
bueno, pues lo expreso de esta manera 00:22:35
pongo la condición 00:22:36
en función de la cual quiero hacer una cosa u otra 00:22:39
la pongo entre paréntesis al principio de todo 00:22:42
vale, y la sigo con una interrogación 00:22:45
esto significa, voy a hacer una asignación a número 00:22:49
vamos a evaluar la condición que está aquí dentro 00:22:55
lo que está aquí dentro tiene que ser algo booleano, que tenga un valor booleano 00:23:00
algo que pueda ser true o false, pagado lo es, pagado es una variable booleana 00:23:03
está aquí, entonces esto me vale como condición 00:23:07
lo que tiene que haber ahí dentro 00:23:11
tiene que ser algo que o sea verdad o sea mentira 00:23:13
pongo 00:23:15
la interrogación para indicar esta es la condición 00:23:17
que me estoy preguntando y ahora 00:23:19
separado por dos puntos pongo 00:23:21
las dos posibilidades 00:23:23
vale 00:23:24
antes de los dos puntos pongo el valor 00:23:28
que asignaría 00:23:31
si esto es true 00:23:32
y después de los dos puntos pongo 00:23:34
el valor que asignaría si eso es false 00:23:37
luego esto es una asignación 00:23:39
condicionada a que esta condición se dé o no se dé 00:23:44
y es una situación muy habitual 00:23:47
entonces en lugar de usar una sentencia selectiva 00:23:51
para ello usamos directamente esto 00:23:53
que ahora mismo ya estamos con capacidad de entenderlo 00:23:56
aunque no hayamos visto sentencias selectivas 00:24:01
pero sabemos entender lo que es una condición 00:24:02
que una condición se puede guardar en una variable booleana 00:24:05
perfectamente, una variable boolean 00:24:08
yo pongo aquí esa condición 00:24:10
y separados por dos puntos 00:24:14
los dos posibles valores 00:24:17
vale 00:24:18
entonces aquí puedo poner cualquier cosa 00:24:22
que sea ese concepto de condición 00:24:26
la variable boolean 00:24:29
lo he pagado, pero incluso podría poner 00:24:30
una expresión también, cuyo resultado 00:24:32
final me diera true o false 00:24:35
podría también ponerla, es decir 00:24:36
podría poner esto también, sería lo mismo 00:24:38
en este caso 00:24:40
podríamos poner aquí esto 00:24:41
vale 00:24:46
O sea, no es que tenga mucha lógica con el sentido del programa 00:24:54
Pero a ver, yo puedo poner aquí cualquier cosa 00:24:57
Que me dé true o false 00:24:59
Cualquier cosa que me dé true o false 00:25:00
Pagado me da true o false, porque es una condición 00:25:02
Es una boolean, o es true o es false 00:25:04
Depende del valor que tenga, no es el que tiene 00:25:06
Pero es una variable boolean, o me da true o false 00:25:07
Y esto también, esto también es algo boolean 00:25:10
Esto también es una condición, es algo boolean 00:25:13
Que o me da true o me da false 00:25:15
Entonces lo que yo pongo entre los paréntesis 00:25:16
Tiene que ser siempre algo 00:25:18
Que me dé true o me dé false 00:25:20
¿Vale? 00:25:22
Y en función de eso, si me da true, la asignación será esta primera. 00:25:24
Y si me da false, pues será esta otra. 00:25:28
Vale. 00:25:49
Claro, claro, clarísimo. 00:25:53
Para todo el mundo. 00:25:56
¿Lo has dicho lo he entendido yo o lo he entendido hasta yo? 00:25:59
Vale. 00:26:03
Pues fenomenal. 00:26:04
Asumo que el resto del mundo también. 00:26:06
vale, bueno pues 00:26:07
hasta aquí asignaciones a variables 00:26:12
eso no significa que no puedan surgir luego situaciones 00:26:14
que uno diga 00:26:17
anda, ¿y por qué me pasa esto? 00:26:18
claro, puede haber casuísticas muy complejas 00:26:20
pero tenemos toda la información necesaria en realidad 00:26:22
para meternos y decir 00:26:24
ah, vale, por esto 00:26:26
y si nos falta alguna 00:26:27
pues ya nos surgirá 00:26:30
vale, vamos a añadir 00:26:31
una cosa 00:26:34
para ya poder empezar a hacer programas sencillísimos 00:26:35
y ya poder escribir algo y no estar ahí todo el rato 00:26:38
aburridos escuchando, pero claro 00:26:40
para poder hacer un programa que tenga mínimamente sentido 00:26:42
tenemos que poder 00:26:44
darle datos desde fuera 00:26:46
porque esto de darle los datos por programa así 00:26:47
directamente, pues esto es una chapuza 00:26:50
¿no? porque entonces mi programa 00:26:52
si yo le doy 00:26:54
los datos directamente así, mi programa 00:26:56
va a operar con los mismos datos siempre 00:26:58
todo el rato con los mismos, poniendo 38 menos 27 00:27:00
que yo quiero que opere con otros 00:27:02
Tendría que irme al código fuente 00:27:04
Editar el código fuente, compilarlo y ejecutarlo 00:27:06
Eso no tiene ningún sentido 00:27:09
Yo quiero hacer un programa 00:27:10
Que los datos que tiene aquí 00:27:11
Los reciba en el momento de ejecutarse 00:27:14
Los reciba desde fuera 00:27:17
Si no, este programa solo va a ser útil 00:27:18
Para esos datos, no tendría mayor sentido 00:27:21
¿Vale? 00:27:23
Entonces los programas tienen que poder coger los datos 00:27:24
Desde fuera en el momento de ejecutarse 00:27:26
Para que tengan utilidad 00:27:28
Ese fuera, ¿cuál será? 00:27:30
ese fuera es el resto del mundo 00:27:32
una base de datos, un fichero 00:27:35
una conexión de red 00:27:37
pueden ser mil cosas 00:27:38
o puede ser un tío que está aquí delante escribiéndoselo 00:27:40
que es lo que vamos 00:27:43
nosotros a hacer 00:27:45
a lo largo de todo el curso 00:27:46
programas en los que 00:27:47
nosotros le metemos los datos en el momento de la ejecución 00:27:50
bien por aquí o bien pinchando en una ventana 00:27:53
me da lo mismo, se los estoy metiendo en el momento de la ejecución 00:27:55
¿vale? 00:27:57
para que los recojan de otros sitios 00:27:58
está el módulo de segundo 00:28:00
de acceso a datos porque no es trivial 00:28:03
el volcado de datos 00:28:04
de una fuente externa no es trivial 00:28:06
para que el programa luego 00:28:08
no se convierta en una especie de bolsa 00:28:10
en la que es intratable 00:28:13
inmanejable esos datos 00:28:14
hay que hacerlo de cierta manera 00:28:16
y para eso hay todo un módulo en segundo 00:28:18
nosotros ahora mismo 00:28:19
los datos los vamos a pasar por un tío 00:28:21
que está aquí sentado delante 00:28:24
y los va tecleando 00:28:25
bueno pues venga vamos a hacerlo en otra 00:28:27
clase 00:28:30
como ejemplo de 00:28:31
lectura de datos 00:28:34
y así ya aprendemos 00:28:35
a leer datos y ya podemos hacer 00:28:38
programas que hagan cosas 00:28:40
simples porque no podemos 00:28:42
hacer lecturas, o sea no podemos 00:28:45
hacer decisiones, ni bucles, ni nada 00:28:46
pero bueno 00:28:48
venga, pues este 00:28:49
es ejemplo 00:28:53
lectura de datos 00:28:54
le ponemos 00:28:57
el main 00:29:01
Y aquí tenemos la clase 00:29:01
Vale, pues a ver 00:29:04
Aquí 00:29:10
Esto ya lo aclarasteis, ¿no? 00:29:11
Con fold 00:29:15
Vale, pues aquí viene uno de los primeros actos de fe 00:29:15
Ya habéis hecho un acto de fe 00:29:19
Cuando yo os he dicho 00:29:23
Este class 00:29:25
Os tiene que 00:29:26
Entrar doblado 00:29:29
Y esto también 00:29:31
Ahí habéis hecho un primer acto de fe 00:29:32
en el que yo os he dicho, eso lo tenéis que poner calcado 00:29:34
para empezar a hacer nuestros programas 00:29:37
ya en su momento 00:29:39
perdón 00:29:40
bueno ya, o sea, se ponga eso o lo pongas tú 00:29:43
da igual, lo que quiero decir es que 00:29:49
lo estamos poniendo 00:29:51
sin saber por qué lo estamos poniendo 00:29:53
por eso me refiero que es un acto de fe que tenéis que hacer 00:29:55
ahora, porque yo no puedo explicar ahora 00:29:57
por qué se pone esto 00:29:59
¿vale? porque eso entra 00:30:01
dentro de la operación orientada a objetos 00:30:03
entonces, ahora mismo os estoy diciendo 00:30:04
para que un programa en Java 00:30:07
yo lo pueda compilar y ejecutar 00:30:09
tiene que tener esto 00:30:11
y a partir de aquí ya empezamos a programar 00:30:12
pero esto lo tiene que tener 00:30:15
es el primer acto de fe que estáis haciendo 00:30:16
bueno, pues para leer de teclado 00:30:19
ahora tenéis que hacer un segundo acto de fe 00:30:22
y es 00:30:23
escribir lo que yo os digo 00:30:25
de lo que más o menos 00:30:27
hombre, un poco os diré por donde van los tiros 00:30:28
pero no podemos tampoco entenderlo en profundidad 00:30:31
vale, pero algo acto de fe 00:30:33
tenéis que hacer, bueno, vale 00:30:35
pues queremos leer por teclado datos 00:30:37
para poder hacer nuestros primeros programas 00:30:39
vale, pues para leer 00:30:41
por teclado datos 00:30:43
tiene que aparecer aquí 00:30:44
alguien que sea capaz de hacerlo 00:30:46
hasta ahora que somos capaces 00:30:49
de hacer aparecer nosotros 00:30:51
variables, el único que somos capaces 00:30:53
de hacer aparecer variables 00:30:55
numéricas, char, boolean 00:30:56
es lo que somos capaces de aparecer 00:30:59
pero esas variables no nos valen 00:31:00
Vale, pero es que hay otro tipo de variables 00:31:02
Que no son las primitivas 00:31:06
Sino que son las variables objeto 00:31:08
Que esas sí que saben hacer muchas cosas 00:31:10
Las variables primitivas 00:31:13
No saben hacer nada 00:31:15
Solo saben 00:31:16
Aparecer por las buenas 00:31:17
Cuando yo la declaro en memoria RAM 00:31:19
Y guardar un valor dentro 00:31:21
No saben más que eso 00:31:22
Las variables primitivas 00:31:24
No saben más que lo que hemos visto 00:31:26
Guardar un valor dentro 00:31:28
Por si yo luego tengo que acceder a él con el nombre 00:31:29
pero hay otro tipo de variables que son las variables que llaman objeto 00:31:31
son los dos tipos de variables que hay, primitivas y objeto 00:31:34
pues otro tipo de variables que son las variables objeto 00:31:38
que esas sí que saben hacer un montón de cosas 00:31:40
y ya veremos en su momento por qué saben hacer, quién les ha dado ese poder 00:31:43
qué somos nosotros, quiénes se lo damos, cómo lo programamos para que lo tengan, etc. 00:31:46
bueno, pues entonces, para poder leer del teclado 00:31:51
como leer del teclado es algo que hay que hacer muy costoso 00:31:54
lo tiene que hacer una variable objeto 00:31:57
que son las que saben hacer cosas 00:31:59
¿cómo hacemos aparecer una variable objeto? 00:32:01
pues igual que hacemos aparecer una variable entera n 00:32:04
que la hacemos aparecer, paf, así de la nada 00:32:07
poniendo su nombre y el tipo de dato 00:32:08
la variable objeto también la hacemos aparecer de la nada 00:32:11
declarándola, poniendo el nombre que yo le quiero dar 00:32:14
pues mi variable objeto que va a aparecer de la nada 00:32:17
y que va a leer, ¿qué nombre le quiero dar? 00:32:20
bueno, como va a servir para leer 00:32:22
pues voy a llamar al lector de teclado 00:32:23
a la ya le he llamado lector de teclado 00:32:25
Pero claro, siempre que declaramos una variable, sea objeto o sea primitiva, siempre que le damos una variable hay que poner el tipo al que pertenece. 00:32:28
Igual que aquí ponemos int. 00:32:36
Bueno, pues primer acto de fe que yo os doy. 00:32:37
El tipo de dato de las variables objeto que son capaces de leer del teclado es este. 00:32:40
Hay más, no es el único, pero bueno, es el más cómodo. 00:32:49
Es este. 00:32:52
¿Vale? 00:32:55
Este es. 00:32:56
¿Y es este? Pues porque lo digo yo. 00:32:56
Y porque no lo digo yo. 00:32:59
Lo dice Oracle, que es el que ha hecho las clases que usamos. 00:33:02
Y es esa, Scanner. 00:33:06
Pues ya está, pues es Scanner. 00:33:08
Vale, nos sigue apareciendo en rojo. 00:33:11
Dice, uuuh, el compilador dice, Scanner, ¿de qué me hablas? 00:33:14
No sé de qué me hablas. 00:33:16
Claro, tercer acto de C, por el que ya vayábamos. 00:33:18
Ahora al principio hay que hacer unos cuantos, tercer acto de C. 00:33:21
Para usar variables que son de tipos objeto no primitivos 00:33:23
Hay que o poner el nombre completito 00:33:29
Que el nombre completito no es este 00:33:33
Este yo lo he puesto así porque soy muy chula 00:33:35
El nombre completo no es este, el nombre completo es este en realidad 00:33:37
Este es, aquí ya sí que se ha callado 00:33:40
O pongo el nombre completo del tipo de dato 00:33:44
O hago una trampita 00:33:48
vale, bueno pues el nombre completo 00:33:50
de ese tipo de dato 00:33:53
que me vale a mi para 00:33:56
como variable para leer 00:33:57
el nombre es este 00:33:59
y ya entenderemos también en su momento 00:34:01
porque ese nombre va con puntos 00:34:03
ahora podemos entenderlo, es ese 00:34:04
el tipo de dato 00:34:06
vale, y como veis se calla 00:34:07
vale, le gusta, igual que le ha gustado el int 00:34:12
igual que le ha gustado el int, pues este le gusta 00:34:14
porque este existe, le gusta 00:34:16
es feo pero le gusta 00:34:18
entonces como es tan feo 00:34:20
como es tan feo 00:34:22
java nos da un truquito 00:34:24
para ignorar este y poner escáner 00:34:25
solo, ya es el programa que da como más cortito 00:34:28
nos da un truquito, que de nuevo 00:34:30
este truquito, pues 00:34:32
no lo tenemos que tragar 00:34:33
¿qué es? pongo el prefijo 00:34:36
delante, que es el que es muy feo 00:34:38
pongo el prefijo delante 00:34:39
vale, import java útil 00:34:41
punto, o sea pongo el prefijo 00:34:44
pongo, el prefijo no 00:34:46
pongo el nombre enterito delante 00:34:48
el nombre 00:34:50
y ahora ya aquí puedo poner escáner sin más 00:34:51
y ya se calla 00:34:54
¿vale? 00:34:56
entonces este le pongo solo una vez al principio 00:34:57
y ahora ya yo aquí en mi aplicación 00:34:59
es que esta aplicación es corta porque solo tiene esto 00:35:02
podría tener muchas cosas 00:35:04
yo podría necesitar muchos escáneres en muchos sitios 00:35:05
entonces solamente voy a tener que poner a partir de ahí 00:35:07
escáner 00:35:10
si yo he puesto al principio del fichero 00:35:10
esta línea 00:35:14
o sea pongo al principio esa línea 00:35:14
import java útil scanner al principio 00:35:17
y luego ya a partir de ahí 00:35:19
cada vez que quiera declarar una variable 00:35:21
imagínate que quiero, no va a ser el caso aquí 00:35:23
pero que quiero declarar dos lectores 00:35:26
de teclado distintos 00:35:28
vale, pues yo con poner 00:35:29
scanner cada vez tengo suficiente 00:35:33
con poner scanner cada vez tengo suficiente 00:35:35
¿tenéis un package? 00:35:37
el package tiene que ir después del package 00:35:44
yo es que como no he metido package porque yo no 00:35:46
¿eh? 00:35:50
O sea, el package es lo que va al principio 00:35:50
De todo siempre 00:35:55
Si es que lo habéis puesto 00:35:55
Porque yo no he creado paquetes porque yo no os he explicado 00:35:57
Todavía como funcionan, entonces yo no los he creado 00:36:00
Yo estoy trabajando el paquete por defecto 00:36:02
Claro, entonces tú no pones package 00:36:04
Lo pones como yo 00:36:07
Pero no se puede poner package 00:36:07
Si tú estás en el default package aquí 00:36:13
Ahora lo miramos 00:36:14
Vale, ahora lo miramos 00:36:17
Un momentito, vamos a 00:36:18
Si alguien tiene puesto package 00:36:19
porque tiene paquete 00:36:23
que yo 00:36:23
eso porque os dé la gana a vosotros 00:36:24
yo no explico paquetes 00:36:26
con lo cual 00:36:28
si trabajan directamente 00:36:28
con el paquete por defecto 00:36:29
pues si alguien tuviera 00:36:31
un package ahí 00:36:31
por vete a saber que 00:36:32
o porque 00:36:33
va por delante 00:36:33
pues el import va después 00:36:35
¿vale? 00:36:36
pero en nuestro caso 00:36:37
yo eso 00:36:37
para mí ni existe el package 00:36:38
con lo cual 00:36:39
el import es la primera línea 00:36:40
entonces es un truco 00:36:41
tú lo pones al principio de todo 00:36:42
y cada vez que quieras 00:36:44
hacer referencia ahora 00:36:45
a este tipo de dato 00:36:46
ya no hace falta 00:36:47
que pongas 00:36:49
java.util 00:36:49
todo el rato 00:36:50
con poder escáner 00:36:51
vale 00:36:52
entonces esto ya va 00:36:52
no solo a gusto del programador 00:36:54
sino sobre todo 00:36:57
en función del código que yo tenga 00:36:58
pues si es más claro arrastrar el prefijo 00:37:02
si no lo es 00:37:04
porque hay veces cuando veamos paquetes 00:37:05
que si yo llevo el import aquí 00:37:07
quito información aquí y el que lo lee 00:37:09
no lo ve muy claro 00:37:11
entonces bueno, esto va a gusto 00:37:13
de la situación concreta en la que esté 00:37:15
con el escáner, que lo estamos usando todo el rato 00:37:17
no vamos a tener el jabot y el escáner aquí todo el rato 00:37:20
que es un coñazo, lo que vais a hacer con el escáner a efectos prácticos 00:37:22
vosotros va a ser, escribir escáner, cuando lo vayáis 00:37:26
a usar, escribir escáner, os va a decir 00:37:30
no conozco escáner, porque es lo que os dice, vale 00:37:34
bueno, os dirá eso, no conozco escáner porque no habéis puesto el import 00:37:38
pues como el entorno de desarrollo nos hace vagos, pues en lugar 00:37:42
de ir arriba a poner import, pues diremos, venga, y que me propones 00:37:46
Pues él te dice, te propongo hacerte un import 00:37:50
Uy, pues vale, justo lo que quería 00:37:53
Le dais a doble clic 00:37:55
Y te lo escribe solito 00:37:56
¿Vale? 00:37:58
Entonces, bueno, este va a ser vuestro proceder 00:38:01
Pero claro, es un proceder 00:38:04
No porque me lo mande el entorno de desarrollo 00:38:06
Sino porque sabéis que es lo que tenéis que hacer 00:38:07
Que no entendemos ahora 00:38:09
Por qué el import 00:38:12
No lo entendemos porque no tenemos ni idea de paquetes 00:38:13
Eso tiene que ver con paquetes 00:38:14
Pero es que, por eso digo que este es un acto de fe que tenéis que hacer 00:38:15
Si queréis leer del teclado desde ya 00:38:18
vale 00:38:19
vale, vamos a 00:38:21
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
13
Fecha:
26 de septiembre de 2023 - 13:19
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
38′ 26″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
733.47 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid