Saltar navegación

2026-01-20 ENUM - 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 22 de enero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

eso, muy bien 00:00:00
así con calma 00:00:02
vale, pues estamos haciendo 00:00:04
este método que quiero 00:00:07
que me lea del teclado algo 00:00:08
y me devuelva 00:00:10
alguno de estos objetos, solo 00:00:12
uno de esos cinco 00:00:14
y así yo invoco luego ese método para 00:00:15
leer mis objetos que pertenezcan 00:00:18
a este tipo de datos 00:00:20
ese es mi objetivo, hacer aquí 00:00:21
algo para que me devuelva uno de esos 00:00:24
cinco, entonces 00:00:26
Pues por ejemplo, podemos hacer, vamos a leer la cadena que él nos diga, que esa no podemos elegir, cadena que él nos dice, pues teclado, si tenéis que hacer un escáner, pues tenéis que hacer un escáner, leer cadena. 00:00:28
Y ahora voy a recorrer todos estos, voy a recorrer todos estos para ver cuál de ellos coincide en nombre con el que acaban de meter, ignorando las mayúsculas y minúsculas. 00:00:47
porque el nombre de estos 00:01:07
que lo hemos visto antes con el get name 00:01:09
es con mayúsculas también 00:01:11
vale pues como puedo recorrer yo esto 00:01:12
como puedo ir yo recorriendo todos estos 00:01:15
para ahora 00:01:17
a ver si alguno de ellos 00:01:19
es igual 00:01:21
en nombre a esta entrada 00:01:23
de aquí saltándome mayúsculas minúsculas 00:01:25
bueno pues 00:01:27
cualquier cosa que sea enum 00:01:29
por ser un enum 00:01:35
hereda de otras 00:01:37
cosas, porque cualquier clase que tiene 00:01:39
la máquina virtual, las que usamos 00:01:41
Scanner, System.out 00:01:43
String 00:01:45
y muchísimas otras más 00:01:47
las millones que usemos, todas 00:01:49
están metidas en realidad en una jerarquía 00:01:51
de clases 00:01:53
¿vale? la máquina virtual 00:01:54
de Java ha diseñado sus clases 00:01:57
todas en una jerarquía para optimizar 00:01:59
el diseño, pues en un 00:02:01
como hereda de otra cosa 00:02:03
tiene cosas aquí, aunque nosotros no las veamos. 00:02:05
Pues, ¿qué cosas tiene? 00:02:08
Tiene un método values, 00:02:09
tiene un método values que me devuelve un array 00:02:11
de todo esto de aquí. 00:02:15
Es decir, este método values me devuelve, ¿vale? 00:02:22
Día, semana, días, ¿veis? 00:02:32
Este método values está aquí, aunque yo no lo vea, 00:02:37
Porque está heredado de la superclase de la que hereda cualquier enum. 00:02:41
Cualquier enum que tú hagas, por el hecho de ser enum, 00:02:45
por el hecho de ser enum, hereda de alguien. 00:02:49
Y eso significa que tiene un método values 00:02:53
que te devuelve un array con todos estos. 00:02:55
¿Veis? Un array de días a la semana. 00:02:58
Vale, pues vamos a recorrerlo. 00:03:01
Para cada día de la semana, 00:03:03
comprendido en todo tu array, 00:03:06
perdón, en todas tus posibilidades, 00:03:09
Vamos a ver si esta posibilidad es la que tú me has metido. 00:03:13
Si dia.main es igual, saltándose mayúsculas y minúsculas, 00:03:21
porque string tiene muchos métodos, podemos ir cotillando los que tiene, 00:03:38
es igual 00:03:41
saltándose mayúsculas y minúsculas 00:03:43
que esto que tú me has escrito 00:03:46
es igual 00:03:48
ya está, ya tengo el día que querías 00:03:49
pues ala, para afuera 00:03:52
retúndio, para afuera 00:03:54
ya está 00:03:56
y así vamos avanzando 00:03:59
¿qué puede ocurrir? para hacer esto más sencillo 00:04:01
no complicarlo, para no meterle en un bucle 00:04:04
hasta que el tío no meta uno así 00:04:06
eso lo podemos hacer luego en el main 00:04:07
si este for termina 00:04:10
y no ha salido por aquí nunca 00:04:12
es porque lo que él metió 00:04:16
no se corresponde en nombre 00:04:19
saltando mayúsculas y minúsculas 00:04:21
a ninguno de los días. 00:04:23
Pues en ese caso que salga por aquí 00:04:25
devolviendo nul. 00:04:26
Luego este método 00:04:28
o te devuelve directamente 00:04:29
una de las cinco posibilidades 00:04:31
o te devuelve nul. 00:04:34
Y ahora nosotros ya en el mail 00:04:37
pues ya gestionamos eso. 00:04:38
pero esto ya es una forma 00:04:39
cómoda de leer 00:04:41
un enum 00:04:43
llamo al método leer teclado 00:04:44
y sé que me va a devolver 00:04:47
o un objeto enum válido 00:04:49
o un null 00:04:51
ahora ya lo usamos desde el main 00:04:53
¿vale? 00:04:57
¿pero no tengo que volver esto siempre 00:05:10
null? no, porque puede 00:05:12
haber salido por aquí 00:05:14
si ha salido por aquí con el return, el método terminó 00:05:15
return hace que el método acabe 00:05:18
con lo cual 00:05:20
lo que haya después 00:05:21
inalcanzable 00:05:23
va a llegar solamente aquí 00:05:24
si nunca jamás este if fue true 00:05:27
que es porque este input pone Pepito Pérez 00:05:30
no pone ni lunes, ni martes, ni miércoles 00:05:34
vale, pues entonces ahora ya 00:05:36
vamos a usar esto en nuestro main 00:05:42
de citas 00:05:44
ahora 00:05:45
queremos leer, estamos aquí 00:05:46
nuestra cita, pues ya está 00:05:51
día de la semana leer teclado, pero podría 00:05:54
ocurrir que esto fuera 00:05:55
nul 00:05:57
entonces vamos a 00:05:58
meter esto en un 00:06:01
en un 00:06:04
while y hasta que no sea diferente 00:06:10
de nul vamos a estar ahí 00:06:12
pues ala, estate ahí atascado 00:06:13
mientras 00:06:22
cita.día 00:06:24
sea igual a nul 00:06:26
ala, ahí te dejo 00:06:28
vale, vamos a 00:06:30
ponerle aquí para ver 00:06:45
tu cita 00:06:47
y ponemos aquí 00:06:52
cita.doctor 00:06:54
cita.día 00:06:58
vale, pues este va a estar aquí 00:07:04
todo el rato 00:07:11
entonces vamos a poner un system out 00:07:12
aquí 00:07:15
para saber que es lo que estamos haciendo 00:07:16
introduzca día 00:07:19
de la cita 00:07:23
vale, introduzca 00:07:24
día de la cita 00:07:27
mientras no ponga un día válido 00:07:28
está ahí emperrado. 00:07:31
Vale, vamos a ejecutar esto. 00:07:33
Introduzca el día de la cita. 00:07:43
Pi, pi, pi. 00:07:44
Nada. 00:07:46
Ahora ya sí. 00:07:48
Tu cita es con este doctor 00:07:50
el martes. Bueno, pues es un 00:07:52
posible uso del enum. 00:07:59
No es que estas cosas se hagan 00:08:02
así. Lo importante es que sepamos 00:08:03
el enum que es 00:08:05
un tipo personalizado nuestro en el cual 00:08:06
damos un 00:08:09
conjunto finito de posibilidades. 00:08:11
porque hay una variable, una propiedad 00:08:13
de una clase que solo admite un conjunto 00:08:16
finito de posibilidades 00:08:18
entonces como eso no lo puedo 00:08:19
recoger, reflejar, ni en un string 00:08:22
ni en un conjunto finito 00:08:24
no lo puedo reflejar, ni en int 00:08:26
ni en nada, pues me hago un 00:08:28
personalizado con mis posibilidades 00:08:30
y esa propiedad 00:08:33
que pertenezca a ese enum 00:08:34
y ahora ya 00:08:35
pues 00:08:37
profundizando más, buscando más 00:08:38
investigando más en el funcionamiento 00:08:42
de enum, pues ya podemos 00:08:44
manejarlo como nos interese 00:08:46
y este es un uso 00:08:47
relativamente 00:08:50
cómodo 00:08:52
¿vale? para leerlo por teclado 00:08:53
y luego 00:08:56
sobre todo el enum, pues le pega muy bien 00:08:58
esto, en función de las posibilidades 00:09:00
pues haces una cosa u otra 00:09:02
¿vale? 00:09:03
enum tiene más métodos, más chorradinas 00:09:15
para hacer cosas, pero 00:09:17
bueno, ¿vuestra curiosidad del enum 00:09:18
se ha satisfecho? 00:09:21
me alegro muchísimo 00:09:23
pues volvemos a nuestro 00:09:25
manejador 00:09:30
entonces, nuestro manejador, que ya nos habíamos 00:09:30
perdido, teníamos un enum 00:09:41
que es tipo figura 00:09:43
triángulo, círculo, cuadrado 00:09:45
vale, pues vamos a ponerle 00:09:48
ese leer teclado 00:09:51
que nos ha gustado 00:09:53
para cuando le pidamos al tipo 00:09:54
Oye, ¿qué figura vas a meter? 00:09:56
Porque en función de eso, instancio con un constructor 00:09:59
O instancio con otro 00:10:01
Pues venga, vamos a copiar 00:10:02
Del otro que hemos hecho 00:10:05
Vamos a copiar el leer teclado 00:10:07
Cambiando los tipos de datos 00:10:12
Claro 00:10:14
Aquí no será día-semana 00:10:14
Sino que será 00:10:23
Tipo figura 00:10:24
Aquí será también 00:10:31
¿Puedes explicar otra vez lo que hace Valius? 00:10:37
Valius te devuelve 00:10:44
un array con todas las posibilidades 00:10:45
del enum 00:10:48
en el que estás llamándolo 00:10:49
o sea, values es un método 00:10:51
o sea, enum hereda de una clase 00:10:52
enumeratio, algo así se llama 00:10:55
no lo sé, no me acuerdo 00:10:57
y esa clase tiene ya métodos hechos 00:10:58
entre ellos tiene un método values 00:11:00
que sirve para devolverte un array 00:11:02
con todos 00:11:05
estos objetos 00:11:06
¿vale? por eso te devuelve un array 00:11:08
de tipo figura 00:11:11
¿y el roce no puede ser donde abajo pone 00:11:12
Bueno 00:11:14
Sí, sí, claro que podrías 00:11:17
Lo he hecho así para que se vea claro lo que devuelve Valius 00:11:21
Claro, podría poner aquí Valius 00:11:23
Lo que pasa es que antes lo he desglosado en líneas 00:11:25
Para que se viera claro 00:11:27
Que devuelve un array de esto 00:11:29
¿Vale? 00:11:31
Pero sí, claro, te puedes ahorrar esa línea 00:11:33
FIX 00:11:35
Le voy a cambiar los nombres para que no quede tan feo 00:11:39
FIX 00:11:41
Vale, ya tenemos nuestro 00:11:43
leer del teclado una figura 00:11:54
que va a estar ahí con el null, mientras el 00:11:56
que nos escribe no nos diga, triángulo, 00:11:58
círculo o cuadrado. 00:12:00
Vale, y aquí hay algo 00:12:03
que 00:12:04
está mal hecho. 00:12:05
Ah, que aquí hay día-semana 00:12:14
y esto es tipo 00:12:16
figura. 00:12:18
Vale, ahora ya sí. 00:12:23
Vale, pues nuestro main raro, 00:12:25
nuestro main de figura geométrica. 00:12:27
Vale. 00:12:29
Crear figura, fin para terminar. 00:12:31
ahora ahora es cuando le vamos a preguntar el tipo de figura entonces hacemos aquí tipo figura 00:12:33
y ahora do y esto sí que se lo ponemos aquí dentro do y ahora tipo figura igual a esto punto leer del 00:12:45
teclado mientras esto sea diferente mientras esto sea igual a no vale pues 00:13:23
vamos a crear figura introduce el tipo y ahora ya sí que tenemos que hacer el 00:13:48
switch en función del tipo que quieras crear o pedimos un lado pedimos tres o 00:13:53
pedimos un radio entonces aquí ahora ya sí que no queda más remedio que hacer 00:13:57
un switch en función 00:14:01
del tipo de figura que tú me has dicho 00:14:03
si es 00:14:06
triángulo 00:14:12
pues si es triángulo, aquí habría que decirle 00:14:16
introduzca 00:14:21
lado del triángulo 00:14:22
vale 00:14:24
vamos a 00:14:29
case círculo 00:14:31
case cuadrado 00:14:46
entonces aquí 00:14:50
para no hacer crecer 00:14:58
los 00:14:59
los case 00:15:01
indefinidamente, aquí deberíais meter un auxiliar 00:15:04
entonces vamos a dejar los huecos 00:15:08
para que lo completéis 00:15:12
la figura que vamos a crear 00:15:13
figura geométrica 00:15:18
figura geométrica 00:15:21
la figura que vamos a crear 00:15:25
inicialmente es null 00:15:26
y ahora aquí se instanciará 00:15:29
pidiendo lo que toque en cada caso 00:15:35
y ahora una vez que esté instanciada 00:15:39
cuando el switch case ha terminado 00:15:41
que estamos aquí 00:15:43
este es el fin del switch 00:15:44
este es el fin del switch 00:15:47
cuando el switch case ha terminado 00:15:51
ahora ya 00:15:52
¿qué hacemos? 00:15:55
pues meterlo 00:15:59
en el array de figuras geométricas 00:16:00
entonces 00:16:02
add figura 00:16:04
al array 00:16:09
figuras 00:16:10
No, porque es un método que vamos a hacer nosotros 00:16:16
Configura, vale 00:16:23
String, lectura 00:16:32
Vale, a ver 00:16:34
Este bucle de aquí 00:16:44
Era para crear el array de figuras 00:16:46
Todo el rato 00:16:48
Es un bucle para crear el array de figuras 00:16:49
Entonces 00:16:51
Aquí lo único que 00:16:53
Claro, como yo he puesto 00:16:56
Que fin sea una posibilidad también 00:16:59
y he metido lo de leer el tipo de figura por aquí 00:17:02
nunca va a ser fin, lectura no se está leyendo 00:17:06
entonces no puede meter fin 00:17:09
entonces crear el array de figuras 00:17:10
tendríamos que cambiar la estructura 00:17:13
para no cambiarlo vamos a hacer que crea un array de 10 figuras 00:17:17
y ya está, así no lo tocamos mucho 00:17:20
quiero que completéis ahora vosotros esto 00:17:22
entonces vamos a cambiarlo así 00:17:24
que nos diga primero el número de figuras que va a hacer 00:17:28
pues que yo había hecho este bucle 00:17:30
para que se haida por lectura igual a 00:17:36
pero entonces lectura también tiene que admitir fin 00:17:38
y yo no estoy admitiendo que sea fin 00:17:40
porque he metido aquí 00:17:42
porque lectura 00:17:43
es una variable local a esto 00:17:46
entonces tendría que pasárselo como parámetro 00:17:48
a tipo figura 00:17:50
que lo puedo hacer 00:17:51
¿vale? 00:17:52
¿pongo un fin dónde? 00:18:00
o sea es que 00:18:04
el valor que se ha leído 00:18:04
se ha leído y se ha quedado aquí encapsulado 00:18:07
no está visible fuera 00:18:09
entonces no puedo acceder al valor leído 00:18:10
no puedo acceder, entonces hombre 00:18:12
puedo cambiarlo de mil formas 00:18:14
pero para no liarla, para no liar 00:18:16
este código y deshacerlo 00:18:18
de, o sea, el método de Lennon 00:18:20
para no tocarlo, ahora que más o menos está bien entendido 00:18:22
voy a hacer 00:18:25
que lo haga 10 veces 00:18:26
y ya está 00:18:28
bueno, más que 10 veces le vamos a 00:18:29
le vamos a preguntar cuántas figuras 00:18:32
quiere crear 00:18:34
que se me ha abierto esto 00:18:35
le vamos a preguntar cuantas figuras quiere 00:18:37
y que el bucle se haga tantas veces como esa 00:18:39
y ya está 00:18:41
cuantas va a crear 00:18:41
y ahora que lo lea desde aquí 00:18:46
teclado punto 00:18:53
leer de entero 00:18:54
y ahora ya 00:18:57
mientras decrementamos num 00:19:00
aquí al final 00:19:04
y mientras num sea diferente 00:19:05
de cero y ya está, es el arreglo 00:19:12
con el que menos código toco 00:19:14
mientras sea mayor o igual que 0 00:19:16
por ejemplo 00:19:22
vale, entonces le pregunto al principio 00:19:23
cuántas va a crear 00:19:28
y me hago un do mientras sea mayor o igual que 0 00:19:29
lo voy decrementando y ya está 00:19:32
así no toco ni el enum, ni el método del enum, ni toco nada 00:19:34
vale 00:19:36
no lo puedo enseñar, pues lo vais a hacer vosotros 00:19:37
está vacío 00:19:44
vale 00:19:45
este es el bucle de nuestro main 00:19:47
para crear este array 00:19:50
luego ya llamaremos a los manejadores 00:19:52
para que hagan lo que sean, ya veremos 00:19:56
este bucle es solo para crear el array de figuras 00:19:58
¿vale? entonces ¿cómo lo estoy 00:20:00
haciendo? pues he forzado 00:20:02
que 00:20:04
solamente pueda meter 00:20:05
uno de tres tipos 00:20:08
y en función del tipo, ahora 00:20:10
tendréis que instanciar la figura geométrica 00:20:12
que toque, luego aquí 00:20:14
hay código por completar 00:20:16
aquí hay código por completar 00:20:17
que es instanciar la figura que toca 00:20:20
en función del enum que ha metido el tío 00:20:22
y ahora ya esa figura que habré instanciado 00:20:25
en alguno de los tres case, en alguno de los tres 00:20:29
esa figura que habré instanciado se lo añado al array de figuras 00:20:32
mediante este método, haz figuras, que tenéis que hacer aquí 00:20:37
recibe este y se lo añade a este array 00:20:41
de figuras, el array de figuras 00:20:45
¿Por qué le tengo que pasar el array de figuras? 00:20:58
Porque es local al método main 00:21:01
Bueno, pues antes de instanciar ya los manejadores 00:21:02
Para no volvernos más locos 00:21:22
Y ya manejar estas figuras 00:21:24
Cuadrados, círculos, lo que sea 00:21:26
Completáis esto vosotros 00:21:28
Y ya mañana 00:21:30
Terminamos este ejemplito 00:21:34
Y ya está 00:21:36
Claro 00:21:37
Claro, en función de lo que haya introducido el tipo 00:22:14
Que es una de estas 00:22:19
tres cosas, sí o sí, no puede ser ninguna 00:22:20
de ellas, no puede ser ninguna diferente 00:22:23
instanciar la que toque, es decir 00:22:24
será, en este caso 00:22:26
pedir los tres lados 00:22:28
e instanciar la figuración 00:22:30
el nombre se puede pedir 00:22:32
como el nombre es común a todos 00:22:34
el nombre se puede pedir antes 00:22:36
del switch case 00:22:37
y luego ya, una vez que tenemos la figura 00:22:39
instanciada, se la 00:22:43
metemos al array 00:22:44
a través de este método 00:22:46
Claro, que son los que tú recogerás aquí 00:22:48
Claro 00:23:01
A ver, el parámetro nombre 00:23:03
Como lo tienen todas 00:23:05
Lo podemos pedir antes del switch case 00:23:07
¿No? Podríamos hacer aquí 00:23:09
Directamente 00:23:12
Hacer una primera instanciación 00:23:12
Bueno, no, porque 00:23:15
la instanciación 00:23:18
hay que hacerla aquí porque es o new cuadrado 00:23:22
o new círculo o new triángulo, claro 00:23:24
lo que podemos es pedir el nombre aquí 00:23:26
vale, para no pedir el nombre en los tres 00:23:28
sitios, porque el nombre 00:23:30
podemos hacer 00:23:32
dime nombre 00:23:33
de figura 00:23:36
porque el nombre se pide para todos 00:23:38
los casos 00:23:40
y dejarlo aquí guardado en un string 00:23:41
string nombre 00:23:44
igual a pues lo que hayan metido 00:23:47
y ahora aquí 00:23:51
pedir lo que toque, en cada caso lo que 00:23:56
falte, que aquí faltarán 00:23:58
tres lados 00:24:00
aquí faltará un radio 00:24:02
y aquí faltará un lado 00:24:03
y ya con eso que hemos añadido 00:24:05
y con este nombre, aquí hacer new 00:24:08
triángulo, aquí hacer new círculo y aquí 00:24:10
hacer new cuadrado 00:24:12
lo que queda feo en esta aplicación es 00:24:13
lo del num lados 00:24:16
es que eso lo voy a pulir directamente 00:24:17
En figura geométrica 00:24:19
Vamos a quitarle esta propiedad 00:24:23
Porque es un poco estúpida 00:24:25
Esta propiedad es absurda 00:24:26
Vale, voy a subir ahora este proyecto 00:24:32
Tal cual está 00:24:38
Y lo indico 00:24:40
Entonces figura geométrica 00:24:46
Los nublados se van fuera 00:24:47
No queremos los nublados 00:24:49
Este nublado es fuera 00:24:51
Y este nublado es fuera 00:24:54
Y en el toString 00:24:56
Los nublados no los queremos 00:24:58
Esto no lo queremos 00:25:00
Vale, he quitado nublados de figura geométrica 00:25:15
Y eso me fuerza a quitarlo de aquí 00:25:25
Y ya está 00:25:31
A quitarlo de aquí 00:25:38
A quitarlo de ahí 00:25:45
Y a quitarlo del toString 00:25:54
Y ya está 00:26:17
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:
1
Fecha:
22 de enero de 2026 - 11:18
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
27′
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
107.67 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid