Saltar navegación

20250930 ProgEstr-Operadores_4 - 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 30 de septiembre de 2025 por Raquel G.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues a ver, a pizarra, aquí. Bueno, pues todos los operadores que hemos usado hasta ahora han trabajado con números, ¿vale? Han trabajado con números y su resultado era un número. 00:00:00
Bueno, salvo las concadenas 00:00:19
También hemos utilizado la concatenación 00:00:23
Entre cadenas de texto o stream 00:00:27
E incluso entre una cadena y un numerito 00:00:30
Y hemos dicho que en ese caso 00:00:34
El operador concatenación 00:00:36
Fuerza la conversión de esta cadena de texto 00:00:37
En un numerito 00:00:42
A los caracteres así que lo representa 00:00:42
Y lo concatena 00:00:45
¿Vale? 00:00:46
Y luego el resultado si era una operación con números, larga, corta, como fuera, con millones de operadores, era un número que iba a una variable número y si era una cadena pues iba a una variable cadena, ¿vale? 00:00:47
pero tenemos también 00:01:01
otro tipo de variable 00:01:03
que es la variable boolean 00:01:05
y la variable boolean hemos dicho 00:01:07
que ¿para qué vale? 00:01:09
vale para guardar condiciones 00:01:11
en realidad, para eso vale una variable boolean 00:01:13
para guardar condiciones 00:01:16
o lo que es lo mismo 00:01:18
para guardar cosas 00:01:19
que pueden ser verdad o mentira 00:01:20
o sea, enunciados que pueden ser verdad o mentira 00:01:23
y es importantísimo 00:01:25
que seamos capaces 00:01:28
de almacenar en variables 00:01:29
cosas que puedan ser verdad o mentira 00:01:31
o lo que es lo mismo, condiciones 00:01:34
porque en función de condiciones 00:01:36
nuestro programa 00:01:38
hará una cosa, hará otra 00:01:40
entonces es imprescindible poder guardar 00:01:42
el concepto de condición 00:01:44
en una variable 00:01:46
porque de una condición va a depender 00:01:46
que nuestro programa vaya por una rama 00:01:50
vaya por otra o haga lo que sea 00:01:51
bueno pues para guardar una condición 00:01:53
tenemos las variables boolean 00:01:55
entonces si yo tengo una variable boolean 00:01:57
aquí lo que tiene que ir 00:01:59
es precisamente eso 00:02:02
una condición 00:02:03
luego para construir condiciones 00:02:04
necesitamos operadores 00:02:07
que me permitan construirlas 00:02:09
que son los relacionales 00:02:12
de los que estábamos hablando 00:02:14
entonces los operadores relacionales 00:02:15
que son los que conocemos 00:02:17
menor que, mayor que, menor o igual 00:02:18
mayor o igual 00:02:21
mayor o igual 00:02:22
igual que o distinto de 00:02:32
estos son 00:02:35
los seis operadores 00:02:37
relacionales 00:02:39
menor que, mayor que, menor o igual 00:02:40
mayor o igual, igual a 00:02:43
y distinto de 00:02:45
entonces el igual a 00:02:47
va con doble igual 00:02:50
precisamente para que no lo confundamos 00:02:52
con el operador de asignación 00:02:54
el igual simple es la asignación 00:02:55
que solo vale para esto 00:02:57
yo tengo un valor 00:02:59
y se lo asigno a una variable que está 00:03:00
a la izquierda 00:03:03
este es un operador relacional 00:03:05
¿Qué significa? Es igual a, en pregunta, en condición. 00:03:06
Entonces, ¿cómo usamos operadores relacionales? 00:03:13
Los usamos entre variables numéricas, ¿vale? 00:03:15
Entonces, por ejemplo, n mayor que 3 es una condición, ¿vale? 00:03:21
Porque está construida con un operador de relación y los operadores de relación lo que tienen a los lados son variables numéricas, las que pueden ser comparadas con este criterio de orden menor que, mayor que, igual a, ¿vale? 00:03:35
De nuevo, esto es una de las cosas que os dije al principio del curso, que muchas cosas las voy a apostillar con el con matices, porque luego todo esto tiene matices que no podemos ampliar ahora porque nos falta conocimiento. 00:03:52
Entonces, el con matices es que solamente tienen criterio de orden los números. No hay más cosas que tienen criterio de orden, no solo los números. Los números es el criterio de orden natural. 00:04:07
pero hay más cosas que pueden tener criterio de orden 00:04:18
por ejemplo, los alumnos por orden de altura 00:04:21
las facturas por orden de cantidad 00:04:23
pero serán criterios de orden artificiales 00:04:26
que imponemos desde fuera 00:04:30
y lo podemos hacer con Java porque en nuestras variables 00:04:32
lo normal es que queramos a veces que tengan un criterio de orden 00:04:36
para compararles, pero serán criterios de orden 00:04:39
programados desde fuera, ese es el con matices 00:04:42
Estos operadores, menor que, mayor o igual, estos sirven para comparar variables que tienen su criterio de orden ya por naturaleza, 00:04:46
que no lo tengo que imponer desde fuera. 00:04:55
¿Y esas cuáles son? 00:04:57
Los números y los char. 00:04:59
Son las únicas variables que tienen un criterio de orden suyo por su propia naturaleza, 00:05:01
sin que yo lo tenga que programar desde fuera. 00:05:06
Los números y los char. 00:05:08
Y con esas yo las puedo comparar con el menor que, mayor que, menor o igual, igual a, esto también sería una condición, n doble igual a 7, también sería una condición que puedo asignar a una variable boolean, porque es una condición, n es igual a 7, que luego la condición sea verdad o mentira, eso ya es otro problema. 00:05:10
Pues con estos operadores 00:05:29
Construimos condiciones básicas 00:05:32
Que luego podemos hacerlas más complejas 00:05:34
Con los operadores lógicos 00:05:37
Que vemos a continuación 00:05:39
Pero con estos construimos las básicas 00:05:40
Y he dicho que 00:05:42
Lo que admite orden natural 00:05:44
Y que por tanto se puede comparar con estos 00:05:46
Son los números, pero también los char 00:05:48
Los char también, porque los char 00:05:51
Recordad que están todos colocaditos 00:05:53
En una tabla así 00:05:54
Pegados a un número entero que es el que los representa 00:05:55
por dentro, pues ese es su orden 00:05:59
natural para Java 00:06:01
luego, si lo escribimos aquí 00:06:02
porque se 00:06:05
ve más claro 00:06:06
¿vale? 00:06:08
sí 00:06:11
vale, a ver 00:06:11
ejemplo incrementos 00:06:28
bueno, vamos a dejarlo 00:06:33
ejemplos operadores 00:06:35
a ver 00:06:36
vamos a hacer aquí otra 00:06:39
clase 00:06:43
ejemplo condiciones 00:06:45
bueno, pues por ejemplo 00:06:48
vamos a 00:07:04
hacer condiciones con dos numeritos 00:07:05
cualesquiera que estamos leyendo 00:07:12
por ejemplo, tengo mi 00:07:13
número uno 00:07:26
que lo puedo leer del teclado 00:07:28
y voy a leer también otro 00:07:30
número dos 00:07:36
vale, ahora por ejemplo 00:07:37
yo puedo expresar la condición 00:07:47
el primero 00:07:49
mayor. Le he puesto 00:07:53
un nombre de variable muy 00:08:01
larga, pero es que es un nombre de variable 00:08:03
muy explicativo. En esta condición 00:08:05
yo quiero meter 00:08:07
la condición de que 00:08:08
el número primero que introduje 00:08:11
es mayor que el segundo. 00:08:13
Quiero poner esa condición. 00:08:15
Entonces, 00:08:17
pues ya está. 00:08:18
Esa condición 00:08:22
es fácilmente expresable con 00:08:23
un operador relacional. 00:08:25
y este puede ser el resultado de mi programa 00:08:26
por ejemplo 00:08:31
el primero es mayor 00:08:32
y el resultado 00:08:37
de mi programa será el resultado de esa variable 00:08:39
¿vale? 00:08:41
luego esta es una condición 00:08:52
válida porque compara 00:08:54
con el operador mayor que 00:08:56
dos cosas que tiene orden natural 00:08:57
como los números 00:08:59
también podría comparar dos double, claro 00:09:00
y con esto construyo una condición 00:09:03
la condición 00:09:05
la puedo meter a una variable boolean 00:09:07
porque son para eso 00:09:10
y ahora ya sé que esta variable boolean 00:09:11
va a arrastrar todo el rato 00:09:14
el valor 00:09:15
resultante de la evaluación 00:09:18
de esta condición 00:09:20
¿que esto es true? pues guardará true 00:09:21
¿que esto es false? guardará false 00:09:24
entonces si ejecutamos este programa 00:09:25
vamos a poner el mensajito para que no sea 00:09:30
tan feo 00:09:31
cielo santo 00:09:34
Primer número 00:09:37
Segundo número 00:09:49
Bueno, pues ya tengo un primer programa sencillo 00:09:58
Que pide dos números 00:10:05
Y te dice si el primero es mayor 00:10:06
Ejecuto esto 00:10:09
Primer número, 78 00:10:16
Segundo número, 90 00:10:21
El primero es mayor, falso 00:10:23
vale, evidentemente 00:10:24
el primero no es mayor 00:10:28
lo ejecuto otra vez, primer número 8 00:10:29
segundo número 3 00:10:34
el primero es mayor 00:10:35
true, el primero es mayor 00:10:37
vale 00:10:40
luego gracias a las variables booleanas 00:10:42
pues ya podemos empezar a hacer 00:10:47
programas cuyo resultado 00:10:49
depende del valor de condiciones 00:10:51
de esta manera tan sencilla 00:10:54
sin poner if todavía y sin poner nada 00:10:55
de esta manera tan sencilla 00:10:57
podemos hacer un programa 00:11:00
que en función de una condición 00:11:02
lógicamente me dice true o false 00:11:05
porque recordad que una variable boolean 00:11:06
los únicos dos valores 00:11:09
que puede guardar dentro 00:11:10
los dos únicos son true y false 00:11:11
porque los resultados 00:11:14
de las condiciones solo pueden ser dos 00:11:17
o son true o false 00:11:19
solo pueden ser dos, true o false 00:11:20
¿vale? pues esos operadores 00:11:22
me permiten construir operaciones 00:11:29
¿vale? que yo quiero saber si 00:11:30
dos números que me han dado son iguales 00:11:33
podría cambiar la condición y poner aquí 00:11:34
el doble igual y ahora esta es 00:11:37
otra condición 00:11:39
que me expresa 00:11:40
bueno en lugar de 00:11:42
cambiar esto vamos a hacer que el programa me haga 00:11:44
pues 00:11:47
dos cosas distintas 00:11:48
primero 00:11:51
que me diga si el primero es mayor 00:11:53
y luego que me diga si son 00:11:54
iguales por ejemplo 00:11:57
entonces me hago aquí 00:11:58
una boolean iguales 00:12:03
Y esta variable boolean tendría como condición esto, son iguales y pongo el resultado de ese boolean, vale, pues este programa me dice tanto, si el primer número que he metido es mayor que el segundo que he metido y luego después mediante otra condición distinta, otra variable booleana distinta, me dice si son iguales. 00:12:05
Entonces, si lo ejecutamos, pues el primer número 6, el segundo 9 00:12:42
Ni el primero es mayor, ni los dos son iguales 00:12:53
Si le doy 7 y 7, el primero no es mayor, pero sí que son iguales 00:12:57
Entonces, con los operadores relacionales, aparte de números, de la manera en la que hemos visto 00:13:05
que es la natural de siempre, también se pueden, o sea, los caracteres también tienen orden, 00:13:22
que es lo que hemos dicho ahora hace un ratín. 00:13:32
Los caracteres también tienen orden. 00:13:35
Por ejemplo, esta condición tiene sentido. 00:13:45
A menor que C. 00:13:52
Es decir, puedo comparar char, los caracteres, los char. 00:13:56
Puedo comparar los char 00:14:00
A menor que C 00:14:04
¿Y cuál es el criterio de los char? 00:14:06
El que me diga la tabla ASTI 00:14:09
El que me diga la tabla ASTI 00:14:10
Luego en este caso 00:14:18
A minúscula es el 97 00:14:19
Que es menor que C 00:14:23
Que es el 99 00:14:25
Luego 00:14:26
Si yo ejecuto esto y lo muestro 00:14:29
Pues aquí al final 00:14:33
Voy a encontrar un true 00:14:34
vale, al final me va a salir un true 00:14:38
porque A es menor que C 00:14:41
aquí bueno, pongo lo que sea 00:14:42
este es el true final 00:14:48
del programa 00:14:51
el resultado de comparar A con C 00:14:52
¿qué más tipos de datos 00:14:55
conocemos aparte de char 00:15:02
y de números? 00:15:03
conocemos el tipo string 00:15:06
¿ese lo puedo comparar con 00:15:07
menor que? no 00:15:10
o sea, si yo tengo un string 00:15:11
nombre 1 00:15:13
Igual a 00:15:15
Juan 00:15:20
Vale 00:15:22
Ahora tengo stream nombre 2 00:15:22
Igual a 00:15:26
Luis 00:15:30
Y ahora vamos a intentar hacernos una condición 00:15:31
Que sea 00:15:35
Nombre 1 menor que 00:15:35
Nombre 2 00:15:38
El compilador me dice 00:15:41
Eh ojo 00:15:43
Cuidadin 00:15:44
Que esto que estas comparando con menor que 00:15:45
O mayor que 00:15:48
o no es ni un char ni un número 00:15:49
no me lo compares con menor que 00:15:52
esto no tiene orden 00:15:55
otra cosa es que tú quieras imponer uno desde fuera 00:15:57
como el alfabético 00:16:01
pero ese orden tendríamos que programarlo 00:16:03
ya veremos cómo 00:16:07
y de hecho ya está programado dentro de la clase string 00:16:09
pero como todavía no sabemos objetos 00:16:13
ni qué significa programar un objeto por dentro 00:16:15
pues nos metemos ahora con eso 00:16:17
Pero sí que puedo yo comparar 00:16:19
Si un nombre está alfabéticamente 00:16:21
Antes que otro 00:16:24
Puedo, pero nunca con el menor que 00:16:25
Con el menor que no, tendría que ser llamando a un programa 00:16:27
Que lo haga, que ya está hecho 00:16:29
Dentro de la clase 00:16:31
Pero con el menor que 00:16:35
Números y caracteres 00:16:36
¿Vale? 00:16:39
Lo que sí que podríamos hacer 00:16:43
Aprovechando que ya sabemos jugar un poco más con los objetos 00:16:45
Recordad que nombre 1 00:16:48
es un objeto y dijimos en su momento 00:16:51
que lo tendréis fresco en la memoria porque lo habréis estudiado 00:16:56
y tenéis todo en la memoria fresco lo que hemos contado, porque lo tenéis que tener 00:17:00
todo fresco en la memoria de una clase a otra. Vale, pues dijimos 00:17:04
las variables que son objeto, además 00:17:08
de guardar un valor, pueden a través del operador punto 00:17:12
hacer cosas, ejecutar código que haga cosas. 00:17:16
Pusimos como ejemplo len, y dijimos, esto es un código que me devuelve el número de caracteres de la cadena nombre. 00:17:21
Entonces esto sí tendría sentido, y aquí el compilador ya se calla, porque aquí lo que estoy comparando con el menor que son ahora ya dos numeritos, 00:17:36
Que son las longitudes de las cadenas 00:17:55
¿Vale? 00:18:01
Luego 00:18:03
Esto de antes 00:18:04
Esto no se puede 00:18:14
¿Verdad? 00:18:18
Y de hecho lo voy a dejar en comentarios 00:18:22
Para que podamos seguir 00:18:23
Pero esto otro que hemos dicho 00:18:25
Por ejemplo, esto sí 00:18:27
Esto sí 00:18:32
pero porque aquí estoy comparando 00:18:44
dos cosas 00:18:46
dos números 00:18:48
entonces aquí 00:18:50
esto sería true 00:18:52
si este nombre es más largo que este 00:18:53
para este caso 00:18:56
concreto, esto sería true 00:18:58
porque el tamaño 00:19:00
de esta cadena 00:19:02
es más grande, tiene más caracteres 00:19:03
que la otra 00:19:06
esto sí sería true 00:19:07
entonces 00:19:09
Entonces, como yo he dicho, por tanto, que lo único que se puede comparar, porque admite un orden natural, lo único que se puede comparar con el menor que, mayor que, son los números y los caracteres. 00:19:23
Está claro, ¿no? De hecho, hemos comprobado que si comparamos un string, pues no podemos. 00:19:36
Y si tuviéramos más tipos de datos objeto, veríamos que no podemos. 00:19:41
Los números y los caracteres. Vale. 00:19:47
Pero, ¿qué pasa si yo hago esto? 00:19:49
Y esto que, vamos a escribir ahora esto, voy a hacerme ahora que esta condición sea esto de aquí, nombre1 igual a nombre2, pues aquí lo ha tragado, aquí se lo ha tragado, 00:19:53
recordad que los operadores de relación eran menor que, mayor que 00:20:15
bueno, voy a poner en filita para que se vea mejor 00:20:21
recordad que los operadores relacionales eran menor que, mayor que, menor o igual 00:20:29
mayor o igual, igual y distinto 00:20:33
vale, y hemos dicho 00:20:37
los operadores relacionales solo se pueden usar con números y caracteres 00:20:39
pero sin embargo yo aquí he comparado 00:20:44
con el operador este igual 00:20:47
y si me ha dejado 00:20:49
y si lo hiciera con el distinto 00:20:52
también 00:20:55
uy, con el distinto que es este 00:20:57
también me dejaría 00:21:02
solo con estos dos 00:21:04
si probaréis con cualquiera de estos, no 00:21:07
con cualquiera de estos solo funcionaría 00:21:09
con números y caraceres 00:21:11
¿por qué con estos dos si nos ha dejado? 00:21:13
porque en realidad ser igual a 00:21:15
y ser distinto de 00:21:18
no está asociado a orden 00:21:19
los únicos que están asociados a orden son estos 00:21:21
mayor que, menor que 00:21:24
menor o igual y mayor o igual 00:21:26
son los únicos que están asociados a orden 00:21:28
ser igual y ser distinto 00:21:31
no están asociados a orden 00:21:33
yo puedo tener un montón de alumnos 00:21:34
que no tienen un criterio de orden 00:21:36
ni por altura, ni por peso, ni por nada 00:21:38
un montón de alumnos que tienen criterio de orden 00:21:40
pero si tiene sentido que yo diga 00:21:42
este alumno es igual a este, o este alumno es distinto de este. 00:21:44
Eso sí, ¿vale? Estos dos operadores no están asociados a un orden, 00:21:48
no necesitan un orden para tener sentido. 00:21:54
Luego sí puedo comparar dos cadenas con el doble igual. 00:22:00
¿Esta cadena es igual a otra? Sí me deja. 00:22:06
O esta cadena es distinta 00:22:09
Si me deja 00:22:12
Porque ser igual y ser distinto 00:22:15
No está asociado a un criterio de orden 00:22:16
¿Vale? Esto sí 00:22:19
Vamos a ver que nos saldría 00:22:20
Tengo aquí esta cadena de aquí 00:22:25
La voy a llamar 00:22:39
Las dos las mismas 00:22:43
¿Vale? Las dos las mismas 00:22:48
Esto no lo he podido hacer 00:22:49
Ya lo tenemos claro 00:22:51
Esto sí 00:22:52
Esto va a ser 00:22:54
Iguales en tamaño 00:22:58
A ver que me dice 00:23:00
Iguales en tamaño, porque aquí con esta condición 00:23:01
Estoy comparando sus tamaños 00:23:06
Y ahora paramos un momento 00:23:08
Voy a ver que me dice 00:23:09
Si true o false 00:23:11
Y ahora le voy a decir aquí 00:23:13
Iguales 00:23:16
Cadenas iguales 00:23:22
Esta es la condición 00:23:23
El tamaño de una menor que la otra 00:23:34
Que la muestro aquí 00:23:37
Y esta es la condición 00:23:39
Son iguales 00:23:40
Le he dado estos valores 00:23:43
Vamos a ver 00:23:45
Que me dice 00:23:47
Bueno, esto de antes, me da igual lo que ponga 00:23:48
Siete 00:23:53
¿Iguales en tamaño? 00:23:54
Ah, bueno, perdona, es que no es iguales en tamaño 00:23:58
O sea, es que esto es puesto menor y cuadrado 00:24:00
Esto sería 00:24:02
La mayor 00:24:03
Más larga 00:24:06
Porque la condición que he puesto es 00:24:08
No, más pequeña 00:24:11
La mayor más pequeña 00:24:12
La primera 00:24:19
Pues porque llevo mucho rato hablando 00:24:23
Y ya no sé qué digo 00:24:25
La primera más pequeña 00:24:26
Vale 00:24:28
Pues falso 00:24:29
Porque son iguales 00:24:36
Cadenas iguales 00:24:37
True 00:24:39
Y antes ya de parar de que descansemos 00:24:42
¿Algún repetido no tiene un comentario de hacerme? 00:24:47
Mirad lo que he hecho 00:24:56
He comparado estas cadenas 00:24:57
Y ha funcionado 00:24:59
¿No os angustia? 00:25:02
No debería, no debería. 00:25:06
Vamos a parar y luego lo explicamos, esto último que hemos dicho. 00:25:15
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
4
Fecha:
30 de septiembre de 2025 - 18:51
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
25′ 22″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
485.41 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid