Saltar navegación

Java Básico 5 - Contenido educativo

Ajuste de pantalla

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

Subido el 26 de septiembre de 2024 por Stefano C.

43 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si habláis, pues me dais el consentimiento para que os grabe. 00:00:00
Vamos a ver una segunda tanda de Java básico, ¿vale? 00:00:09
Una segunda parte de Java básico que añadirá algunas cosillas a lo que ya hemos visto. 00:00:13
Empezamos con constantes. 00:00:21
Vosotros habéis visto variables, ¿vale? 00:00:23
Las variables que son, son trocitos de memoria donde guardo un valor y ese valor lo dejo allí dentro y este valor puede ser modificable. 00:00:25
En algún momento de mi ejercicio, de mi programa, pues puedo acceder a ese trozo de memoria y cambiar el valor que contiene. 00:00:35
¿Vale? Esas son las variables. 00:00:44
Podría darse el caso que en algunas circunstancias yo quiera crear un trozo de memoria donde guardo un valor, 00:00:46
Pero este valor quiero que no se pueda cambiar nunca jamás en el resto de mi programa 00:00:54
Pues esa variable que no puede cambiarse, pues sea más constante 00:01:00
Un ejemplo puede ser el número pi 00:01:06
Si yo uso pi para hacer los cálculos matemáticos de círculos y cosas por el estilo 00:01:09
De cálculo de área del círculo, etc. 00:01:17
Lo que podría hacer es crearme al principio una variable 00:01:18
Entre comillas, que tenga dentro 3,14 y no sé qué viene más 00:01:23
Y luego para el resto de mi programa 00:01:27
En vez de escribir siempre 3,14, 3,14 00:01:29
Pues uso pi como variable 00:01:32
Pero no quiero que se cambie porque pi no varía 00:01:34
Pues no creo, ¿vale? 00:01:38
Entonces en vez de declararlo como variable 00:01:40
Podría declararlo como constante 00:01:43
¿Cómo se declara una constante? 00:01:45
igual que una variable 00:01:47
lo único es que se pone 00:01:48
delante la palabra 00:01:51
reservada final 00:01:52
¿vale? 00:01:54
final, int 00:01:56
edad es igual a 13 00:01:57
quiere decir que 00:02:01
ese es un valor que se llama edad 00:02:02
que tiene dentro 13 00:02:04
y no puedo hacer en ningún lado 00:02:06
edad igual a 14 00:02:09
me va a dar un error 00:02:10
¿si? 00:02:12
por ejemplo, esta cosa aquí 00:02:14
final double p 00:02:16
es igual a 3,1415 00:02:18
bla bla bla 00:02:21
ahora yo no tengo que escribir esto cada vez 00:02:21
solo escribo pi 00:02:25
final int max usuarios 00:02:28
es igual a 300 que define que 00:02:30
en mi sistema 00:02:32
el número máximo de usuarios es 300 00:02:34
¿qué querrá decir? no lo sé 00:02:37
depende de mi sistema, pero si yo voy añadiendo 00:02:38
usuarios y de repente 00:02:41
tengo que añadir el usuario número 301 00:02:42
Me debería decir no 00:02:45
Ya he alcanzado el número máximo de usuarios 00:02:47
Eso depende de mí de programador 00:02:49
¿Notáis algo en términos de sintaxis 00:02:52
De cómo se escriben las cosas con respecto a las variables? 00:02:57
La mayúscula 00:03:02
Las variables se ponen todas en mayúscula 00:03:03
Si yo veo un nombre de algo 00:03:07
Que está escrito todo en mayúscula 00:03:09
Esa es una constante 00:03:11
Y esto es necesario, hay que hacerlo así, si no, no funciona 00:03:13
Pues no, puedes hacerlo como te da la gana 00:03:20
Pero los otros programadores de Java del mundo te agradecerán 00:03:22
Si tú las constantes las pones todas en mayúsculas 00:03:27
Y tú agradecerás a todos los otros programadores de Java del mundo 00:03:31
Porque cuando verás un nombre en mayúsculas, sabe que esa es una constante 00:03:37
Una constante no puede cambiar de su valor 00:03:41
El identificado de una constante suele ir todo en mayúsculas 00:03:45
¿Dudas? 00:03:49
Siguiente 00:03:51
Ámbito de las variables y de las constantes 00:03:52
El ámbito de una variable es donde existe esta variable 00:03:55
Las variables no existen siempre por todo lado 00:04:00
Las variables existen solo dentro del bloque en el que se han declarado 00:04:07
¿Qué es un bloque? 00:04:14
Es una llave y cerrallave 00:04:17
Lo que está dentro de abrir llave y cerrallave 00:04:20
Ese es un bloque, un bloque de código 00:04:23
Si yo tengo abre llave, declaro unas variables 00:04:25
Esas existirán hasta que este bloque se cierre 00:04:28
Si voy fuera de este bloque, las variables que he declarado allí dentro dejan de existir. 00:04:35
Entonces, nosotros hemos hecho, hemos creado las variables en el bloque main. 00:04:46
Nosotros trabajamos todo dentro del bloque main. 00:04:57
Se enfadaría. 00:05:05
Por ejemplo, aquí abajo. 00:05:06
Imaginaos esta cosa de aquí. 00:05:10
Esto funciona, no hay problemas. 00:05:13
La cosa de abajo no, ¿qué diferencia hay? 00:05:16
Que veis el primer bloque va de aquí a aquí, todo es un bloque 00:05:20
Y luego hay un bloque interno 00:05:24
Dentro de este bloque interno, como pertenece al bloque externo 00:05:25
La variable a sigue existiendo 00:05:30
La variable a existe desde este símbolo de aquí, desde el principio hasta el final 00:05:32
Entonces si yo dentro de aquí tengo otro bloque y le digo que b vale a 00:05:37
Este a es este a 00:05:41
Existe 00:05:44
Ahora mira este otro en vez 00:05:45
Yo estoy declarando la variable a dentro de un bloque interno 00:05:47
Cuando luego fuera en el bloque externo intento utilizar a 00:05:51
Esto me dará un error 00:05:55
Porque la variable a ha dejado de existir 00:05:57
Cuando hemos llegado a este paréntesis de aquí 00:06:01
A esta llave de aquí 00:06:03
A ya no existe 00:06:05
Fuera de este bloque interno 00:06:07
A no existe, no se ha declarado 00:06:10
Te diría a no se ha declarado 00:06:12
Te diría él 00:06:14
Cannot resolve symbol 00:06:15
Y ahora 00:06:18
Esto tiene poco sentido 00:06:21
Dentro de un rato cuando veremos if 00:06:22
Cuando veremos while y cosas por el estilo 00:06:25
Que cada if que daremos y luego abriremos un bloque 00:06:26
Allí tendrá un poquito más de sentido 00:06:29
Pero lo que tenéis que quedaros 00:06:31
Y recordaros es que hay 00:06:33
Un ámbito de las variables 00:06:34
Hay un lugar de existencia de las variables 00:06:36
Las variables no existen por todo lado 00:06:39
Si no existen solo dentro del bloque 00:06:40
Donde se han declarado 00:06:43
¿Sí? 00:06:45
Está claro también que dentro del mismo bloque 00:06:48
No puedo crear dos variables 00:06:51
Que se llamen igual 00:06:54
No puedo hacer int a 00:06:55
Dos veces dentro del mismo bloque 00:06:58
Pero en bloques distintos sí 00:06:59
¿Vale? 00:07:01
Para hacer ejemplos más visuales 00:07:04
Si yo aquí hago 00:07:08
Int a es igual a 3 00:07:12
Ahí 00:07:14
e int a es igual a 4 00:07:17
se va a enfadar 00:07:21
me dice, mira que a ya existe 00:07:23
duplicate local variable a 00:07:25
pero si yo digo 00:07:28
ningún problema 00:07:30
he creado esta variable a 00:07:36
que ha llegado aquí 00:07:39
ha dejado de existir 00:07:42
entonces declararla otra vez 00:07:44
no es un problema 00:07:46
oye, cuidado, esta a no es esta a 00:07:47
son dos cosas distintas 00:07:49
Esta es una variable a que ha existido en este bloque 00:07:51
Y que he usado aquí haciendo alguna operación con a 00:07:55
Hago operaciones con a 00:07:58
Pero no es la misma a que uso aquí 00:08:03
Cuando ha llegado aquí 00:08:07
La a declarada aquí ha desaparecido 00:08:09
Y entonces puedo tranquilamente utilizar otra 00:08:17
Aquí no 00:08:21
Porque ya existe una A 00:08:26
Si yo declaro otra A 00:08:28
Me dicen, ay, olvídate corchete 00:08:30
No hemos usado corchete 00:08:40
¿Qué es solo corchete? No existe 00:08:41
Hasta ahora 00:08:43
Nosotros, lo que pasa es que main 00:08:47
Es un bloque de aquí a aquí 00:08:49
En realidad nosotros usamos dos bloques 00:08:51
Tenemos también el bloque del class 00:08:53
Pero nosotros por ahora 00:08:55
Trabajamos solo dentro de un bloque 00:08:57
Y por ahora no hemos creado ni utilizado 00:08:59
otros bloques, por lo tanto nos afecta relativamente 00:09:01
cuando tendré un if 00:09:04
el if pondrá aquí 00:09:06
y abrirá un bloque, entonces las variables 00:09:09
que creo dentro de este if no se verán fuera 00:09:11
pero más adelante 00:09:14
queda claro que 00:09:16
las variables no existen por todo 00:09:21
lado, si no existen solo 00:09:23
dentro del bloque en que se han creado 00:09:25
o bloques interiores 00:09:27
fijaos aquí 00:09:29
A no la he declarado en este bloque 00:09:31
Pero es un bloque interno 00:09:34
A un bloque donde se ha declarado A 00:09:36
Por lo tanto existe 00:09:38
Sería 00:09:39
Si yo declaro A aquí 00:09:42
Luego aquí hago otro bloque 00:09:49
E intento aquí dentro 00:09:51
Declarar otra vez A 00:09:54
¿Qué pasa? 00:09:55
¿Va a dar? 00:09:59
Es otro bloque distinto 00:10:00
Pero este bloque pertenece a este bloque 00:10:02
Y por lo tanto A ya se ha utilizado 00:10:05
¿Sí? 00:10:07
Más cosillas 00:10:14
Ahí 00:10:16
Si se declara un ámbito más externo 00:10:18
Se podrá acceder a la misma desde un ámbito más externo 00:10:22
Va, sí 00:10:25
Si yo declaro 00:10:26
B, por ejemplo, aquí dentro 00:10:29
Fuera no lo puedo utilizar 00:10:31
Porque acabado este bloque 00:10:34
Pues B desaparece 00:10:36
¿Sí? 00:10:38
Por ejemplo, este es un ámbito, tenemos el main, x está declarado en el main, luego creo otro bloque donde creo q, aquí dentro puedo hacer int suma es igual a x más q, tranquilamente. 00:10:40
Aquí puedo utilizar tanto X como Q como suma 00:10:56
No hay problema porque estoy dentro del bloque 00:11:00
Cuando salgo de este bloque me queda disponible solo X 00:11:03
No puedo acceder ni a suma ni a Q 00:11:07
Ya no existe 00:11:10
¿Queda claro? 00:11:13
¿Dudas? 00:11:16
¿Sigo? 00:11:19
Expresiones, ¿qué son las expresiones? 00:11:24
Son conjuntos de token que el programa 00:11:26
Podrá resolver en tiempo de ejecución 00:11:28
A un valor concreto 00:11:30
Es 3 más 4 00:11:31
Token 3, token más 00:11:32
Token 4 00:11:36
En tiempo de ejecución 00:11:37
El ordenador lo que hace es hacer 00:11:39
3 más 4 es igual a 7 00:11:41
Y usará esta expresión como si valiera 7 00:11:43
Esas expresiones son 00:11:46
Más simples, consisten de un literal 00:11:49
O sea, 3 es una expresión 00:11:51
La comilla, tres comillas, es una expresión, es un literal de tipo string. 00:11:54
Y si no, son combinaciones de literales, variables, constantes y operadores. 00:12:00
¿Sí? 00:12:11
Ejemplos. 00:12:12
Todas estas son expresiones, ¿vale? 00:12:13
Dos más tres es una expresión. 00:12:17
Tres por saldo es una expresión. 00:12:19
Dos más incentivo es una expresión. 00:12:21
paréntesis, paréntesis, saldo, dividido por 2, paréntesis, más 1000, paréntesis, módulo 10 00:12:23
es una expresión 00:12:28
yo la escribo así, a tiempo de ejecución, cuando lanzo el programa 00:12:29
el programa mirará cuánto vale saldo, sacará de la memoria el valor de saldo 00:12:33
hace todas las operaciones, saca un valor 00:12:38
y ahora esta expresión está evaluada en este valor 00:12:40
¿sé cuánto vale el valor en tiempo de compilación? 00:12:43
no, porque no sé cuánto valdrá saldo 00:12:46
es una variable, a lo mejor se lee de teclado 00:12:49
Pero al tiempo de ejecución, cuando le toca evaluar esta expresión 00:12:52
Él irá a mirar saldo, cuánto vale en ese momento 00:12:59
Y sacará el valor total de esa expresión 00:13:01
Los operadores son los símbolos que me permiten hacer algún tipo de operación 00:13:04
Que pueden ser aritmética, pueden ser lógica, pueden ser de byte 00:13:10
Pueden ser de varias cosas, ahora veremos algunos operadores 00:13:15
Y permiten combinar variables para crear expresiones más complejas 00:13:19
El operador de agrupación es la paréntesis 00:13:28
La hemos usado ya alguna vez 00:13:33
Si yo hago esto, me hará antes 2 más 3 00:13:36
Y luego el resultado de 2 más 3 lo multiplicará por 5 00:13:40
Sirve para desambiguar 00:13:43
Pensad esto sin paréntesis, 2 más 3 por 5, ¿vale? Normalmente nosotros hemos aprendido desde la matemática de, no sé, de cuando se ve, de primaria, final de primaria o si no, de la ESO, que antes se hace multiplicación y división y luego se hacen las sumas. 00:13:46
¿Pero por qué? Porque no se lo han dicho como regla. También el Java tiene sus reglas, tiene su prioridad de las operaciones. 00:14:07
Entonces, si yo pongo las operaciones al azar así, sin paréntesis, o me sé muy bien cuál es el orden de prioridad con que se van a evaluar las operaciones, 00:14:17
y por lo tanto escribo lo que yo quiero 00:14:27
o si no me pongo a poner paréntesis 00:14:29
es decir que 00:14:31
tenéis que saber esto 00:14:33
esto son todas las 00:14:34
operaciones, los operadores 00:14:37
y el orden con que se ejecutan 00:14:39
si no os queréis 00:14:41
aprender esto, usad paréntesis 00:14:43
vale, vuelvo aquí 00:14:45
operación de agrupación, me dice 00:14:50
esta paréntesis de aquí, lo que hay dentro 00:14:53
se evalúa antes, cuando se ha evaluado esto 00:14:55
se evalúa lo que está afuera 00:14:57
Voy rapidito porque estas son cosas que más o menos ya he visto en bachillerato o por algún lado 00:14:58
Si tenéis dudas levantad la mano 00:15:06
Clasificación de operadores, por el número de expresiones que requiere 00:15:09
Existen tres tipos de operadores dependiendo de cuántas expresiones requieren 00:15:14
Hay operadores unarios 00:15:20
Operadores unarios necesitan una sola expresión 00:15:22
Por ejemplo, el menos. El operador menos uno requiere una expresión, la expresión es uno, y el operador te dice, cámbiale el signo, ¿sí? 00:15:27
Podría ser la operación operador interresultado es igual a operador menos, y aquí pongo la expresión que me da la gana. 00:15:40
Por ejemplo, a más 7 por 4 más a por a. 00:15:56
Este operador de aquí pilla una expresión y una vez que tenga el valor le cambia el signo. 00:16:07
Es un operador unario, pilla una sola expresión. 00:16:17
Luego están binarios. 00:16:22
que son los más comunes, a más 4, 3, 2. 00:16:26
El operador más es binario porque pilla una expresión y otra expresión. 00:16:37
Lo podría hacer así. 00:16:46
Este de aquí es binario porque pilla esta expresión y esta expresión, y la suma. 00:16:54
Operador de suma, resta, multiplicación, división, módulo 00:17:01
Son todos binarios 00:17:07
¿Dudas? 00:17:08
Y luego está una cosa nueva, que es el operador ternario 00:17:12
El operador ternario pilla tres expresiones 00:17:15
Una, dos y tres 00:17:23
Y esto no lo habéis visto en vuestra vida 00:17:26
Y esto es algo parecido a un if 00:17:29
Pero no es un if, es un operador 00:17:33
Si vosotros en vuestra vida habéis visto un if 00:17:36
Sabéis programar 00:17:40
Pues esto sonará de alguna forma 00:17:41
Pero es menos potente que un if 00:17:44
Un if puede hacer esto y mucho más 00:17:46
Mientras que el operador puede hacer solo esta cosa 00:17:48
El operador ternario pilla tres expresiones 00:17:51
La primera es una expresión booleana 00:17:57
¿Qué quiere decir una expresión booleana? 00:17:59
Que el resultado será o true o false 00:18:02
Si esto que le he puesto aquí es true 00:18:05
Entonces todo el operador vale esto 00:18:09
Si lo que le he puesto aquí vale false 00:18:13
Todo el operador vale esto 00:18:18
Y ahora haremos ejemplo 00:18:21
¿Sí? 00:18:26
Es como una pregunta 00:18:31
Esto es así 00:18:32
Si sí, entonces esta cosa aquí 00:18:34
Y si no, esta cosa aquí 00:18:36
Punto y coma 00:18:38
¿Vale? 00:18:39
Pero el if te permite hacer instrucciones 00:18:41
Mientras esta no es una instrucción 00:18:49
Estas son valores 00:18:51
Es una expresión 00:18:53
Es al final, yo estar aquí 00:18:55
Me tiene que valer algo concreto 00:18:57
Esto vale 3,4 00:18:59
O vale 4,7 00:19:01
Dependiendo de num 00:19:02
Y de su comparación con 3 00:19:03
Pero no le puede hacer imprime en pantalla 00:19:05
Que quiere decir el if abarca todo 00:19:08
En el if puedes hacer esto 00:19:15
Pero puedes hacer también escribirla en pantalla 00:19:20
Este no, porque escribir en pantalla no es una expresión 00:19:22
Es una instrucción 00:19:26
Entonces no es exactamente un if 00:19:28
Pero nosotros lo usaremos casi como if 00:19:30
Para los primeros ejercicios 00:19:32
También en vez de clasificar los operadores 00:19:34
Por cuantas expresiones requieren 00:19:39
Entonces un ario, binario, eternario 00:19:42
Los puede hacer en base a 00:19:43
Que posición tiene con respecto a la expresión 00:19:46
Prefijo es un operador que se pone antes de la expresión 00:19:51
Como por ejemplo, más más saldo 00:19:56
O menos menos intereses 00:19:58
Postfijo se pone después 00:20:00
Como por ejemplo, beneficio más más 00:20:03
Y infijo es cuando está entre medias 00:20:05
Como por ejemplo, A más B 00:20:09
¿Sí? 00:20:10
Esto lo veremos muy poco 00:20:12
Pero esto sí lo veremos mucho 00:20:14
¿Sí? 00:20:16
Y esto también 00:20:18
¿Sí? 00:20:19
Sí, ahora hacemos ejemplo 00:20:20
Pero la idea del ternario es que tengo tres expresiones 00:20:24
Una, dos y tres 00:20:28
Entonces, si esta es verdadera, todo esto vale esto 00:20:31
Si esta es falsa, todo esto vale esto 00:20:38
Y ahora hacemos un par de ejemplos o ejercicios y vemos cómo es 00:20:44
Vamos a hacer ejemplos antes de meternos a este de aquí 00:20:50
Entonces, por ejemplo 00:20:57
Voy a crear una nueva 00:21:00
Para hacer ejemplos 00:21:06
Vamos a hacer un poco de ejemplos sobre todo de este ternario 00:21:15
Que es el que es un poquito más nuevo 00:21:32
Por ejemplo, yo tengo un entero 00:21:34
Int A es igual a 3 00:21:38
Tengo otro entero 00:21:40
Int B es igual a 7 00:21:42
A 6 00:21:44
Y ahora digo que 00:21:45
El entero C 00:21:48
Es igual a 00:21:50
Si A es menor que B 00:21:52
Entonces C valdrá 0 00:21:57
Si no 00:22:02
¿Cuánto vale C? 00:22:07
Vamos a verlo 00:22:16
Si eso, C vale 0. 00:22:18
Ahora, ¿qué pasa si yo le digo, oye, A vale 8? 00:22:32
¿Sí? 00:22:49
Ahora vamos a darle un poquito de sentido. 00:22:49
Int nota es igual a scan.nextInt. 00:22:55
Si eso, dame tu nota. 00:23:00
¿Sí? 00:23:11
Vale. 00:23:12
Y ahora digo, string resultado es igual, si nota es mayor o igual a 5, vale, has aprobado, si no, has suspendido y luego imprime. 00:23:12
Resultado 00:23:50
¿Qué he hecho? 00:23:52
Aquí 00:24:03
Esta es una expresión 00:24:04
Si tú aquí pones una expresión booleana que vale true 00:24:06
Pues al final vale un true 00:24:08
Pero lo tendrás que guardar en un true 00:24:10
¿Por qué no? 00:24:11
Si en el examen donde yo te estoy evaluando 00:24:21
Si tú sabes el operador ternario 00:24:23
Tú no me utilizas el operador ternario 00:24:27
¿Cuánto vas a sacar en el apartado operador ternario? 00:24:30
Cero 00:24:34
No obstante, funciona perfectamente 00:24:34
No, voy a especificar que el próximo examen 00:24:36
Es sobre lo que hemos hecho hasta ahora 00:24:44
Y no hemos hecho el IF 00:24:46
¿Dudas? 00:24:47
¿Qué he hecho? 00:24:57
¿Qué hace este ejercicio? 00:25:00
Es un ejercicio que me dice si ha probado o no 00:25:08
¿Vale? 00:25:10
Entonces, dame la nota 00:25:12
¿Cuánto he sacado? 00:25:14
¿Seis? 00:25:17
Has aprobado 00:25:18
Si dice un tres 00:25:19
ha suspendido. Mirámoslo bien. He leído un número, lo he puesto en nota, ¿sí? Y luego aquí me estoy 00:25:26
preguntando, este operador es todo un operador entero, ¿vale? Este es todo un operador. Es un 00:25:38
operador único y se basa sobre, si nota es mayor o igual que 5, entonces todo esto vale esta expresión 00:25:47
de aquí. Si esto es falso, todo vale esta expresión de aquí. Por lo tanto, si me has 00:25:58
dado un 7, pues como 7 es mayor que 5, pues entonces es verdadero, por lo tanto yo pillaré 00:26:08
esta expresión que es la que guardo en resultado. Y luego la escribo. Si en vez de esto no es 00:26:15
Verdad, pues, nota. 00:26:27
¿Puedo poner aquí un string y aquí un int? 00:26:30
¿Por qué no? 00:26:34
Porque estos dos señores tienen que tener el mismo tipo. 00:26:44
¿Sí? 00:26:48
Porque es verdad que dependen de esto. 00:26:49
Pero al final, lo que me espero es un... 00:26:52
No puedo decirle en un caso una cosa, en un caso otra. 00:26:59
Cosa que a lo mejor con un if podrías lograr haciendo... 00:27:01
Es un operador solo. 00:27:05
Entonces, las dos string, o sea, las dos expresiones que pongo aquí, pueden ser distintas, valores distintos, complejas cuando os da la gana, pero tienen que devolver el mismo tipo. 00:27:08
Si este es un string, esto también es un string. Si este es un int, esto también es un int. Y si este es un bool, pues esto también es un bool. 00:27:24
Sí, pero yo 00:27:32
A lo mejor no lo estoy usando aquí 00:27:42
A lo mejor estoy haciendo esto 00:27:43
No lo estoy guardando en ningún lado 00:27:45
Pero yo me espero que 00:27:57
Print pilla aquí 00:27:59
Un string 00:28:02
Entonces me espero que el final de esto 00:28:03
Es string, si aquí le pongo 3 00:28:05
A lo mejor va a hacer cosas raras 00:28:07
Pues me la acepta 00:28:09
¿Por qué me la acepta? 00:28:11
Porque Println acepta tanto esto como esto de aquí 00:28:14
Pero no lo hagáis así 00:28:17
¿Vale? 00:28:18
Así, mejor. 00:28:20
Va bonito. 00:28:23
Porque admite las dos cosas. 00:28:27
Pero está... 00:28:29
No la caes. 00:28:30
Ha suspendido. 00:28:33
Más bien, no luchéis contra vosotros mismos a la hora de complicar las cosas, ¿vale? 00:28:37
Intentad mantener lo más sencillo. 00:28:42
Esto por ahora es la cosa más compleja que hemos visto, ¿vale? 00:28:46
Y será la cosa más compleja que hemos visto 00:28:50
Por un ratito 00:28:53
Luego llegará el if 00:28:54
Y ya esto no es tan complejo 00:28:56
Luego ya va el while 00:28:58
Y esto es súper sencillo 00:29:00
¿Sí? 00:29:04
Y de allí 00:29:05
Nada, ya allí somos programadores 00:29:06
¿Dudas? 00:29:12
Está haciendo una comparación entre un double 00:29:31
Y un int 00:29:32
De esta forma esto es un operador de mayor 00:29:33
Él sabe que 5,00001 00:29:36
es mayor que 5. ¿Dudas? ¿Se entiende más o menos cómo funciona esto? ¿Queréis otro 00:29:38
ejemplo? ¿Otro tipo de dado? ¿Qué le hacemos? Va, lo habéis querido vosotros. Entonces, 00:29:47
Entonces, dame tu nota, ¿vale? 00:30:07
Esta de aquí. 00:30:16
Si es estrictamente de mayor que 5, has aprobado mucho. 00:30:18
Si no, si la nota es igual a 5 y has aprobado por los pelos, y si no, has suspendido. 00:30:25
No, pero me da un error de bajo. 00:30:51
Eso lo pillan 00:31:03
Dejamos los a int 00:31:04
Me da un error aquí 00:31:06
¿Qué será? 00:31:08
¿Por qué falta un paréntesis? 00:31:10
¡Voilá! 00:31:13
¿Sí? 00:31:20
¿Qué estoy haciendo? 00:31:21
Complicarnos la vida 00:31:27
Esto tiene tres casos 00:31:29
¿Vale? 00:31:31
Primera compruebo uno 00:31:33
Si esto es verdadero, entonces es esto 00:31:35
¿Vale? 00:31:37
Si no, vuelvo a hacer otra comprobación 00:31:38
de si es igual. Si es igual, entonces has aprobado por los pelos. Si llego aquí, quiere 00:31:43
decir que no era esto, porque si no habría devuelto esta cosa aquí, y no era esto, perdón, 00:31:50
no era esto, porque si no habría devuelto esta cosa aquí. Entonces es el tercer caso. 00:31:59
Estoy metiendo un operador ternario dentro de un operador ternario. Hasta el infinito. 00:32:03
Pero al final 00:32:16
Todo esta cosa de aquí 00:32:19
Tiene que devolverme 00:32:22
Un string 00:32:25
Yo lo puedo evaluar 00:32:26
Complicado o cuanto queráis 00:32:30
Pero al final esto valdrá un string 00:32:32
Y lo imprimo por batalla 00:32:34
Hoy se me ha borrado 00:32:35
No todo está grabado 00:32:39
Con otro 00:32:43
En vez que un string 00:32:45
Pues que queremos hacer 00:32:49
Un double 00:32:51
¿Qué sé yo? 00:32:52
Dame tu nota 00:32:55
Dame... ¿Qué sé yo? 00:32:57
No sé cómo hacer 00:32:59
¿Qué ejemplo hacer? 00:32:59
Positivo y negativo 00:33:01
Dame... 00:33:02
No, pero siempre, siempre... 00:33:05
Vale 00:33:09
Dame un número 00:33:09
¿Vale? 00:33:11
Leo el número 00:33:13
Ahora 00:33:14
Interresultado es igual a 00:33:15
Si... 00:33:18
Nota, bueno, num 00:33:20
Si num 00:33:21
es menor que cero 00:33:25
entonces 00:33:29
menos num, si no 00:33:32
num, imprime num 00:33:37
¿qué he hecho? 00:33:42
¿qué he hecho? 00:33:51
darle un título a este ejercicio 00:33:51
exacto, calcula el valor absoluto de un número 00:33:53
¿a que si? 00:34:03
Ahora, si os acordáis 00:34:07
Que es un valor absoluto de un número 00:34:10
Pero, esto 00:34:12
¿Sí? 00:34:15
¿Os ha gustado? 00:34:18
¿Estáis contentos de haber conocido 00:34:19
El operador 00:34:21
Ternario 00:34:22
Listos a sufrir para los próximos ejercicios 00:34:24
Muy bien 00:34:27
Vale 00:34:28
Más cosillas 00:34:30
Clasificaciones, esto lo hemos hecho 00:34:34
Tipos de expresiones, vale 00:34:36
El tipo de datos que devuelve una expresión 00:34:38
Dependerá del tipo de las expresiones involucradas 00:34:42
Algo de esto ya hemos hecho 00:34:45
Hemos visto que si hago intero más double 00:34:47
Tengo un double 00:34:51
Si hago un int más dividido 00:34:52
Resultado es un int 00:34:55
Hay algunas conversiones que se pueden hacer 00:34:57
Que son estas de aquí 00:35:02
Las conversiones automáticas o implícitas son cuando se converte desde un tipo compatible más pequeño a un tipo compatible más grande 00:35:04
¿Qué quiere decir? Es cuando tengo un float y lo guardo en un double 00:35:17
Como float es más pequeño y double es más grande 00:35:21
Y tanto double como float son decimales 00:35:27
Por lo tanto son compatibles 00:35:31
Puedo hacerlo, no hay problema 00:35:33
Puedo guardar un float dentro de un double 00:35:35
No puedo guardar un double dentro de un float 00:35:38
¿Por qué no? 00:35:41
Porque son compatibles 00:35:43
Pero no es de más pequeño a más grande 00:35:45
De más grande a más pequeño 00:35:47
Eso no se puede hacer 00:35:49
Si yo tengo un int 00:35:50
¿Lo puedo guardar en un long? 00:35:53
Sí 00:35:58
Porque int son 4 bytes 00:35:59
Un long son 8 bytes 00:36:01
Y por lo tanto un int 00:36:03
Puedo tranquilamente guardarlo en un long 00:36:04
Puedo guardar un 00:36:06
Int en un short 00:36:09
Porque int son 4, short son 2 bytes 00:36:13
Por lo tanto uno más grande 00:36:17
No lo puedo guardar ahí dentro 00:36:18
Pero son compatibles, si 00:36:20
Son enteros los dos 00:36:22
Pero no lo puedo hacer 00:36:23
Y estas 00:36:25
Se llaman implícita o automáticas 00:36:27
Porque Java te lo hace en automático 00:36:30
Por ejemplo esto 00:36:32
Esto no te lo debería hacer 00:36:34
Esto 00:36:39
Sí 00:36:42
Esto debería haber una FG 00:36:43
Esto lo hace 00:36:45
Float 00:36:46
N1 es igual a 00:36:52
3.14 00:36:54
Se enfada 00:36:55
¿Sí? 00:36:57
Le tengo que poner una F 00:36:59
¿Sí? Ahora sí 00:37:00
Y si luego hago doble 00:37:03
X es igual a 00:37:05
N1, sin problema 00:37:09
¿Sí? 00:37:11
¿Dudas? 00:37:15
Cuanto más preciso sea, mejoré 00:37:23
¿Vale? 00:37:25
En algunos programas, en lenguaje de programación 00:37:26
Como por ejemplo C 00:37:34
El falso 0 00:37:35
Y cualquier otro número 00:37:38
Es verdadero 00:37:40
Entonces luego puedes hacer una conversión de booleano 00:37:41
A entero 00:37:45
No os aconsejo que lo hagáis 00:37:46
Luego, existen la posibilidad de hacer conversiones de tipos compatibles más grandes a más pequeños. 00:37:47
Pero en un cierto sentido le tienes que decir tú, oye, mira, sé que esto va a dar problemas, pero hazlo. 00:37:58
Como por ejemplo, al revés. 00:38:11
Antes me parecía que no me había dejado, dejadme probar. 00:38:15
Y imaginaos que hago doble pi es igual a 3.14 00:38:18
Y ahora le digo float pif es igual a pi 00:38:27
No me va a dejar 00:38:35
¿Vale? 00:38:37
Pero si yo le digo 00:38:38
No, espera 00:38:40
Que me doy cuenta 00:38:41
Sé que aquí hay algún problema 00:38:43
Pero confía en mí, hazlo 00:38:48
Ahora, puede ser que esto cause problema 00:38:53
Porque podría ser que tengo tantos números decimales 00:38:57
Que un double lo puede representar, pero un flat no 00:39:09
Entonces es lo que se llama pérdida de precisión 00:39:12
La pérdida de precisión más grande es si tengo doble pi 00:39:16
lo tenemos allí, int pi como entero 00:39:23
es igual a int 00:39:27
de pi, fenomenal, son tipos numéricos 00:39:31
son compatibles, ahora mi pi vale 00:39:36
3, y el vuestro profesor 00:39:39
de matemática que os ha hecho trigonometría y cosas por el estilo, en este momento está haciendo 00:39:43
¡ah! sí, sí, no me deja hacerlo 00:39:47
Porque no me deja 00:40:00
Pero yo le estoy diciendo 00:40:02
Sé lo que estoy haciendo 00:40:05
Y a lo mejor es porque yo quiero 00:40:07
Pillar la parte entera de este número 00:40:09
Quiero pillar por un lado la parte entera 00:40:10
Luego hago 00:40:13
Doble 00:40:15
Parte 00:40:16
Decimal 00:40:19
Es igual a pi menos pi 00:40:20
Y ahora ya tengo solo la parte 00:40:23
Decimal de este punto 00:40:26
pillo la parte entera 00:40:27
luego pillo el número, le quito la parte entera 00:40:30
pues me quedo solo con la parte decimal 00:40:32
¿por qué me sirve la parte decimal para hacer no sé qué? 00:40:34
¿sí? 00:40:39
entonces, esto se llaman 00:40:40
casting explícitos 00:40:42
o conversiones explícitas 00:40:44
si os fijáis, aquí no le estoy diciendo nada 00:40:46
aquí faltaría una F 00:40:49
aquí no le estoy diciendo nada 00:40:50
la conversión me la hace él 00:40:53
aquí le tengo que decir 00:40:54
explícitamente haz la conversión 00:40:57
explícito 00:40:59
y luego hay castings 00:41:00
que no se pueden hacer 00:41:03
¿vale? no puedo hacer 00:41:04
pp-n 00:41:07
con n un entero 00:41:09
no está definido el operador 00:41:11
menos 00:41:14
entre estas cosas ¿vale? 00:41:14
o por ejemplo 00:41:17
esta cosa aquí no la puedo hacer 00:41:19
bueno, sí, pero creo que 00:41:21
perdón, creo que esta no me la deja 00:41:27
hacer porque no puede hacer el casting a pp-n no no tiene sentido esta me la hace 00:41:30
pero pierdo dos cosas esto es interesante mirar de internet es igual a 170 vale que 00:41:34
él lo hace con short o con byte, no me acuerdo, byte, byte b es igual a byte de n, a seguir 00:41:45
lo dice, a seguir lo dice así, no me acuerdo, aquí byte k igual a n, vamos sin esto, no 00:42:01
me deja, ¿sí? Estas no se pueden hacer, pero ¿qué pasaría si lo hago así? Y luego 00:42:11
digo, si eso 00:42:17
que creéis que va a hacer 00:42:21
que va a hacer aquí 00:42:27
vamos a verlo 00:42:29
menos 86 00:42:32
bytes son 256 00:42:39
pero la mitad son positivos 00:42:45
y la mitad son negativos 00:42:47
y los negativos son los que van 00:42:48
desde 128 para arriba 00:42:51
entonces como he puesto 170 00:42:52
pues me he pasado de 128 00:42:55
y ahora me está dando los números negativos 00:42:57
entonces me sale menos 36, ahora imaginaos 00:42:59
que esto lo habéis hecho por error 00:43:01
en algún lado de los millones 00:43:03
de líneas de código que tenéis por allí 00:43:05
y alguien nos dice de hacer 00:43:07
una transferencia de 170 euros 00:43:09
en positivo 00:43:12
y vosotros le vais a quitar 86 euros 00:43:13
cuidado 00:43:16
cuidado estas cosas 00:43:19
si te pillan 00:43:21
vale 00:43:23
si, entonces tres tipos 00:43:24
Los tipos de expresiones 00:43:27
No en el sentido que hay varios tipos de expresiones 00:43:29
Sino que tipo tienen las expresiones 00:43:31
Hay que calcular 00:43:33
La expresión cuanto vale 00:43:36
Y ver que tipo tiene 00:43:37
Y luego hay conversiones que pueden ser implícita o explícita 00:43:38
O que no se pueden hacer 00:43:41
Porque hace caso 00:43:43
Operadores 00:43:43
Estos los conocemos 00:43:48
Aritméticos 00:43:50
Estos también los conocemos 00:43:51
Un poquito 00:43:55
Son de comparación 00:43:55
¿Vale? Dos números iguales, dos números distintos 00:43:57
Mayores, menor, mayor igual y menor igual 00:44:01
¿Vale? El operador ternario que pilla un booleano 00:44:03
Yo le hago una expresión 1 y una expresión 2 00:44:09
Hay dos bloques aquí que no hemos visto todavía 00:44:11
Estos, que no os lo explico 00:44:15
Existen, pero son cosas a nivel de bit 00:44:19
Shift de bit y cosas por el estilo 00:44:22
Esto si no vais a hacer cosas muy muy concretas de la informática 00:44:25
No los volveréis a ver en vuestra vida 00:44:29
Pero esto sí, esto lo veréis demasiado 00:44:31
Estos son operadores booleanos 00:44:36
Sirven para combinar dos expresiones booleanas 00:44:38
Verdadero y falso 00:44:44
O verdadero o falso 00:44:47
Le dedicaremos un poquito más de tiempo 00:44:50
Mañana no 00:44:52
Pero más adelante 00:44:53
Y estos operadores compactos 00:44:57
Los que nos interesa son estos de aquí 00:45:02
Y este de aquí principalmente 00:45:04
Si yo tengo una variable a más más 00:45:06
Es como decir que a vale a más uno 00:45:10
Sustancialmente sumarle uno a 00:45:13
Menos menos resta uno a 00:45:15
Más igual es como hacer 00:45:19
Ahora os lo enseño 00:45:21
Se hace antes así 00:45:24
Si yo tengo 00:45:25
Int 00:45:29
Número es igual a cero 00:45:30
¿Cuánto vale 00:45:33
Int 00:45:37
Número dos 00:45:38
Número 00:45:39
Número más más 00:45:41
Preciso 00:45:45
Número 00:45:49
¿Cuánto me imprime? 00:45:51
Uno 00:45:53
Déjame quitar 00:45:54
esto 00:45:57
y esto 00:45:59
y esto 00:46:02
y si vuelvo a hacer esto 00:46:08
¿ahora cuánto vale? 00:46:13
¿sí? 00:46:19
esto es equivalente 00:46:23
a hacer 00:46:25
número 00:46:26
es igual a 00:46:28
número más 1 00:46:31
Pilla el valor actual de número, súmale 1 y guárdalo en número 00:46:33
Esto es equivalente a decir 00:46:41
Número es igual a número menos 1 00:46:51
Y luego están cosillas como 00:46:56
Número más igual 3 00:47:04
Esta es equivalente a decir 00:47:08
Número es igual a 00:47:12
Número 00:47:14
Más 3 00:47:15
Porque es el esquema más compacto 00:47:17
Y yo esto lo odio 00:47:28
Esto sí 00:47:29
Pero estos de aquí 00:47:31
Yo los odio 00:47:34
A veces puede tener su sentido 00:47:34
Y os lo digo 00:47:40
No porque lo uséis 00:47:42
Pero están aquí 00:47:43
Son los mismos con más o menos 00:47:45
por dividido y 00:47:48
módulo, ¿vale? 00:47:49
pero 00:47:52
porque lo podéis ver 00:47:53
de repente los veis 00:47:55
a veces estos se usan en while 00:47:57
y cosas por el estilo, se pueden utilizar al final 00:47:59
para actualizar el valor 00:48:01
esto sí que se usa 00:48:03
más más y menos menos se usa mucho 00:48:07
sobre todo en un for, por ejemplo 00:48:09
y finalmente 00:48:10
y aquí acabo 00:48:13
pues los operadores y su orden 00:48:14
Si yo tengo una expresión grande así y quiero evaluarla, pues primero busco estos operadores de aquí. 00:48:17
Una vez que he evaluado estos operadores de aquí, paso a estos, luego a estos, luego a estos, luego a estos, luego a estos, luego a estos, hasta el final. 00:48:27
Es la razón de por qué las multiplicaciones se ejecutan antes de la suma, por ejemplo. 00:48:42
Repito, si no me acuerdo esto 00:48:47
Pongo paréntesis 00:48:53
Lo estás forzando tú, estás diciendo 00:48:54
Antes hazme esto, luego esto 00:49:00
Y luego lo sumas con esto 00:49:02
Le estás diciendo tú 00:49:04
A lo mejor lo podrías escribir en una forma 00:49:06
Sin paréntesis, pero a lo mejor 00:49:08
Se vuelve más complicado 00:49:10
Luego de leer, no lo sé, eso lo sabéis vosotros 00:49:12
¿Dudas? 00:49:14
Vale 00:49:19
Sobre estos de aquí 00:49:19
And, and, etc 00:49:22
Vamos a hacer un dibujito 00:49:24
Paint. 00:49:26
Nosotros, cuando trabajamos con valores de verdad, tenemos dos valores, true o false. 00:49:33
¿Sí? ¿Verdadero o falso? 00:49:43
¿Vale? 00:49:45
Yo puedo tener una expresión grande, cuanto os da la gana, que cuando se resuelve, me da o true o false. 00:49:46
¿Vale? 00:49:54
Pero, ¿qué pasa si yo tengo dos expresiones y quiero combinarlas entre ellas? 00:49:54
Pues, existen tablas de verdad. 00:49:59
Por ejemplo, el operador end, que se escribe así porque sí. 00:50:03
¿Se puede poner con una sola? 00:50:13
No, ponedlo siempre con dos ampersand, este simbolito de aquí. 00:50:15
El que está encima del 6, el que... Dungeons and Dragons. 00:50:19
¿Habéis visto la película? 00:50:26
Pues este de aquí. 00:50:28
Este es el operador 1. 00:50:31
Este es el operador 2. 00:50:34
Hay cuatro casos 00:50:35
Esto puede ser verdadero, esto puede ser falso 00:50:37
Esto puede ser verdadero, esto puede ser falso 00:50:40
Más que operador, esto serían expresiones 00:50:44
La expresión uno y la expresión dos 00:50:47
A ver, si la expresión uno es verdadero 00:50:49
Y la expresión e, esto es un e 00:50:53
No, perdón, i, e es en italiano, i 00:50:55
Si la expresión uno es verdadero 00:51:00
Y la expresión 2 es verdadero 00:51:04
¿Será verdadero? 00:51:07
Pero, si esta es falsa y esta es verdadera 00:51:11
¿Cómo será? 00:51:16
Falso 00:51:18
Y si esta es verdadera y esta es falsa 00:51:19
Falso 00:51:25
Y si las dos son falsas 00:51:26
Falso 00:51:29
¿Sí? 00:51:31
Ahora hacemos ejemplos 00:51:34
Si nos da tiempo 00:51:43
Luego está el OR 00:51:44
Y solo si 00:51:48
El I 00:51:54
Solo si las dos son verdaderas 00:51:56
Es verdadero 00:51:58
Si no, es falso 00:51:59
Y si no está el OR 00:52:01
O esta o esta 00:52:03
Entonces 00:52:04
Este es el OR 00:52:05
Esto es true 00:52:07
False 00:52:10
True y false 00:52:11
Si son verdaderas las dos, es verdadero 00:52:14
Si una es verdadera y la otra falsa, también es verdadero 00:52:20
Si una es verdadera y la otra falsa, también es verdadero 00:52:23
Si las dos son falsas, es falso 00:52:26
O sea, sustancialmente estos dos operadores me dicen 00:52:29
Si las dos son verdaderas, es verdadero 00:52:32
Y si no es falso 00:52:36
O esta de aquí es si una de las dos es verdadera 00:52:37
O las dos son verdaderas 00:52:41
Es un or 00:52:42
O esto o esto 00:52:44
me vale cualquier de las dos 00:52:46
este es un i 00:52:48
las dos a la vez 00:52:50
mientras que este aquí es un or 00:52:52
o las dos o una de las dos 00:52:53
y con esto haremos ejemplos 00:52:55
en los próximos días 00:52:59
la otra 00:53:00
el otro que tenemos 00:53:02
es el not 00:53:05
el not es 00:53:06
si soy true 00:53:09
not true es false 00:53:10
esto es al revés 00:53:12
es este de aquí 00:53:14
este. Y es lo que 00:53:17
sale aquí. 00:53:24
Esto es como decir not igual. 00:53:27
O sea, diferente. 00:53:30
¿Sí? 00:53:32
Esto 00:53:34
cambia 00:53:35
valor de verdad de lo que tú 00:53:38
tienes. 00:53:43
¿Sí? Entonces, 00:53:44
oye, señores, que aquí no hemos acabado. 00:53:48
Vamos a hacer pruebas. 00:53:54
Boolean. 00:53:56
B1 es igual a 5 menor que 3 00:53:56
¿Cuánto vale B1? 00:54:05
Falso 00:54:18
¿Vale? 00:54:18
Ahora, hagamos así 00:54:21
X menor que 10 00:54:23
Verdadero 00:54:27
¿Estamos de acuerdo hasta aquí? 00:54:33
Ahora, ¿cómo hago una expresión aquí para que B1 sea verdadero? 00:54:34
solo si x está entre 0 y 10. 00:54:41
Por ejemplo, con esto he comprobado si x es una nota, 00:55:17
porque es un valor entre 0 y 10. 00:55:25
Entonces podría hacer una cosa así. 00:55:28
Si, no, bueno, si no, string res es igual a si b1, tu nota es más x. 00:55:30
Si no, no es una nota válida 00:55:52
¿Cómo lo veis? 00:55:59
Bueno, esto X, ya existe un X 00:56:07
Pero, ¿me entendéis? 00:56:10
¿Qué he hecho? 00:56:12
Este de aquí es una cosa que me dice 00:56:14
Que esto es verdadero solo si 00:56:16
Las dos expresiones aquí son verdaderas a la vez 00:56:20
Porque he usado Y 00:56:25
entonces si x es mayor que cero y al mismo tiempo x es menor o igual que 10 o sea un 00:56:26
valor entre 0 y 10 esto será verdadero y luego digo que si esto es verdadero entonces te doy 00:56:36
tu nota pero si esto es falso quiere decir que la nota que se ha puesto aquí o es menor que 00:56:44
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
43
Fecha:
26 de septiembre de 2024 - 14:30
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
56′ 52″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
219.87 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid