Saltar navegación

20260120 Herencia_Ejer_ABSTRACT_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 22 de enero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues seguimos. Pues nada, esta clase se nos ha convertido en abstracta. Repito, ¿es grave que sea abstracta? Hombre, vale, ¿es grave que sea abstracta? ¿No se van a poder crear objetos figura geométrica? 00:00:00
pero seguramente mi aplicación 00:00:25
no lo vaya a usar un objeto 00:00:27
figura geométrica, va a usar un triángulo 00:00:29
un cuadrado, entonces si no va a usar 00:00:31
objeto figura geométrica que es lo habitual 00:00:33
que se abstracta, no es grave 00:00:35
es de hecho lo ideal 00:00:37
¿por qué es lo ideal? 00:00:38
porque ahora todos los que hereden 00:00:41
ahora ya tienen 00:00:44
la orden expresa de 00:00:46
oye tú, ¿qué quieres heredar de mí? 00:00:47
muy bien, pero entonces 00:00:50
sobrescribe este método 00:00:52
a tu manera 00:00:53
Por ejemplo, triángulo 00:00:55
Me ha sido un error de compilación 00:00:58
¿Qué me dice el error? 00:00:59
Perdona, pero triángulo debe implementar el método figura geométrica 00:01:01
Debe implementarlo 00:01:05
¿Vale? 00:01:06
A ver, podría haber otra cosa 00:01:12
¿Qué es? 00:01:14
No, no, no, no quiero implementarlo 00:01:15
No, por nada del mundo 00:01:16
No quiero, que estoy ahora mismo 00:01:17
Haciendo otra cosa y no me apetece 00:01:19
Pero necesito quitar el error de compilación 00:01:21
pues que triángulo 00:01:24
se abstracta también 00:01:27
es decir, pero no 00:01:28
no, porque ya tiene 00:01:34
claro, o sea, aquí 00:01:39
me voy a triángulo 00:01:45
triángulo hereda de la clase abstracta 00:01:46
y por tanto hereda un método abstracto 00:01:49
que está obligada a implementar 00:01:51
pero yo no quiero 00:01:53
implementarla en ese momento porque estoy 00:01:55
haciendo pruebas en otro sitio, pero no quiero 00:01:57
el error de compilación. No lo quiero. 00:01:59
A ver, podría hacer esta 00:02:02
abstracta también. ¿Por qué? 00:02:03
Porque entonces se queda con el método 00:02:05
abstracto. 00:02:07
Esta, al heredar de 00:02:09
figura geométrica, hereda su método abstracto 00:02:11
y al no implementarlo, 00:02:13
porque no me ha dado la gana, 00:02:15
al no implementarlo, la he convertido en abstracto. 00:02:17
Pero, hombre, esto no es lo que queremos 00:02:20
hacer ahora nosotros. Porque nosotros sí 00:02:21
que queremos crear objetos triángulos. Esto ha sido 00:02:23
una solución temporal para quitar el error de 00:02:25
compilación, pero hombre 00:02:27
entonces dejaría mi aplicación 00:02:28
incapaz de crear objetos 00:02:31
triángulos, es que no quiero que 00:02:33
se abstracta triángulo, lógicamente 00:02:35
lo que quiero es 00:02:36
implementar el 00:02:39
método perímetro 00:02:41
que esta de aquí ha dejado 00:02:43
vacío, entonces 00:02:45
estamos tirando mucho de atajos del 00:02:47
entorno de desarrollo, demasiado 00:02:51
pero bueno, quiero 00:02:52
creer que tenéis criterio suficiente como 00:02:55
para usar los atajos bien 00:02:57
y si algo lo genera mal 00:02:59
hacerlo mal, entonces, él me ofrece 00:03:00
aquí 00:03:03
me ofrece aquí 00:03:03
hace el método que está sin implementar 00:03:05
venga, pues, me gusta 00:03:09
este atajo del entorno 00:03:11
y aquí me lo ha puesto, ¿dónde me lo ha puesto? 00:03:12
aquí, me lo ha dejado vacío 00:03:15
y ahora yo ya 00:03:17
le hago el bueno 00:03:19
¿vale? ¿veis? es 00:03:20
método sobrescrito 00:03:23
sobrescrito de la clase de arriba 00:03:24
calcula perímetro del triángulo 00:03:26
pues será lado 1 más lado 2 más lado 3 00:03:29
no hay otra 00:03:31
no hay que ponerlo, no es obligatorio 00:03:31
pero es recomendable 00:03:42
¿por qué es recomendable? 00:03:43
por si te equivocas 00:03:46
calculas perímetro 00:03:47
que te coja el 00:03:48
vale, para validar 00:03:51
para nivel de compilación 00:03:53
validar que realmente ese es 00:03:55
el de arriba y no otro nuevo que estoy 00:03:57
haciendo. Si no ponemos 00:03:59
a novel write, no estamos a nivel de 00:04:01
compilación validando. 00:04:03
¿Vale? A este ya le tengo. Triángulo 00:04:05
se quedó estupendo. 00:04:07
Entonces, 00:04:09
realmente el diseño con clases 00:04:10
abstractas y suprima 00:04:13
que suprima es luego 00:04:15
la más usada 00:04:17
y suprima las interfaces 00:04:19
es fundamental 00:04:21
porque te da un patrón de comportamiento. 00:04:22
¿Vale? 00:04:27
Es decir, en figura geométrica, todo lo que yo ponga aquí abstracto, estoy obligando a los que vienen detrás de mí a que lo hagan. 00:04:27
Entonces, oye, tú puedes ser figura geométrica si te da la gana. 00:04:37
Pero si tú quieres ser figura geométrica, perdona, pero dime cómo calculas el perímetro. 00:04:41
Si no, no seas figura geométrica. 00:04:46
Entonces, impones unas plantillas de comportamiento. 00:04:49
¿Vale? Luego tiene todo el sentido como diseño. 00:04:53
Pues cuadrado le pasa lo mismo 00:04:55
Cuadrado al heredar de figura geométrica 00:04:58
Tiene que implementar el método abstracto 00:05:02
Y en este caso será 4 por la A2 00:05:04
Y círculo lo mismo 00:05:10
Tiene que implementar el método de la clase que hereda 00:05:20
Que está sin implementar 00:05:25
Y en este caso este será 00:05:27
2 por pi 00:05:31
que es una variable estática 00:05:35
de la clase math que me da la máquina virtual 00:05:38
2 por pi por el radio 00:05:40
vale, entonces 00:05:44
fijaos que diferencia grande 00:06:11
repito otra vez, entre hacerlo abstracto 00:06:15
y dejarlo vacío y que no sea abstracto 00:06:18
si yo lo dejo vacío y no lo dejo como abstracto 00:06:21
con lo cual aquí quito el abstract 00:06:27
y aquí pongo 00:06:29
pues esto 00:06:33
vale 00:06:35
pues esto también funciona 00:06:36
y ahora triángulo 00:06:39
está sobrescribiendo el calcula 00:06:43
perímetro de arriba, también lo está sobrescribiendo 00:06:45
y ya está y todo está bien 00:06:47
pero esto es peligroso 00:06:49
porque ahora meto octógono 00:06:50
y octógono 00:06:53
no tiene por qué sobrescribir 00:06:55
calcula perímetro, no tiene por qué 00:06:57
porque como este no es abstracto 00:06:59
no obligas a sobreescribirlo 00:07:01
con lo cual octógono se podría estar quedando 00:07:02
con este retuncero que no nos gusta 00:07:05
entonces esto es más peligroso 00:07:07
es mucho mejor 00:07:10
por tanto 00:07:11
dejarlo como lo teníamos 00:07:12
clase abstracta 00:07:15
y método abstracto 00:07:16
para que cualquiera que entre a jugar aquí 00:07:18
como figura geométrica 00:07:21
tenga que implementar esto por huevos 00:07:22
vale pues ahora ya si 00:07:25
mi método 00:07:28
perímetro total 00:07:31
se queda limpio y magnífico 00:07:32
y estupendo 00:07:34
se queda muy limpito 00:07:35
yo recorro todas mis figuras 00:07:38
cada figura llama calcula perímetro 00:07:40
y a qué versión 00:07:43
de calcula perímetro llamará 00:07:44
ya sabemos cómo funciona esto 00:07:46
que en tiempo de ejecución 00:07:48
lo que la máquina virtual busca 00:07:50
es el método 00:07:52
en la versión en la que este 00:07:53
se implementó, no en la que se 00:07:56
declaró. Declarado está como 00:07:58
figura geométrica, ya lo sabemos. 00:08:00
Pero a la hora de ejecutar el método 00:08:03
el que se ejecuta, es tal cual 00:08:04
tú te implementaras, tú te crearas. 00:08:06
¿O no lo has creado? 00:08:09
¿Vale? Y ese es 00:08:12
el polimorfismo del que hemos hablado. 00:08:12
Pues perímetro total aquí 00:08:15
queda tan limpio y tan estupendo. 00:08:16
Gracias a este método calcula perímetro 00:08:18
que está en figura geométrica 00:08:20
abarcándolo todo. 00:08:22
¿Entendido, no? 00:08:28
A ver, ¿qué más tenía que hacer este ejercicio? 00:08:30
Manejador figuras, vale. 00:08:35
Vamos a hacer un manejador cuadrados, que es más específico que manejador figuras, 00:08:38
porque va a manejar solo cuadrados. 00:08:43
Pues venga, vamos a hacer manejador cuadrados, que hereda de manejador figuras. 00:08:47
Pues venga, dos relaciones de herencia, dos jerarquías distintas, 00:08:54
una la de las figuras y otra la de los manejadores. 00:08:58
dos jerarquías distintas 00:09:01
manejador de cuadrados 00:09:03
este es para manejar 00:09:09
cuadrados específicamente 00:09:11
el manejador figuras es para manejar 00:09:12
figuras de diferentes tipos 00:09:14
este es para manejar cuadrados 00:09:16
específicamente 00:09:19
vale, que nos dicen que tiene que tener 00:09:20
añada un método 00:09:23
para calcular el área total 00:09:27
de todos los cuadrados 00:09:29
del array 00:09:31
a ver, esto yo lo veo un poco feo 00:09:32
pero bueno 00:09:35
Cuando instanciamos un manejador cuadrados, él tiene su array de figuras geométricas y que hereda este de aquí, más su método, 00:09:36
pero este además tiene un método para calcular el área de todos los cuadrados. 00:10:01
vale, entonces 00:10:08
este public 00:10:10
novel 00:10:13
área 00:10:18
total 00:10:19
vale, entonces 00:10:23
a ver, un momentito 00:10:27
vale, pues en principio 00:10:35
la idea, lo que yo interpretaría 00:10:38
de esto es 00:10:39
que cuando tu instancia es un manejador 00:10:40
cuadrados 00:10:43
lo que vas a meter en su array de figuras 00:10:44
son cuadrados, lógicamente 00:10:47
vale 00:10:49
entonces, aquí no hace falta 00:10:50
que distingamos por instance of 00:10:53
si todos los objetos del array 00:10:55
son cuadrados o no, les podemos hacer el casting 00:10:57
sin más, a ver, me explico 00:10:59
y ahora vamos a recorrer 00:11:01
su array 00:11:10
for, a ver, manejador figuras 00:11:10
vamos a 00:11:14
manejador figuras y vamos a ponerle 00:11:16
este array 00:11:18
ah, no lo tenía ni private ni nada 00:11:19
vamos a ponerle 00:11:21
no lo habíamos hecho 00:11:23
ni un get ni un set, vamos a ponerle como protected 00:11:27
y un get y un set para el array este, que no se lo habíamos hecho 00:11:31
no habíamos hecho get y set para esa propiedad 00:11:35
vámonos otra vez a manejador de cuadrados y ahora ya 00:11:38
para cada figura geométrica 00:11:52
figura en su array de figuras 00:12:03
¿qué vamos a hacer? podemos 00:12:08
instanciar 00:12:20
vale, podemos llamar figura geométrica 00:12:23
lo mismo con el área 00:12:27
podemos hacer 00:12:30
suma 00:12:32
más 00:12:35
igual 00:12:37
figura 00:12:37
calcula área 00:12:40
claro, pero es que 00:12:46
el manejador cuadrados cuando tú lo instancies 00:12:52
la idea es que 00:12:55
solo tenga cuadrados en su array 00:12:56
porque si no habrías hecho un manejador de figuras 00:12:58
entonces como solamente 00:13:00
va a tomar cuadrados en su array 00:13:02
luego ya vamos a hacer 00:13:04
en el main, vamos a validarlo para que solo tenga 00:13:06
cuadrados, pero es el único sentido que tiene 00:13:08
manejador cuadrados que en su array solo haya cuadrados 00:13:10
es el único sentido que tiene 00:13:12
que exista esta clase 00:13:14
pero no es 00:13:15
el método no sería 00:13:16
que hiciera eso 00:13:18
Claro, el array suyo 00:13:21
Él tiene dentro su array 00:13:27
Que es este 00:13:29
Su array 00:13:29
Manejador, ¿dónde estamos? 00:13:31
Este 00:13:35
No, es que es el suyo propio 00:13:35
Es decir, no es que haya 00:13:44
Un conjunto de figuras 00:13:47
Y manejador 00:13:49
Es que igual te estás confundiendo con dos cosas 00:13:50
no es que en el main 00:13:53
ahora cuando hagamos el main se va a entender mejor 00:13:54
no es que en el main haya un conjunto de figuras 00:13:56
y manejador figuras acceda a todas 00:13:58
manejador cuadrados 00:14:01
solo a los cuadrados 00:14:03
no, o sea, manejador figuras 00:14:04
tiene sus figuras, que serán de cualquier tipo 00:14:06
que luego hay un manejador cuadrados 00:14:08
ese es para manejar solo cuadrados 00:14:11
y tendrá su propio array 00:14:12
pero que en ese array solo habrá cuadrados 00:14:14
¿vale? pues este objeto 00:14:16
manejador cuadrados tiene aquí su array 00:14:19
que es este 00:14:20
Perdón, que es este 00:14:22
Tiene su array 00:14:24
Y en ese array solo va a haber cuadrados 00:14:24
¿Vale? Entonces 00:14:28
Este de aquí 00:14:30
Ahora en el main lo vamos a entender mejor 00:14:33
Vale 00:14:36
Este de aquí 00:14:38
¿Por qué me dice esto? 00:14:39
Ah, jolines, muy bien 00:14:43
Estáis muy despiertos 00:14:45
Manejador 00:14:47
Manejador 00:14:49
Figuras 00:14:51
vale, vale, entonces 00:14:53
podemos 00:15:00
sacar 00:15:03
bueno, vamos a hacerlo como dice aquí 00:15:06
con calcular 00:15:12
área nos pasa lo mismo 00:15:15
si tuviéramos aquí un método 00:15:16
para calcular el área de cualquier figura 00:15:18
estupendo, pues podemos hacer 00:15:20
lo mismo, igual que hemos hecho aquí 00:15:22
un abstracto de calcular 00:15:24
perímetro, vamos a 00:15:26
hacer un abstracto de calcular área 00:15:28
en figura, exactamente igual 00:15:30
vamos a hacernos un abstracto 00:15:32
calcula 00:15:37
área 00:15:42
entonces esta clase abstracta 00:15:43
tiene dos métodos abstractos, puedes tener 00:15:46
uno, dos, mil, con que tenga 00:15:48
al menos uno ya se convierte en abstracta 00:15:50
vale 00:15:52
tiene dos 00:15:54
entonces ahora, triángulo, cuadrado y círculo 00:15:55
otra vez le sale error de compilación 00:15:58
porque una clase 00:16:00
que hereda de una abstracta, tiene que sobreescribirlo 00:16:02
todo, todo, no hay 00:16:04
tutía 00:16:06
pues venga, vámonos una por una 00:16:07
triángulo, vamos a sobreescribir 00:16:10
su método 00:16:13
calcula área 00:16:14
calcula área de triángulo 00:16:15
pues calcula área de triángulo 00:16:21
buf, tenemos que 00:16:24
sacar la base por la altura de los tres lados 00:16:26
pero esto será una fórmula 00:16:28
a través de los lados será fácil de hacer 00:16:29
hay una fórmula que seguro 00:16:31
que echa GPT-SAN 00:16:34
Vale, a ver 00:16:35
Área del 00:16:39
Triángulo 00:16:42
Sabiendo los lados 00:16:44
Venga 00:16:49
Ah, la fórmula de Herón 00:16:51
Esta famosa 00:16:56
Joder, pues sí que es larga la tía 00:16:57
Pero bueno, vamos a hacerla 00:16:59
Calculas el semiperímetro 00:17:00
Y luego la raíz de todo esto 00:17:03
Vale, pues venga 00:17:05
Vamos a pasar esto 00:17:07
Bueno, es que somos tan vagos 00:17:09
A ver si me entiende así 00:17:14
Lado 1, lado 2, lado 3 00:17:16
Variables 00:17:19
Java, dame código 00:17:21
Y no tenemos ni que pasarlo 00:17:22
Vale 00:17:27
Este es el semiperímetro 00:17:36
Y esta es la raíz de lo que faltaba 00:17:38
Ala, ya lo tenemos 00:17:41
Vale 00:17:42
Semiperímetro 00:17:53
La suma de los lados entre 2 00:17:55
Y la fórmula de erón, la raíz de todo esto 00:17:58
Esta es la fórmula de erón 00:18:01
Y ahora ya retun 00:18:04
Le paso esto al retun directamente y listo 00:18:07
Retun, todo esto 00:18:11
¡Hala! Ya tengo el área del triángulo 00:18:15
No hace falta copiarla de aquí porque si la estáis pidiendo echa GPT también 00:18:20
O sea, me refiero, o la estáis copiando de aquí 00:18:26
Bueno, pues 00:18:28
Voy a bajar aquí abajo 00:18:32
Para que se vea mejor 00:18:37
Vale, pues hay que saber 00:18:41
Cuando no hacer el trabajo sucio 00:19:05
Pero claro 00:19:07
El trabajo sucio 00:19:09
Es el que no nos ayuda a aprender 00:19:12
El que nos ayuda a aprender 00:19:14
No es el trabajo sucio 00:19:16
Ese sí que tenemos que hacerlo 00:19:17
En ese proceso estáis vosotros 00:19:18
Bueno, pues venga 00:19:20
Aquí tenemos el área de este de aquí 00:19:22
Ahora, en el cuadrado lo tenemos más fácil, afortunadamente 00:19:28
En el cuadrado, el área del cuadrado es lado por lado 00:19:32
Y el área del círculo también lo tenemos muy fácil 00:19:45
El área del círculo también lo tenemos muy fácil 00:19:51
porque será 00:19:57
por radio 00:20:04
por radio 00:20:09
y ahora ya el manejador 00:20:11
de cuadrados 00:20:21
pues calculará el área total 00:20:21
de todos los cuadrados que tienen 00:20:26
su array 00:20:28
que se supone que son todos los del array 00:20:29
aunque no me gusta a mi mucho 00:20:32
este enunciado como está explicado 00:20:34
a ver 00:20:36
vale, manejador círculo 00:20:36
sería igual 00:20:49
igual, así que el manejador círculo 00:20:49
lo dejamos, vamos a hacer el main 00:20:52
un main probando esto, el main vamos a 00:20:54
tunearlo un poco 00:20:56
manejador figuras 00:20:57
en lugar de decir, vamos a decir cuadrado 00:21:00
pues, vale 00:21:08
bueno, vamos a hacer un main, nosotros 00:21:12
un poco tuneado, para 00:21:14
ejemplificar un poco 00:21:16
todo el ejercicio, pasamos un poco 00:21:18
del main ese de ahí 00:21:20
venga, pues nuestro main 00:21:21
a ver que se me da la 00:21:24
la batería 00:21:39
vale, pues vamos a pasar nosotros de ese main 00:21:41
para hacer algo un poquito así más 00:21:46
más completo, que nos lo 00:21:47
muestre un poquito mejor 00:21:50
venga, pues vamos a crear 00:21:52
un array de figuras geométricas 00:21:54
para luego mandárselas a un manejador 00:21:56
que las maneje 00:21:58
entonces vamos a crear primero un array de figura 00:21:59
geométrica 00:22:02
inicialmente 00:22:13
cero, y ahora vamos a hacer un bucle 00:22:34
En el que esté metiendo figuras 00:22:36
Dándole a elegir entre las tres 00:22:38
Hasta que el tío diga fin 00:22:39
¿Vale? 00:22:41
Vale, pues entonces 00:22:47
Podemos hacer 00:22:48
Figuras cométricas 00:22:50
No debería ser un manejador de figuras 00:23:02
Cuando tenga el array 00:23:04
Porque manejador de figuras 00:23:07
Necesita el array 00:23:09
Para manejarlas 00:23:10
Voy a crear primero el array 00:23:11
¿Vale? 00:23:13
Vale 00:23:15
Voy a llamar a esto lectura, sea diferente de fin, vaya diferente de fin, vale, entonces primero vamos a leer, le decimos crear figura, fin para terminar, 00:23:16
Y ahora le podemos poner aquí, para orientarle, triángulo, cuadrado o círculo. 00:24:31
Ahora, aquí leeríamos, yo voy a meter el teclado ese para no estar con el escáner, 00:24:49
que es un rollo de leer como queráis. 00:25:02
¿El hard lo tienes? 00:25:31
Sí. 00:25:36
Vale, pues si tienes ya el hard 00:25:36
Botón derecho en el proyecto 00:25:39
Buildpad 00:25:41
Configure Buildpad 00:25:41
Ahora una vez aquí 00:25:43
Pinchas Clashpad 00:25:46
Add external hash 00:25:48
Y aquí ya seleccionas el hard 00:25:50
Y ya lo tienes 00:25:53
¿Vale? 00:25:54
Sí, botón derecho 00:25:56
Buildpad 00:25:59
Configure Buildpad 00:26:01
Pinchas en Clashpad 00:26:03
Pues no estamos usando módulos 00:26:06
el módulo de path habría que declararlo 00:26:07
en el módulo de info y es un rollo, class path 00:26:09
add external hash 00:26:11
y ya coges esa clase 00:26:13
y ya está 00:26:16
y cuando ya la has cogido os aparecerá 00:26:18
aquí en references libraries 00:26:22
os aparecerá ya la clase 00:26:24
con el nombre 00:26:26
para que podáis llamarlo 00:26:27
vale, pues entonces 00:26:29
ahora, una vez que ha leído 00:26:42
esto, aquí habría un switch case 00:26:45
y todo eso, pero vamos 00:26:47
a aprovechar que me lo dijisteis 00:26:49
ayer, pues 00:26:51
este sería un caso de 00:26:53
en un posible. 00:26:54
Y es, vamos a ver, 00:26:57
solo hay 00:27:00
tres tipos posibles de figura. 00:27:01
Mi tipo de figura solamente 00:27:03
puede ser o triángulo, o 00:27:05
cuadrado, o círculo. Solo tengo tres tipos 00:27:07
posibles de figura. 00:27:09
Pues, ¿por qué no me creo 00:27:11
un tipo más concreto 00:27:13
que el string? Porque en string cabe cualquier 00:27:15
cosa. Entonces, 00:27:17
¿por qué no me creo un tipo que solo admita 00:27:19
tres posibilidades? 00:27:21
triángulo, cuadrado, círculo 00:27:24
tres ideas ¿vale? 00:27:25
esos son los tipos enumerados 00:27:27
un tipo enumerado 00:27:29
es un tipo que tiene 00:27:31
un conjunto finito de valores 00:27:33
los tipos que hemos visto 00:27:35
hasta ahora, el string, el int, el double 00:27:37
tiene infinito 00:27:40
a ver, infinitos no, porque con int 00:27:41
solamente puedes representar hasta 2 elevado a 00:27:43
31 o más menos, pero 00:27:45
muy grande ¿vale? 00:27:47
Entonces, indouble, float, es una posibilidad enorme de valores, ¿vale? 00:27:49
Pero hay veces que yo tengo una variable que solo se mueve entre tres posibilidades. 00:27:57
Por ejemplo, tengo tres aulas, dam1, dam2 y dam3. 00:28:04
Pues a lo mejor me apetecería crear un tipo de dato que solo tenga tres posibles valores, 00:28:08
dam1, dam2 y dam3, ya está, tres posibles valores. 00:28:13
me apetecería crearlo 00:28:16
y ahora ya poder crear variables 00:28:18
de ese tipo y esas variables voy a tener 00:28:20
la garantía, la seguridad 00:28:22
de que solo van a tener esos 00:28:24
tres posibles valores, solo esos tres 00:28:26
entonces bueno, eso puede 00:28:28
hacer el diseño más bonito 00:28:30
más claro 00:28:31
para el que lo ve, porque si tú ves que algo 00:28:34
es de ese tipo, ya sabes que 00:28:36
solamente va a ser una de esas tres cosas 00:28:38
me obliga luego a seguir 00:28:40
programando en coherencia con eso 00:28:42
bueno, es otra herramienta 00:28:44
más, no es que las cosas 00:28:46
se tengan que hacer de una manera o tengan 00:28:48
que hacer de otra, tal cual 00:28:50
no, nosotros 00:28:52
vemos, estamos viendo 00:28:53
herramientas ahora mismo a nivel muy básico 00:28:55
con ciertas pautas en general 00:28:58
de programación para usarlas 00:29:00
¿vale? de las que vamos dejando caer 00:29:01
pues lo que decimos 00:29:04
nada de métodos largos 00:29:06
métodos cortos que hagan cosas atómicas 00:29:07
si hay código compartido 00:29:10
hacer una estructura jerárquica 00:29:14
Ese tipo de cosas 00:29:15
Bueno, pues entonces 00:29:17
Vamos a aprovechar aquí entonces 00:29:19
Este proyecto 00:29:22
Para meter un poco por encima 00:29:22
Porque tampoco tiene mucha historia 00:29:26
Esto no tiene mucho interés 00:29:28
El concepto de tipos enumerados 00:29:29
Luego esto lo subo al proyecto, al aula virtual 00:29:31
Con los comentarios 00:29:33
Y lo indicamos 00:29:34
Bueno, pues entonces 00:29:36
Yo aquí tengo tres conceptos 00:29:38
Tres ideas 00:29:41
círculo, cuadrado 00:29:42
y triángulo 00:29:44
en esos tres me muevo 00:29:46
y yo voy a pedir por teclado 00:29:47
uno de esos tres conceptos 00:29:50
uno de esos tres 00:29:52
vale, pues entonces me voy a 00:29:53
hacer ese tipo enumerado, me lo voy a 00:29:56
construir 00:29:58
me voy aquí a mi paquete 00:29:59
y ahora aquí me creo 00:30:02
directamente en new os aparece 00:30:06
en un, en el entorno de desarrollo. 00:30:10
En este me da igual Intel IE cualquiera. 00:30:12
Y como veis, el código, aquí le damos un tipo. 00:30:16
Pues, por ejemplo, 00:30:18
tipo figura. 00:30:19
Por ejemplo, 00:30:22
vamos a llamarle. ¿Veis? 00:30:23
Entonces, esto, 00:30:31
el código Java para hacer un enumerado 00:30:33
es como si hiciéramos una clase, 00:30:35
pero aquí en lugar de clase pone 00:30:37
en un. ¿Vale? En lugar de clase 00:30:39
en un. Entonces, 00:30:41
esto no define una clase. 00:30:43
Esto no es una clase, no. Esto es un contenedor de posibilidades, ¿vale? Un contenedor de posibilidades. Es como crear un tipo personalizado para nosotros donde aquí ponemos el abanico de posibilidades. 00:30:45
El tipo personalizado es tipo figura. Y ahora el conjunto de posibilidades se las ponemos aquí. ¿Cómo se suele poner? Pues directamente con el nombre del concepto en mayúscula, separado por coma. 00:31:02
Tengo tres posibilidades, triángulo, círculo y cuadrado. 00:31:17
Y este ya es un enum perfectamente válido, ¿vale? 00:31:29
Estoy diciendo, oye, tipo figura, 00:31:35
las variables que sean de tipo figura, 00:31:39
porque ahora habrá variables string, variables int, 00:31:42
variables double, variables alumno, 00:31:45
variables figura geométrica, 00:31:48
pues también puede haber variables de tipo figura. 00:31:50
y esas variables solo pueden tener 3 valores 00:31:54
triángulo, círculo y cuadrado 00:31:56
¿vale? 00:31:58
entonces, esto no son figuras 00:32:00
es el tipo de figura 00:32:02
entonces 00:32:04
¿cómo podríamos usar esto aquí? 00:32:06
¿vale? pues aquí podría 00:32:11
ahora ese tipo figura ¿cómo se usa? 00:32:12
pues por ejemplo 00:32:15
ahora este tipo 00:32:16
tipo figura 00:32:19
yo lo puedo usar así, tipo figura 00:32:20
punto círculo 00:32:28
entonces esto 00:32:29
tiene dentro la posibilidad 00:32:34
círculo 00:32:36
y a tipo le podría dar la otra posibilidad 00:32:37
no son nada 00:32:41
lo que realmente son 00:33:06
a ver, son 00:33:08
en realidad son objetos 00:33:10
objetos únicos 00:33:11
es decir 00:33:14
esto es que no es tan fácil de entender 00:33:16
en realidad, la idea general sí 00:33:18
pero como está construido 00:33:20
por dentro no 00:33:22
volviendo atrás un momento 00:33:22
vale, esto es una variable 00:33:24
normal y corriente, mi variable tipo 00:33:26
como la podría llamar variable o la podría llamar como me diga 00:33:29
la gana, es una variable, pero esta variable 00:33:31
tiene la peculiaridad 00:33:33
por ser de este tipo 00:33:34
tiene la peculiaridad de tener solo 00:33:36
tres valores posibles y ya está 00:33:39
y sus tres valores posibles 00:33:41
son este, este y este 00:33:43
ya está, eso es lo básico 00:33:44
del numerado, crear variables 00:33:47
la voy a cambiar de nombre 00:33:49
por si lo de 00:33:51
bar 00:33:52
lo de tipo nos lía 00:33:53
o variable cualquiera, esta 00:33:56
vale, entonces esto se ve mejor 00:33:58
esto es muy típico, el ejemplo típico que se 00:34:10
dice siempre, en el que se entiende mejor 00:34:12
vamos a, por ejemplo 00:34:13
mi aplicación trabaja con una idea 00:34:15
que son días de la semana 00:34:18
vale 00:34:19
vamos a 00:34:21
sacarlo de este proyecto, vamos a ponerlo 00:34:23
aquí, en otro paquete, ejemplo 00:34:26
enum, para verlo más claro, no, y luego ya 00:34:27
venimos a este para hacerlo para este, para no, me voy a hacer aquí 00:34:29
otro paquete en este proyecto que subo 00:34:33
ejemplo enum, vale 00:34:38
pues en ejemplo enum, voy a cerrar 00:34:41
todo esto para no liarlo y esto por ahora lo voy a quitar 00:34:50
de aquí, vale 00:34:54
venga, ejemplo enum, lo típico, pues 00:35:00
Tú tienes una aplicación, por ejemplo, en la que estás haciendo, tienes una clase que es una cita que recoge una cita médica. 00:35:07
Por ejemplo, recoge una cita médica en una aplicación de citas médicas. 00:35:19
Tienes aquí tu string que recoge el doctor con el que está la cita médica. 00:35:25
y tienes aquí otra propiedad de mi cita médica 00:35:30
que es el día de la semana en la que la tengo, 00:35:35
la cita médica, ¿vale? 00:35:39
Ahora mismo me olvido de Getset porque, bueno, 00:35:41
todo menos ahora. 00:35:43
Vale, entonces yo podría dejar así esta clase y muy bien. 00:35:45
Pero, claro, se podría convertir en una especie 00:35:49
de sumidero de errores porque aquí admite 00:35:52
que yo en el día ponga praplaplum. 00:35:55
entonces cuando yo luego consulto 00:35:58
en mi aplicación 00:36:00
a ver que día tengo la cita con este doctor 00:36:02
me sale día plaplaplum 00:36:05
pues hombre, se me ha colado el error 00:36:07
pero cuando yo quería poner miércoles cuando la ingresé 00:36:08
se me fue el dedo y puse 00:36:11
plaplaplum, entonces eso ahora yo voy a 00:36:12
consultar y no lo entiendo 00:36:14
¿por qué? porque claro 00:36:16
día es un string 00:36:18
pero en string cabe cualquier cosa 00:36:20
entonces yo lo podría dejar así 00:36:22
pero luego cuando yo 00:36:24
en la parte de la aplicación de ingresar 00:36:26
la cita, meta el día, 00:36:28
tengo que ser muy cuidadoso de validar 00:36:30
con un bucle que realmente meta un día 00:36:32
válido, en fin. 00:36:34
Bueno, pues, ejemplo típico 00:36:37
que se usa para Enum. 00:36:38
Vamos a ver. Esto solo 00:36:40
tiene siete posibilidades. 00:36:42
De lunes a domingo, solo tiene 00:36:45
siete. Pues en lugar de 00:36:46
que día pertenezca al tipo string, 00:36:48
que día pertenezca a un tipo 00:36:51
personalizado mío que me voy a hacer, 00:36:52
que solo tenga siete posibilidades. 00:36:54
Y ya está. 00:36:57
Y así no hay margen de error. 00:36:58
Este día, una vez que ha llegado aquí y se ha inyectado, 00:37:00
ese día solamente puede ser uno de los cuatro, de los siete. 00:37:03
Pues entonces me tengo que hacer ese tipo personalizado. 00:37:08
Pues venga, ese tipo personalizado será un enum. 00:37:13
Por ejemplo, día-semana. 00:37:19
Día-semana. 00:37:24
Aquí tengo mi enum. 00:37:25
¿Cuáles son las siete posibilidades? 00:37:28
las 7, vamos a poner 5 00:37:30
para no escribir tanto 00:37:32
y porque no trabajan en fin de semana 00:37:34
no, no, no 00:37:37
no hace falta poner punto y coma 00:37:46
lo puedes poner, pero no es necesario 00:37:50
vale 00:37:52
es necesario si luego le añades más cosas abajo 00:37:53
pero ahora mismo todavía no se las hemos añadido 00:37:56
vale, este es el enum normal y corriente, básico 00:37:57
ahora, este es un tipo personalizado 00:38:00
entonces yo ahora 00:38:03
a cita 00:38:04
le cambio y digo, oye cita no es 00:38:05
string 00:38:08
cita es día 00:38:09
semana, mucho 00:38:11
mejor diseñada así la aplicación 00:38:14
porque ahora 00:38:16
a día solamente se le 00:38:18
puede asignar uno de esos cinco valores 00:38:20
ya está, no se le puede asignar nada más 00:38:22
entonces 00:38:24
bueno, tiene más sentido la aplicación 00:38:26
entonces vamos a poner aquí 00:38:28
el main 00:38:30
vale, pues entonces me voy a hacer yo 00:38:32
una cita 00:38:52
cualquiera 00:38:53
estoy pasando de get y set y todo 00:38:56
porque ahora mismo me da igual 00:38:59
vale, pues a cita.doctor 00:39:01
le puedo dar 00:39:06
lo que me dé la gana 00:39:08
es un string, le puedo dar lo que quiera 00:39:09
pero a cita.día 00:39:12
no le puedo dar 00:39:17
lo que a mí me dé la gana 00:39:20
le puedo dar solo uno de esas cinco posibilidades 00:39:21
y a esas cinco posibilidades 00:39:24
¿cómo se accede? 00:39:26
se accede así 00:39:27
día, semana, punto 00:39:28
la que sea 00:39:31
o sea, es imposible darle a 00:39:32
cita día algo que no sea una de esas 00:39:38
cinco, entonces tiene 00:39:40
mucho más sentido 00:39:42
vale, ahora tú preguntabas 00:39:43
pero esto físicamente que es 00:39:48
físicamente en realidad 00:39:50
no es un stream 00:39:52
esto físicamente es un objeto 00:39:53
pues que tiene recogido 00:39:56
ese yo soy el objeto lunes 00:39:58
físicamente 00:40:00
es un objeto, sin más. 00:40:02
Entonces, como es un objeto, 00:40:05
tiene métodos también. 00:40:06
¿Veis? Cita.día 00:40:21
que tiene este valor. 00:40:23
Si veis los métodos que 00:40:25
tiene, tiene un 00:40:27
método. Por ejemplo, el name 00:40:29
que me saca 00:40:31
vamos a mostrar 00:40:33
lo que me saca. Me saca 00:40:36
en string lo que yo 00:40:57
he escrito ahí. 00:40:59
Tiene un método 00:41:10
ordinal 00:41:12
que me saca 00:41:14
el orden en el cual 00:41:16
está situado 00:41:18
eso dentro del enum, que bueno 00:41:20
puede tener interés, depende de la aplicación 00:41:22
o puede no tenerlo 00:41:24
el lunes 00:41:25
está en la posición 0 00:41:28
pero si yo le dijera el martes 00:41:30
me va a sacar que está en la posición 1 00:41:32
¿vale? 00:41:34
bueno, ¿con qué 00:41:42
se conjuga esto muy bien? 00:41:43
Esto se conjuga muy bien con el switch case 00:41:44
Porque ahora yo ya puedo hacer un switch case 00:41:47
De esta manera 00:41:50
Switch cita día 00:41:52
Y ahora hago aquí 00:41:58
Case lunes 00:42:04
Bla, bla, bla 00:42:10
¿Vale? Vamos a ponerlo así 00:42:12
Case martes 00:42:15
Bla, bla, bla 00:42:23
¿Vale? 00:42:26
Espera, voy a ponerlo con los dos puntos 00:42:29
para que me quite el error de compilación 00:42:30
pero no voy a poner código ahora 00:42:32
vale, entonces 00:42:34
conjuga muy bien con esto 00:42:49
eso es lo que ya sé que te inquieta 00:42:51
vale, pues esto es para lo típico 00:43:08
para lo que se usa un enum 00:43:16
vale, si tú sabes 00:43:18
que una variable va a tener solamente 00:43:20
un conjunto finito de valores 00:43:22
te haces un enum con esos 00:43:24
y ya solamente puedes hacer 00:43:26
hacer asignaciones de una de esas cinco 00:43:28
posibilidades. 00:43:30
Y luego eso encaja clavado 00:43:32
con el suitcase. 00:43:34
¿Vale? Encaja y clavado en función 00:43:36
de que sean estos los patatines. Hasta ahí 00:43:38
vale. Entonces, clara, 00:43:40
claro. Ahora la 00:43:42
pregunta es, y si yo tengo, 00:43:44
aquí lo he asignado directamente, le he dicho 00:43:46
martes. Pero si yo lo tengo 00:43:48
que meter por teclado, porque yo por teclado 00:43:50
solo meto un string. Esto no 00:43:52
es un string, esto no es el string 00:43:54
martes, no. Esto es 00:43:56
un objeto 00:43:58
sin más, uno de estos cinco objetos de aquí 00:43:59
aquí hay cinco objetos 00:44:03
que son los cinco posibles valores 00:44:06
son los cinco posibles valores 00:44:08
y uno de esos cinco es el que yo he metido aquí 00:44:10
entonces para meterlo por teclado 00:44:15
pues solamente puedo leer un string 00:44:18
entonces tengo la forma cutre 00:44:20
entre comillas, pero que siempre puedo recurrir a ella 00:44:24
que es leerlo, hacer un switch case 00:44:27
en función del string que sea, asignarle el valor 00:44:30
y en el caso de que no sea uno de ellos 00:44:33
estarle metiendo en un while y ya está 00:44:36
esa sería la forma de hacerlo 00:44:39
lo que pasa es que para que eso no embarre mucho el main 00:44:41
se puede hacer 00:44:45
incluso aquí porque el enum 00:44:48
admite que tú metas métodos a los que luego puedes 00:44:51
llamar, lo que pasa es que bueno, esto ya nos complica 00:44:54
mucho las cosas, por ejemplo, vamos a hacer un 00:44:58
método que me devuelva 00:45:02
un día de la semana 00:45:12
leer de teclado 00:45:13
vale, entonces le voy a dejar aquí el null para quitarlo de compilación, paramos un segundito 00:45:19
para que lo maduréis y descanséis, ya lo vemos 00:45:27
vale, entonces yo puedo meter aquí 00:45:30
toda esa complejidad de leer 00:45:33
por teclado el string 00:45:35
compararlo a ver si es uno de los 00:45:37
válidos, si no patatín 00:45:39
patatán y cuando ya 00:45:41
pues lo haya hecho bien devolverlo 00:45:43
entonces lo puedo hacer así 00:45:45
y entonces ahora yo ya de aquí 00:45:46
podría llamar directamente 00:45:48
a díasemana 00:45:50
punto 00:45:52
leer teclado 00:45:54
y ya está 00:45:57
¿Vale? Sería lo más limpio 00:45:59
¿Vale? 00:46:02
Y ahora metemos aquí 00:46:04
El código que falta, ¿vale? Vamos a parar un momentito 00:46:06
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:16
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
46′ 13″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
188.71 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid