Saltar navegación

Java Básico 2 - 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 29 de septiembre de 2026 por Stefano C.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si habláis, me dais vuestra autorización a grabar vuestra voz. Dicho esto, segunda parte del Java básico. Hasta ahora nosotros hemos visto variables, hemos visto cómo leer de teclado, cómo escribir en pantalla y poco más. 00:00:00
Algunos operadores, suma, resta y división. Vamos a añadir más elementos para poder hacer más ejercicios, ejercicios más distintos y empezar un poquito a acercarnos a lo que es la parte interesante de este primer trimestre, que son el control del flujo de información, que son if, while, iterativos, condicionales y llamadas de métodos. 00:00:16
¿Sí? Entonces, lo que vamos a ver hoy son muchas cosillas, ¿vale? 00:00:44
Nosotros hemos visto las variables. ¿Qué es una variable? 00:00:49
Es un trozo de memoria donde dentro le pongo un valor. 00:00:52
Este valor está asociado con un tipo, solo puede tener un determinado tipo. 00:00:56
Puede variar este valor. 00:01:00
Sí. Y en cualquier momento puede decir int edad es igual a 10. 00:01:04
Y mañana es mi cumpleaños y pongo edad es igual a edad más 1. 00:01:10
Pues ya está. Ahora tengo 11 dentro de él. 00:01:14
Se llama variable porque este trozo de memoria está allí, nadie me lo toca, nadie lo modifica, pero en cualquier momento yo puedo cambiar esto. 00:01:16
Hay situaciones, hay contextos dentro de mis programas y mis sistemas en el que yo podría crear un trozo de memoria diciendo, 00:01:27
mira, yo aquí dentro te meto un valor que te pongo al principio y quiero que este valor no cambie nunca jamás. 00:01:34
De una ejecución a otra 00:01:42
Podría hasta variar 00:01:46
Yo podría decir, vale, este es un juego 00:01:47
Dime el número de jugadores 00:01:49
¿Cuánto hay? Tres, vale, a partir de ahora 00:01:51
Para esta sesión hay tres jugadores 00:01:53
La próxima vez cuando juego 00:01:55
Digo, ahora hay siete jugadores, vale, perfecto 00:01:57
En esta partida hay siete jugadores 00:01:59
Pero no cambiarán nunca hasta que 00:02:01
No reinicie el juego, ¿sí? 00:02:03
Por ejemplo, estas no se llaman 00:02:05
Variables, sino se llaman 00:02:07
Constantes, ¿vale? Por ejemplo 00:02:09
el pi griego 00:02:11
es una constante 00:02:13
¿por qué? porque no vale 00:02:16
¿vale? 00:02:18
¿cómo se define? exactamente 00:02:20
como una variable 00:02:22
solo que le ponemos 00:02:24
delante la palabra reservada 00:02:26
final, como decir, este es tu valor 00:02:28
final, no vas a cambiar 00:02:30
nunca, ¿vale? 00:02:32
entonces, final double pi 00:02:34
es igual a 00:02:36
pues me crea un trozo de memoria 00:02:37
pone dentro este valor, ese trozo de memoria se referencia como 00:02:41
con la palabra pi, ¿vale? pi 00:02:45
pero ya no puedo cambiarlo, no puedo hacer después 00:02:48
pi es igual a 3, me va a dar un error, me dice 00:02:53
no, no lo puedes modificar, si le quito el final, sí, puede hacer lo que me la haga 00:02:56
pero con el final, una vez definido, es eso para siempre 00:03:01
¿ok? para diferenciarlas 00:03:04
De las variables, las constantes van todas en mayúsculo. 00:03:09
El nombre de la variable se pone entera en mayúsculo. 00:03:15
Por ejemplo, en el ejercicio que hemos hecho antes, ¿esto qué será? 00:03:19
Una constante. 00:03:27
¿De qué clase? ¿Dónde es definida esta clase? 00:03:28
¿Dónde está definida esta constante? 00:03:31
En la clase math. 00:03:35
Si yo me voy a la clase math.java y voy a leer el código de math.java, allí dentro encontraré una línea que pone final double p es igual a 3,14, bla, bla, bla. 00:03:36
¿Entiendes? 00:03:52
O por ejemplo, final int max-usuarios, veis, todo en mayúscula, es igual a 300. 00:03:57
Eso quiere decir que mi sistema es máximo 300 usuarios. 00:04:04
Y eso no cambiará nunca. 00:04:07
se escribe en mayúscula 00:04:08
porque así yo cuando leo 00:04:11
un nombre, más o menos sé 00:04:12
de qué estoy hablando 00:04:15
empieza por mayúscula, pero el resto es minúscula 00:04:16
posiblemente es un objeto, como string 00:04:19
como scanner 00:04:21
es todo minúsculo 00:04:22
probablemente es o una variable 00:04:24
o un método 00:04:27
todavía no lo hemos visto, hemos visto main 00:04:28
todo mayúsculo 00:04:30
pues eso no lo está 00:04:33
entonces, ¿es necesario 00:04:34
que sea así? No. Podéis hacer lo que os da la gana. ¿Todos los que 00:04:37
programan en Java hacen así? Sí. Por lo tanto, si no lo hacéis, la gente 00:04:41
que programa en Java os dirá que lo se ha escrito mal. 00:04:45
Una constante no puede cambiar su valor. El identificador 00:04:50
de una constante suele ir en mayúsculas. 00:04:53
Tema, concepto, abstracto 00:04:59
y teórico. ¿Vale? 00:05:02
el ámbito de una variable 00:05:06
o de una constante 00:05:08
un elemento de estos que creo 00:05:09
hasta ahora 00:05:12
en inglés se llama scope 00:05:12
¿vale? 00:05:15
¿qué es el ámbito de una variable? 00:05:17
es donde existe esta variable 00:05:19
la variable 00:05:22
existe en el bloque 00:05:24
en que la creo 00:05:26
¿qué era un bloque? 00:05:27
¿os acordáis los delimitadores de bloque? 00:05:30
cuando vimos los delimitadores 00:05:37
como la tercera transparencia del Java Básico 1, vimos delimitador de bloque. 00:05:38
¿Qué era el delimitador de bloque? 00:05:43
La llave. 00:05:46
Se marca que aquí empezó un bloque de código, aquí acaba un bloque de código. 00:05:48
Llave abierta, llave cerrada. 00:05:53
Pues si yo declaro una variable aquí dentro, esta variable tiene sentido, existe dentro de este bloque. 00:05:55
Si salgo de este bloque, esta variable ya no existe. 00:06:03
por ahora es que me cuentas dentro de un rato tendrá sentido pero acordados si yo te abro abro 00:06:06
una llave declaró una variable si cierro esa llave no puedo volver a utilizar esa variable 00:06:15
ya no existe fuera de ese modo puede ser sensible sólo dentro del bloque es decir entre estas cosas 00:06:21
aquí vale en el que ha sido definida el mismo nombre de otra declarada del mismo ámbito vale 00:06:30
si yo hago int edad es igual a 3 y ahora hago int edad es igual a 4, pues él colapsa, porque dice 00:06:35
no, dentro de un bloque o tú defines una variable con un nombre en un bloque, pues dentro de este 00:06:42
bloque no puede haber otra variable que tenga el mismo nombre. En un bloque distinto quizás sí, 00:06:49
pero dentro de este bloque no. Si se declara una variable en un ámbito más interno, 00:06:54
no se podrá acceder a la misma 00:07:04
desde un ámbito más externo. 00:07:06
Sin embargo, desde un ámbito más interno 00:07:07
sí se puede acceder a las variables externas. 00:07:10
¿Qué quiere decir? 00:07:12
Mirad esta cosa de aquí. 00:07:14
¿Aquí cuántos bloques hay? 00:07:16
Dos. 00:07:18
Uno que es este de aquí, más externo, 00:07:19
y un bloque interno. 00:07:22
Si yo hago int a es igual a 3, 00:07:25
este a existe en el bloque externo. 00:07:28
Sí. 00:07:32
¿Existe en el bloque interno? Sí, también, porque ésta dejará de existir cuando salgo de este bloque. 00:07:32
Por lo tanto, todos los bloques que están dentro tienen ésta. Por lo tanto, si yo aquí dentro hago 00:07:41
int b es igual a, funciona perfectamente. Ahora, imaginaos esta otra cosa. ¿Cuántos bloques hay aquí? 00:07:47
siempre 2, ¿vale? Abro el primer bloque, abro el segundo bloque y declaro la variable int a es 00:07:55
igual a 3 dentro del bloque interno y luego intento utilizarlo en el bloque externo. Esto 00:08:04
me da un error, me dice no sé qué es a. Imaginaos aquí, hago un bloque y digo int a es igual a 3 00:08:13
y luego creo otro bloque dentro 00:08:34
que digo int b es igual a 00:08:38
ningún problema 00:08:40
¿vale? no me da errores 00:08:42
se puede hacer 00:08:44
si yo aquí hago 00:08:45
int x es igual a 00:08:47
a más 3 funciona 00:08:51
¿por qué no? 00:08:52
pero si lo he declarado aquí 00:08:56
¿por qué no funciona? 00:08:57
porque estoy fuera de este bloque 00:08:59
el bloque donde se ha declarado 00:09:01
ha acabado aquí. Y por lo tanto 00:09:03
aquí A no existe. 00:09:05
¿Cuánto vale aquí? 00:09:16
Y he entrado aquí dentro, he creado A 00:09:19
¿Vale? 00:09:27
He dado 3. Cuando he llegado aquí 00:09:29
A ha desaparecido. 00:09:32
Ya no existe. 00:09:34
Y he creado otro trozo de memoria que se 00:09:35
llama A donde le he puesto 7. 00:09:37
Son dos variables distintas. 00:09:41
Si yo muevo esta línea 00:09:44
aquí. ¿Funciona? 00:09:45
Sí. 00:09:48
Porque ahora yo he definido en el bloque este de aquí, el bloque del main, he definido la variable A. 00:09:57
Y cuando intento volver a definir A en un bloque más interno, la variable A ya existe. 00:10:05
Y no puedo declarar dos variables en el mismo ámbito que se llamen igual. 00:10:13
¿Se entiende? 00:10:20
¿Se le quitará a Selim? 00:10:21
sí, claro, pero entonces 00:10:22
lo que sería, no estaría 00:10:25
declarando otras variables 00:10:27
o si pusiera 00:10:29
pusiera double, funcionaría 00:10:31
¿está la variable? 00:10:33
no puedo tener 00:10:38
dos variables que se llamen 00:10:39
igual dentro del 00:10:41
mismo ámbito, y me da igual 00:10:43
yo no te he hablado de tipo, te he hablado 00:10:45
del nombre, vale, no se puede 00:10:47
yo no puedo poner aquí scanner A 00:10:49
no puedo poner aquí double A 00:10:51
o boolean A, pues que ya existe. 00:10:53
Entonces, A no lo puede usar hasta que acabe el bloque. 00:10:57
Cuando acabe el bloque, si lo quiero reutilizar en otro bloque, ¿por qué no? 00:11:00
¿Ve? No se suele hacer. 00:11:05
¿Dudas? 00:11:08
¿Entiende el ámbito de una variable? 00:11:10
Es donde existe esta variable. 00:11:12
Existe dentro del bloque en la que la hemos definido 00:11:14
y normalmente por debajo de donde se define. 00:11:19
O sea, por arriba de donde se define no existe. 00:11:22
El discurso que si yo esto lo bajo abajo, funciona porque cuando llego aquí, A no existe, entonces la puedo crear. 00:11:25
Y cuando llego aquí, esta A desaparece, entonces cuando vuelvo a recrearla, pues sigue sin existir y la puedo recrear. 00:11:37
Ahora, esta A y esta A no tienen nada que ver, son trozos de memoria separados. 00:11:46
Lo que hago en esta A no es lo mismo lo que hago en esta A. 00:11:52
Son dos cosas completamente distintas. 00:11:56
Por eso situaciones de este estilo no se suelen hacer. 00:11:59
No se suelen llamar las mismas variables iguales porque luego te confundes. 00:12:02
Llámala A1 y A2 si no tienes tantas. 00:12:08
¿Sí? 00:12:13
¿Dudas sobre el ámbito de la variable? 00:12:17
Lo mismo vale para las constantes. 00:12:18
¿Dónde dejó la constante? 00:12:20
Dentro de ese bloque existe. 00:12:21
dudas 00:12:22
clase ámbito 00:12:24
que está mal porque debe ser colar mayúscula 00:12:29
este es el main, creo la 00:12:31
x, creo la q 00:12:33
interso más x más q lo puedo hacer 00:12:35
porque x existe 00:12:37
en todo este bloque aquí y q 00:12:39
existe en este bloque aquí, por lo tanto 00:12:41
lo puedo hacer, si salgo fuera 00:12:43
y digo dime cuánto vale x 00:12:45
pues valdrá, existirá porque x 00:12:47
vale, existe 00:12:49
también en este bloque 00:12:51
dudas 00:12:52
Expresiones son un conjunto de tokens que el programa podrá resolver en tiempo de ejecución a un valor concreto, ¿vale? 00:12:58
Lo que decimos a la derecha del igual va a una expresión. 00:13:05
Esta expresión es un conjunto de sumas, restas, operaciones y cosas por el estilo. 00:13:09
Lo que hace el programa es pillar toda esa expresión, evaluarla y de allí sacar un valor. 00:13:14
Y ese es el valor de la expresión. 00:13:21
Y ese valor tendrá un tipo, ¿vale? 00:13:24
Si el tipo coincide con una variable 00:13:26
Puedo guardar ese valor en esa variable 00:13:28
Si no, no 00:13:32
Si el resultado de mi expresión es un booleano 00:13:32
Y yo tengo un int x 00:13:37
Pues no puedo guardar el booleano dentro de un int x 00:13:38
Pero si la expresión al final me da un entero 00:13:41
Y tengo un int x 00:13:44
Pues puedo guardar este valor ahí 00:13:45
La expresión más simple consiste de un literal 00:13:47
O sea, tres es una expresión 00:13:51
comillas, gato, comillas 00:13:53
es una expresión 00:13:56
es un literal, lo vimos la semana pasada 00:13:57
que eran los literales 00:14:01
otro tipo 00:14:02
de expresión habitual es un identificador 00:14:04
de variable, también una variable 00:14:06
puede ser una expresión 00:14:08
una expresión 00:14:10
¿vale? 00:14:12
aquí, esta es una expresión 00:14:16
esta es una expresión 00:14:18
sería una expresión, pero B no existe. ¿Qué error me da? 00:14:22
B cannot be resolved to a variable. No puedo pillar B y decir qué variable es. 00:14:34
No puedo resolverla a una variable. No puedo decir, ah, B es esta variable de aquí. 00:14:43
No me has dicho que es B. Me tienes que decir que es B antes. 00:14:48
lo he dicho aquí. Sí, pero en un bloque interno y desde esta paréntesis de aquí, b no existe. 00:14:52
Y si quisiera usarla, pues pillo esta, la pongo aquí fuera, le doy un valor inicial, aquí lo cambio a y ahora sí que me existe. 00:15:00
Porque ahora la he declarado en el bloque externo y entonces existe aquí y sigue existiendo aquí. 00:15:11
dejará de existir cuando salgo de este bloc. 00:15:21
¿Entiendes? Sí, vale. 00:15:25
Operadores, ¿vale? 00:15:34
Son símbolos que representan algún tipo de operación. 00:15:36
Hay varios tipos de operaciones distintas. 00:15:40
Nosotros conocemos típicamente las aritméticas y ya las hemos usado. 00:15:43
Summa, resta, división y multiplicación. 00:15:46
La única que ha un poquito molesta es la división. 00:15:48
Todos los demás son bastante fáciles. 00:15:51
Pero hay otros tipos de operaciones. 00:15:53
hay las lógicas, que nos sirven para crear expresiones, ¿vale? 00:15:55
2 más 3 es una expresión, 3 más saldo es una expresión, saldo más incentivos es una expresión, 00:16:02
saldo dividido por 2 es lo que sale, más 1000 es lo que sale, módulo 10 es una expresión. 00:16:09
Ahí es el módulo, cierra el módulo. 00:16:15
El resto de la división entera. 00:16:19
Agrupación. El operador de agrupación son las paréntesis. 00:16:25
¿Vale? Me sirven para situaciones como estas, para saber qué se ejecuta antes y qué después. 00:16:28
¿Vale? Hay dos opciones, tenéis dos opciones. 00:16:35
O sabéis de memoria esta tabla, que os dice qué operadores se ejecutan antes que otros, 00:16:38
o usáis las paréntesis. 00:16:49
Elegid vosotros. 00:16:52
Y yo uso las paréntesis. 00:16:54
Clasificación de operadores 00:16:55
¿Vale? Por el número de expresión 00:17:00
O por la posición que ocupan de esto 00:17:02
¿Vale? Si yo hablo de los operadores 00:17:04
Sean aritméticos 00:17:06
Sean lógicos y cosas por el estilo 00:17:08
Puedo agruparlos, puedo definirlos 00:17:10
De alguna forma ¿Vale? 00:17:12
Si son monarios o unarios 00:17:14
Yo suelo usar unarios 00:17:16
Son operadores 00:17:18
Que solo reciben un parámetro 00:17:20
Como por ejemplo 00:17:22
Menos uno 00:17:24
Menos 1, ¿cuántos parámetros reciben? 00:17:26
Solo el 1. 00:17:28
¿Vale? 00:17:29
Y lo que te está diciendo es, invértele el signo a ese 1. 00:17:29
Si 1 es positivo, menos 1 es negativo. 00:17:34
¿Entiendes? 00:17:41
Eso sería un ario, porque recibe un solo elemento. 00:17:42
Nosotros estamos más acostumbrados a los binarios, ¿vale? 00:17:52
Que reciben 2, como 3 más 2. 00:17:55
El operador más recibe dos elementos. 00:17:59
Necesita dos operandos para poder operar. 00:18:03
¿Sí? 00:18:07
El operador es el más. 00:18:07
El más es un operador binario. 00:18:09
¿Por qué? 00:18:11
Porque recibe dos valores y hace algo con estos dos valores. 00:18:11
El operador de concatenación. 00:18:16
¿Cuál es? 00:18:19
El más. 00:18:22
¿Y cómo es? 00:18:23
¿Unario, binario? 00:18:24
Binario también. 00:18:27
el string que tienes a la izquierda 00:18:30
pégale detrás el string que tienes 00:18:33
a la derecha 00:18:35
¿sí? ¿dudas? 00:18:36
y luego está 00:18:41
el operador ternario 00:18:41
que sostancialmente es sólo esto 00:18:42
y sólo veremos esto 00:18:44
pero, bueno, existe 00:18:46
el operador ternario es un operador que recibe 00:18:48
tres cosas 00:18:50
¿vale? 00:18:53
y esto es lo más parecido 00:18:54
a un if 00:18:57
sin que sea un if. 00:18:58
Esto no es un if. 00:19:00
¿Vale? 00:19:03
Nosotros lo usaremos if, como if, 00:19:04
hasta que veamos los if 00:19:06
que son de verdad, pero el if 00:19:08
es más potente que esta cosa. 00:19:10
Esta es una expresión. 00:19:12
El if no es una expresión. 00:19:14
¿Vale? 00:19:17
¿Qué es esto? Me dice, mira, 00:19:17
es este operador aquí, este operador aquí. 00:19:20
¿Vale? Interrogación 00:19:22
y dos puntos. Y recibe 00:19:24
tres cosas. Esto 00:19:26
esto y esto. Por eso es ternario. ¿Cómo funciona? Es una pregunta. Dice, ¿esta cosa de aquí es 00:19:27
verdadera? Si es verdadera, mi valor es esto. Si es falsa, mi valor es esto. Si el número vale 5, 00:19:38
esta expresión, ¿cuánto vale? 00:19:52
4.7 00:19:56
y si NUM en vez es 10 00:19:57
¿cuánto vale? 4.7 00:20:00
y si NUM es 130 00:20:06
4.7 00:20:08
y si NUM es 4.7 00:20:12
pues siempre 4.7 00:20:14
y si NUM es 3 00:20:17
porque esto 00:20:20
es el operador de igualdad 00:20:24
y dice, si NUM 00:20:25
es exactamente 00:20:28
3 es, entonces 00:20:29
yo, todo esto 00:20:33
vale 3,4. 00:20:35
Sin embargo, si no es 3, 00:20:38
todo esto vale 4,6. 00:20:42
Entonces, es en un cierto sentido 00:20:45
el primer 00:20:46
prototipo de condicional que yo tengo. 00:20:48
Aquí puedo hacerme una pregunta 00:20:53
en base a lo que hay aquí dentro, decidir si 00:20:55
si el resultado es uno u otro. 00:20:59
Es como la suma. 00:21:03
5 más 3, ¿no es así? 5 más 3, pero 00:21:05
si la luna es llena, entonces vale 7 00:21:07
y si no, vale 00:21:09
5 más 3, 8. 00:21:10
Siempre. 00:21:13
Sin embargo, este de aquí es, 00:21:15
dependiendo de esta cosa de aquí, 00:21:17
que será un... ¿Qué tipo tiene 00:21:19
esta parte de aquí? 00:21:21
Esta es una expresión aritmética 00:21:27
y el resultado de esto es un número. 00:21:30
Esa es una operación booleana. 00:21:36
Aquí, el resultado de esto tiene que ser o true o false. 00:21:41
Si el resultado de este es true, entonces me das esto. 00:21:46
Si el resultado de este es false, entonces me das esto. 00:21:50
Estos dos señores tienen que tener el mismo tipo. 00:21:55
Si he usado double, tiene que ser double. Si he usado int, int. Si string, string. 00:22:00
Puedo usar lo que me da la gana, pero tienen que ser iguales. 00:22:04
¿Veis? 00:22:07
Por hacer un secado. 00:22:10
Pero, más que esto de aquí, que ahora lo volveremos a ver, el operador ternario, 00:22:13
este operador ternario de aquí, es, cuando yo tengo un operador, 00:22:18
te puedo decir, oye, mira, te estás equivocando, este operador es un ario. 00:22:22
¿Qué quiere decir? 00:22:25
Que solo se usa para un elemento. 00:22:26
O no, mira, que estás usando la forma, pero como un aria, pero en realidad es binaria. 00:22:30
¿Qué te estoy diciendo? Oye, que te falta un operando. ¿Entiendes? 00:22:34
Esto es sólo para clasificación. Existen operadores unarios, 00:22:41
existen operadores binarios, existen operadores ternarios. 00:22:44
Típicamente nosotros usaremos... Nosotros usaremos como operador unario también el 00:22:48
NOT. Esto cambia el valor de verdad a lo que viene después. 00:23:00
Por ejemplo, ¿cuánto vale todo esto? 00:23:08
¿3 es igual a 5? 00:23:19
No. 00:23:23
Esto sería falso. 00:23:24
Este operador de aquí, que es un ario, 00:23:27
esto se aplica a un solo elemento, que es este de aquí, 00:23:30
lo que haría es negar lo que es esto. 00:23:33
Por lo tanto, todo esto es... 00:23:35
Volveremos sobre eso. 00:23:40
¿Vale? 00:23:42
O, en vez de mirar cuántos operadores, cuántos operandos pilla, 00:23:46
puedo clasificar los operadores en base a dónde se ponen. 00:23:51
Entonces son o prefijos, o posfijos, o infijos. 00:23:57
¿Vale? 00:24:02
Prefijos, el operador va antes del operando. 00:24:03
Posfijo, el operador va después del operando. 00:24:08
Y infijo va en el medio de los operandos. 00:24:12
Por ejemplo, menos uno, el menos, 00:24:15
es prefijos, posfijos o infijos. 00:24:18
prefijo, ¿vale? En 2 más saldo, entonces el más, infirmo, ¿vale? El, creo que lo hemos visto una vez, 00:24:21
me equivoco, no lo sé, el operador este de aquí que hace 5a es igual a 5a, a más más. 00:24:32
No hemos visto esto 00:24:49
Visto nunca 00:24:51
Esto es equivalente a decir 00:24:54
A es igual a A más 1 00:24:56
Hacer esto 00:24:59
O hacer esto 00:25:04
Es exactamente lo mismo 00:25:06
Suma 1 00:25:08
A esa variable 00:25:10
Y lo verbo guardar en esa variable 00:25:12
¿Ok? 00:25:14
Esto es un operador 00:25:16
Infijo, prefijo, posfijo 00:25:17
Postfijo 00:25:22
porque viene después 00:25:24
unario, binario, ternario 00:25:26
unario 00:25:28
unario, pues fijo 00:25:30
existe también el mas-masa 00:25:32
pero lo dejamos en otro 00:25:36
compuesto 00:25:38
no se suele usar nunca 00:25:39
antes hace la suma y luego lo usa 00:25:41
entonces cuando lo usas 00:25:47
dentro de cosas así puede variar 00:25:49
pero se suele utilizar el mas-mas 00:25:50
¿dudas? 00:25:52
¿sí? 00:25:57
Preguntas, aquí, esto es solo nombres, para que ellos digan a veces, 00:25:58
mira que esto es un operador infijo, y tú entiendas qué quiere decir. 00:26:05
Tipos de expresiones, vale, nosotros, el tipo de datos que devuelve una expresión 00:26:11
dependerá del tipo de la expresión involucrada, vale, lo que decíamos, un int más int, el resultado es? 00:26:18
int 00:26:23
int por double 00:26:25
el resultado es 00:26:28
int dividido int 00:26:29
string más int 00:26:31
pero double más string 00:26:35
string también 00:26:39
¿sí? 00:26:42
entonces, la operación 00:26:44
si yo tengo una expresión grande así 00:26:46
me meto allí y puedo calcular 00:26:48
y saber que toda esta expresión 00:26:50
tiene un tipo 00:26:52
en algunos 00:26:53
casos, y esta es una parte 00:27:02
importante 00:27:04
se pueden hacer 00:27:05
conversiones 00:27:07
o sea, hay conversiones 00:27:09
que están 00:27:12
admitidas y conversiones 00:27:14
que no 00:27:16
por ejemplo, nosotros hemos visto algunas 00:27:16
si yo hago 00:27:19
double x es igual a 3 00:27:20
punto y coma 00:27:23
Funciona. Pero ¿3 qué tipo tiene? Int. ¿Y lo puedo guardar en un double? 00:27:24
Sin problema, porque int ocupa cuántos bytes. ¿Y double? 00:27:36
Entonces, en un espacio de memoria de 8 puedo guardar todo lo que se hace en un 00:27:49
espacio de una molécula. Todos los enteros se pueden representar como double. Al revés, 00:27:54
puede hacer int x es igual a 3.5. ¿Por qué no? Porque no todos los doubles, que yo pueda hacer 00:28:02
2 elevado a la 64, 2 a la 64 distintos, double distintos, ¿vale? Pero puede hacer solo 2 a la 32 00:28:15
distintos enteros. Entonces hay double que no podría hacer como entero, ¿entiendes? Entonces no le gusta. 00:28:32
cuando quiero hacer este tipo de 00:28:41
conversiones 00:28:45
hay conversiones 00:28:45
automáticas, o sea implícitas 00:28:48
¿vale? es decir 00:28:51
que si dos tipos 00:28:53
son compatibles 00:28:55
lo intentamos 00:28:56
por ejemplo, imaginaos que yo 00:29:00
tengo float n1 es igual a 00:29:05
3.4, aquí debería poner una f 00:29:07
¿vale? 00:29:09
y esto sería double 00:29:10
double n2, n2 igual a n1. ¿Funciona? Sí, sin ningún problema, porque un float son 00:29:12
cuatro bytes, un double son ocho bytes, son tipos compatibles porque son 00:29:21
numéricos y todos los float se pueden representar como double. Entonces no me 00:29:25
pide nada Java, me dice vale, aceptado. ¿Entiendes? Cuando hace así es una 00:29:31
conversión automática. Como cuando hago double x es igual a 3. Está haciendo una conversión 00:29:40
automática desde entero a double sin pedirme permiso y sin pedirme autorización. Dice no te 00:29:47
preocupes que lo hago yo porque no pierdo precisión. En esta operación, en esta conversión, no vas a 00:29:53
perder ningún dato. El dato que tú me hayas puesto se va a mantener exactamente igual en esta nueva 00:30:01
variable en este nuevo tipo no te preocupes me encargo yo que no pase nada si puedo hacer esto 00:30:09
ni te pido el permiso es una conversión automática una conversión implícita 00:30:15
luego estaba el casting o sea la conversión explícita es decir oye mira yo quiero hacer 00:30:22
una operación y esta operación no es válida yo sé que si tú haces estas operaciones hay 00:30:30
casos en que puede ser que pierdas algo. Aún así, yo, programador, te digo, sí Java, lo sé, no te 00:30:37
preocupes, tú hazlo. Entonces, se lo digo. Por ejemplo, si tengo un double e intento ahora meter 00:30:49
este double en un float, esto no funciona. Porque un double tiene 8 bits, es representado en 8 bits, 00:31:01
y yo estoy intentando decir, oye mira, ponmelo en un espacio de solo 4 bits. Entonces podría ser que 00:31:09
pierda algo de precisión, pierda algunos datos infinitesimales pequeñitos, se pierda. Y yo no 00:31:14
quiero. El Java me dice, no se puede hacer. A menos que yo no le diga explícitamente, 00:31:22
hace un casting explícito 00:31:30
entonces, él sabe 00:31:32
que no debería hacerlo, pero 00:31:34
como el programador está diciendo 00:31:36
explícitamente, tranquilo 00:31:38
yo lo sé 00:31:40
entonces dice, vale, si luego 00:31:42
habrá problemas, porque en verdad 00:31:44
no era 3,4, era 3,4 00:31:46
y al pasarlo a float, has perdido este 1 aquí, el problema es tuyo, porque tú has dicho de hacerlo. 00:31:48
Como por ejemplo, puedo yo convertir un double en un entero. Claramente estoy perdiendo toda la 00:32:03
parte decimal, pero a lo mejor es lo que quiero. Yo quiero la parte entera de un número. Pues lo 00:32:11
Lo converto entero y lo pillo. 00:32:16
Está. 00:32:18
Es en fácil. 00:32:19
Y luego está el tercer tipo de conversiones, 00:32:20
que es, estas no las puedes hacer. 00:32:26
Bajo ningún concepto. 00:32:28
Esto no se hace. 00:32:30
Como por ejemplo, yo tengo el nombre Pepe 00:32:31
e intento hacer Pepe menos n. 00:32:34
String menos 4, ¿qué quiere decir? 00:32:39
No lo sé. 00:32:42
¿Vale? 00:32:44
Debería convertir esto en un número 00:32:45
para poder hacer esta operación. 00:32:47
Y no lo voy a hacer porque no lo sé hacer. 00:32:49
No sé convertir una string a un número. 00:32:51
Por lo tanto, no se puede hacer esta cosa. 00:32:54
Esto es entre tipos incompatibles o entre tipos compatibles, 00:32:59
pero perdiendo precisiones y casting explícito. 00:33:03
Yo tengo un entero, lo intento poner en un byte. 00:33:06
El entero son cuatro bytes. 00:33:09
El byte es un byte solo. 00:33:10
Si no hago casting explícito, me va a decir, no, no puede ser. 00:33:13
Vamos a probarlos. 00:33:17
por ejemplo 00:33:18
por ejemplo 00:33:23
pongo una 00:33:28
int 00:33:30
x es 00:33:31
igual a 00:33:33
doble 00:33:35
x es igual a 00:33:37
esto funciona 00:33:40
si, que tipo de 00:33:41
conversión es 00:33:44
automática o implícita 00:33:45
vale, no 00:33:48
pierdo algo, no 00:33:50
vale 00:33:52
porque todos los enteros se pueden representar 00:33:53
como double, no ha perdido nada 00:33:55
a revés 00:33:57
int x2 00:33:59
es igual a 10 00:34:01
double 00:34:05
int y2 00:34:06
es igual a x2 00:34:12
¿cuántas conversiones hay? 00:34:13
dos conversiones, ¿de qué tipo? 00:34:26
una 00:34:30
¿aquí o no? 00:34:30
conversión. ¿Vale? ¿Que es una conversión de qué tipo? Implícita. 00:34:38
Tengo un int y lo estoy transformando en un double. 00:34:44
Ningún problema. Pero cuando ahora esté double, porque ahora es un double, porque x2 00:34:47
contiene double, no obstante dentro tenga un int, porque al fin y al cabo tiene un int, 00:34:54
pero ahora su tipo es double. 00:34:58
Lo intento poner dentro de un int, no funciona. 00:35:00
vamos a hacer una cosa 00:35:03
que hay 00:35:10
tres 00:35:28
tres 00:35:31
porque lo he hecho 00:35:33
lo he puesto fuera del main 00:35:37
lo he puesto fuera del main 00:35:39
ahí 00:35:42
a ver 00:35:46
vale, entonces 00:35:48
imaginámonos 00:35:50
que yo quiera hacer esto 00:35:52
¿cómo puedo hacer para forzar que lo haga? 00:35:55
¿Qué le pongo aquí? ¿Cómo? ¿Veis que ahora me deja? 00:35:58
Este es un casting explícito. 00:36:07
Estoy diciendo, yo lo sé que no lo podría hacer, pero hazlo. 00:36:12
Y pongamos esto. ¿Qué me escribe? 00:36:17
Bien. A ver. ¿Esto funciona? 00:36:22
que me escribe 00:36:29
veis que en este paso 00:36:31
de aquí he perdido toda la parte 00:36:35
decimal 00:36:37
entiende 00:36:38
aquí con esto 00:36:46
puedo hacer varias 00:36:50
conversiones, nos servirá más adelante 00:36:52
pero para que 00:36:54
sepáis que se puede hacer 00:36:56
operadores, estos los conocemos 00:36:57
más menos por 00:37:01
dividido y módulo 00:37:03
esto ya los hemos visto 00:37:05
¿Sí? Más operadores tenemos los lógicos, los comparación, el ternario condicional, que es el que hemos visto antes, eso de la interrelación en dos puntos, y estas cosas de aquí que probablemente no veremos. 00:37:06
¿Vale? A nivel de bit. Son cosas más avanzadas que se usan relativamente poco en lo que hacemos nosotros. 00:37:21
La lógica booleana es 00:37:28
Estos dos son todos operadores de true y false 00:37:32
¿Vale? 00:37:36
O sea que los lógicos y los de comparación 00:37:37
Me sirven para que haya un resultado de verdadero o falso 00:37:40
Es lo que usaremos luego en la condición 00:37:43
Tanto aquí en el eternario condicional 00:37:46
Como en el condicional verdadero que es el if 00:37:49
Como en el why 00:37:52
¿Vale? 00:37:53
esta parte de aquí será una parte 00:37:54
interesante e importante 00:37:56
porque nos permitirá 00:37:58
establecer condiciones de verdad 00:38:00
si esto es verdadero o falso 00:38:02
si es verdadero hace una cosa, si es falso hace otra cosa 00:38:04
mientras esto sea verdadero 00:38:06
sigue haciendo una cosa, cuando esto se vuelva 00:38:08
falso pues sal 00:38:10
comprueba si este número 00:38:11
es mayor que otro, entonces haz algo 00:38:14
si es menor haz otra cosa 00:38:16
por ejemplo para ordenar números 00:38:18
para saber 00:38:20
si el DNI 00:38:23
que has puesto es el correcto 00:38:25
si la password que has puesto es la correcta 00:38:27
y todo esto 00:38:29
creo que 00:38:29
ya estamos 00:38:33
llegando al final, mañana 00:38:34
vemos estos operadores de aquí 00:38:41
y luego empezamos 00:38:43
a hacer ejercicios 00:38:45
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
4
Fecha:
29 de septiembre de 2026 - 14:18
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
38′ 51″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
107.52 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid