Saltar navegación

20250304 EjercicioExcepciones - 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 8 de marzo de 2025 por Raquel G.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, ya está. Estamos grabando. 00:00:00
Uy, perdona, pero... 00:00:02
Vale, bueno, pues entonces, 00:00:04
un vistazo muy por encima de las clases de este ejercicio. 00:00:07
Me liaba aquí a... 00:00:15
Me quedaba sola aquí dando... 00:00:16
Vale, pues a ver. 00:00:22
Pues hicisteis una clase alumno. 00:00:25
Esta es una versión un poquito más tuneada, 00:00:27
Pero bueno, es ver por encima la idea de excepciones que vimos el otro día. 00:00:29
Vale, pues habéis hecho esencialmente un método crear alumno, al cual se le pasan los datos del alumno y lo crea y lo devuelve con ahorro de retorno. 00:00:34
Luego, primera cosa, este método crear alumno, que se le pasan los datos de un objeto alumno, lo instancia y lo devuelve, 00:00:44
por definición es un método estático 00:00:54
porque no depende de propiedades 00:00:57
de ningún objeto en concreto 00:00:59
de hecho sirve para crear uno nuevo 00:01:00
¿no? con lo cual 00:01:02
uno le pone estático 00:01:05
y luego pues desde su main 00:01:06
¿cómo crea uno a un alumno? 00:01:08
pues desde su main crea uno 00:01:11
a un alumno directamente con el nombre 00:01:12
de la clase crear alumno 00:01:15
los datos y lo crea 00:01:16
luego 00:01:18
esto en realidad este crear alumno 00:01:19
es igual que un constructor 00:01:23
es lo mismo, hace lo mismo que un constructor 00:01:25
lo que pasa es que lo hace específicamente 00:01:28
es lo mismo 00:01:29
entonces, ¿qué sentido tiene? 00:01:31
pues a lo mejor aquí ahora mismo 00:01:33
poquito, aunque alguno tenga 00:01:35
por el tema de la excepción de ahora 00:01:37
poquito, pero es una forma 00:01:39
de diseñar clases muy habitual 00:01:42
entonces 00:01:44
a veces lo que se hace es 00:01:45
por lo que se opta es 00:01:47
el constructor 00:01:48
yo lo hago privado 00:01:50
¿Veis? Yo aquí en mi clase alumno 00:01:53
al constructor lo he hecho 00:01:55
privado 00:01:57
Claro, y si lo he hecho privado 00:01:58
significa que no dejo a nadie 00:02:01
que instancie objetos por su cuenta 00:02:02
Nadie va a poder hacer un new, nadie 00:02:05
porque está privado, nadie 00:02:07
Entonces, ¿cómo se van a crear 00:02:08
los objetos alumno? 00:02:11
Hola, pues los objetos alumno 00:02:14
se van a crear 00:02:17
porque yo ofrezco un método alternativo 00:02:19
como este 00:02:21
Y en este método alternativo, además de instanciar el propio objeto con new, puedo hacer más cosas, como verificar que se cumplen ciertas condiciones, etc. 00:02:21
Entonces, de nuevo otra idea más, pues que nos va apareciendo de diseño sobre la marcha, según vamos haciendo ejercicios. 00:02:35
Aunque este módulo sea específicamente de aprender las técnicas básicas de programación, es bueno que nos vayan quedando poquito a poco nociones de diseño. 00:02:43
Pues bueno, esta es una muy habitual. Yo prohíbo el constructor. Al prohibirlo con el privado, automáticamente nadie va a poder instanciar. 00:02:54
Entonces, ¿qué hace la gente cuando tenga que crear alumnos? Lo hará a través del método que yo ofrezco. 00:03:05
y este método ya dentro hace comprobaciones 00:03:10
cosas que yo quiero que pasen 00:03:14
luego es una forma de dirigir 00:03:15
la creación de objetos 00:03:18
dirijo la creación de objetos 00:03:19
ofreciendo un método que hace comprobaciones 00:03:22
hace cosas y él 00:03:24
es el único que tiene permiso de llamar 00:03:25
al constructor, el único 00:03:28
¿vale? 00:03:29
bueno pues en este caso 00:03:31
¿por qué lo hemos planteado así este ejercicio? 00:03:33
lo hemos planteado así 00:03:36
porque a la aplicación 00:03:37
le interesa que solo se puedan 00:03:40
crear alumnos, solo 00:03:42
si el año no es negativo. 00:03:43
Entonces, 00:03:47
prohibimos el constructor 00:03:48
nos hacemos un método que verifique 00:03:51
si el año es negativo. 00:03:54
Si lo es, ni instancia 00:03:56
nada, ni hace nada. 00:03:58
Lanza la excepción. 00:04:00
Y si no lo es, ya devuelve el alumno. 00:04:02
¿Vale? Luego es una forma alternativa 00:04:05
de crear el objeto alumno 00:04:06
a través de un método estático. 00:04:07
¿Vale? 00:04:10
Y así no ensuciamos el constructor 00:04:12
aquí haciendo que sea el constructor 00:04:14
el que lance una excepción, que eso es feo. 00:04:16
A los constructores, cuando a menos 00:04:18
mierda se les meta mejor. 00:04:20
Los constructores están exclusivamente para 00:04:22
dados los valores de unas propiedades 00:04:24
crear un objeto. 00:04:26
Y no les metemos ahí morraya y nada. 00:04:28
Si necesitamos meter morraya 00:04:31
para hacer comprobaciones, 00:04:32
para poner mensajitos de si ha creado un objeto, 00:04:34
para verificar si el usuario 00:04:36
que está llamando al constructor 00:04:38
tiene permisos o no 00:04:40
si necesitamos meter todo ese tipo de comprobaciones 00:04:41
o cosas en el constructor para crear un objeto 00:04:44
prohibimos el constructor 00:04:46
y hacemos un método 00:04:48
adicional, que haga las comprobaciones que sean 00:04:50
verifique lo que sea y sea 00:04:52
él el que ya una vez 00:04:54
verificado que todo está correcto 00:04:56
llame al constructor 00:04:58
y devuelva el objeto 00:04:59
es una forma de diseño habitual 00:05:01
bueno pues en este caso lo hemos usado 00:05:03
para esto, simplemente para que en lugar de que 00:05:06
sea el constructor el que lance el throws 00:05:08
excepción, que es muy feo, pues 00:05:10
le lancé crear alumno. Y ya está. Si el año 00:05:12
es negativo, aquí el programa se para. 00:05:14
Lanzo la excepción y 00:05:17
listo. Y si no, el programa 00:05:18
no se para, sino que me hace el retun, 00:05:20
el método, perdón, no el programa, el método, 00:05:22
me hace el retun y ya está. 00:05:24
Y esto es lo que haríais en ese ejercicio, hacer 00:05:26
un crear alumno que haga esto. 00:05:28
Y luego ya 00:05:30
el main, pues 00:05:31
claro, llama al objeto, por ejemplo, aquí vamos 00:05:34
a crear un array de cuatro alumnos. 00:05:36
Pues en cada posición creamos un alumno y aquí efectivamente, si vamos a crear alumno, hay que pasar de todas las propiedades de crear alumno, que crear alumno yo tengo puesto porque, bueno, le añadí este de asignaturas y todo, año y curso, pues ya está en crear alumno. 00:05:38
como le añadí un curso 00:06:01
pues bueno, vamos a suponer 00:06:04
que ala, curso 00:06:06
primero, lo que sea 00:06:08
para que no me dé 00:06:09
y ahora 00:06:11
como crear alumno puede que lance 00:06:16
excepción, pues ya sabemos que entonces tenemos que 00:06:17
meterlo en un try-catch 00:06:19
para decir que hacemos en el caso de que 00:06:21
no podamos crear el alumno 00:06:24
en este caso, ¿por qué optamos? 00:06:25
por decrementar 00:06:29
la variable i 00:06:30
para que el for insista en la i una y otra vez. 00:06:32
¿Vale? 00:06:36
¿Veis? O sea, este main, que es el que rellena a los alumnos, 00:06:38
este main va a rellenar a mis cuatro alumnos. 00:06:42
Intenta crear el alumno, que puede crearlo fenomenal. 00:06:46
Ya está, pasa al siguiente i. 00:06:49
Que no puede crearlo, como se habrá lanzado la excepción, 00:06:51
sale el catch, me avisa y decrementa el i otra vez. 00:06:54
y lo decrementa y así se está todo el rato 00:06:58
intentando crear ese alumni 00:07:01
que puedo crearlo, genial, paso al siguiente 00:07:02
que no puedo crearlo 00:07:05
dejo la i 00:07:06
decrementada para volver 00:07:08
a insistir en este, volver a insistir 00:07:10
y este for se va a estar parado 00:07:12
en la misma i se va a estar parado 00:07:14
hasta que por fin esto no dé excepción 00:07:16
luego sería una forma 00:07:18
de rellenar este array 00:07:20
y esto sería mucho mejor solución que la 00:07:21
solución de 00:07:26
que si en lugar de excepción 00:07:26
¿por qué otra solución podría ser? 00:07:29
la que tengo aquí comentada 00:07:31
si el año es negativo, no me crees el alumno 00:07:32
return null y se acabó 00:07:35
vale 00:07:36
pero que feo 00:07:38
porque si yo en lugar de lanzar excepción 00:07:40
return null si el año es negativo y se acabó 00:07:42
pues entonces aquí 00:07:44
alumnos de i estará metiendo 00:07:46
alumnos nulos 00:07:48
y yo 00:07:49
como programador de mi programa main 00:07:51
pues no me estaré enterando 00:07:54
de que esto puede ser que no esté funcionando 00:07:56
no me estaré enterando porque no me está avisando 00:07:58
cuidado que pueda lanzar excepción, podré estar 00:08:00
metiendo ahí nulos 00:08:02
entonces pues bueno, esto es mucho mejor 00:08:03
hago que el método en lugar de 00:08:06
devolver nulos, si no puede, me lance una excepción 00:08:08
con lo cual 00:08:10
al lanzarme una excepción 00:08:12
si yo no meto el try catch 00:08:13
si yo no meto, me va a decir 00:08:16
si este try catch 00:08:19
yo no lo pongo 00:08:20
hola, si yo no lo pongo 00:08:21
donde está alumno excepción 00:08:34
aquí 00:08:35
vale, si yo no lo pongo 00:08:39
el try catch 00:08:48
automáticamente aquí 00:08:49
me llega el aviso de cuidado que el método 00:08:52
crear alumno, cuidado, puede que te lance 00:08:54
una excepción, genial, me facilita 00:08:56
la tarea, no tengo yo aquí que 00:08:58
buscar en la documentación a ver si puede que 00:09:00
esto me dé nulo, si no me dé nulo, no 00:09:02
es que directamente ya me está diciendo, cuidado que puede 00:09:04
dar una excepción de año negativo 00:09:06
pues ya está, ah vale, pues genial 00:09:07
la capturo 00:09:10
la capturo 00:09:11
y en el caso de que se lance 00:09:16
la excepción, alumnos de i 00:09:19
se habrá quedado sin inicializar 00:09:21
me avisa 00:09:23
y decrementa i para que en la siguiente 00:09:24
iteración volver a insistir otra vez 00:09:27
y volver a insistir y volver a insistir 00:09:29
y así 00:09:30
pues esta es la idea de este ejercicio 00:09:31
ver las diferentes formas de comunicarse 00:09:35
entre mi entidad alumno y el programa principal 00:09:37
en el caso de que ocurra 00:09:39
algo que yo he identificado que no quiero 00:09:41
que pase, que es un año negativo. 00:09:43
Luego uno hace su aplicación, 00:09:47
identifica 00:09:49
qué cosas no quiero que pasen. 00:09:50
Pues no quiero que pase 00:09:53
que el login tenga más 00:09:54
de 10 caracteres. 00:09:57
No quiero que pase 00:09:59
que haya un email 00:10:01
sin un arroba. No quiero que pase 00:10:03
no sé qué. Pues me hago excepciones 00:10:04
para esos casos. 00:10:07
Y luego en los métodos donde yo verifico 00:10:08
eso, si eso pasa 00:10:11
que no quiero que pase, hago el throw 00:10:13
y ahora ya el que usa esas clases tiene los avisos 00:10:14
cuidado que aquí te puede pasar esto 00:10:17
ah vale, pues si me pasa hago esto 00:10:18
cuidado que aquí te puede pasar esto, ah pues si me pasa hago esto 00:10:20
es mejor forma de programar 00:10:22
construyendo 00:10:25
esas propias excepciones nuestras 00:10:27
bueno, de todo el rollo 00:10:29
este de excepciones 00:10:34
alguna duda, problema, etc 00:10:35
bueno, esto era 00:10:38
y llamar al alumno con los parámetros 00:10:43
que necesitaba. 00:10:45
Pero vamos, este proyecto 00:10:48
lo subiré también. Dime. 00:10:49
¿El print stack trace que hacía? 00:10:51
El print stack trace 00:10:54
demuestra toda la traza 00:10:55
que le ha hecho llegar a ese error. 00:10:57
Todas las líneas de código que le han hecho llegar a ese error. 00:10:59
Recuerda 00:11:07
que si no hay un try-catch, 00:11:07
es decir, tú decides 00:11:09
no tratarla. Si no pones el 00:11:11
throws arriba sin más, entonces 00:11:13
si aquí ocurriera una excepción, 00:11:15
La máquina virtual llama a ella sin que tú lo veas 00:11:17
al print extract trace y luego para el programa. 00:11:20
Por eso cuando salta una excepción 00:11:23
vemos también las líneas rojas. 00:11:25
Porque la máquina virtual antes de parar el programa 00:11:27
ha llamado a esto, aunque no lo veamos. 00:11:29
Pero si tú haces un try-catch, 00:11:32
entonces ya el que has tomado el control eres tú. 00:11:34
Entonces si la excepción se lanza, 00:11:36
se hace lo que hay aquí. 00:11:38
Si no hay print extract trace, 00:11:40
no vas a ver líneas rojas. 00:11:41
Porque esas líneas rojas se muestran 00:11:43
cuando hay un print extract trace. 00:11:44
como son de mucha ayuda 00:11:46
para saber que ha pasado 00:11:50
cuando estás desarrollando las ponemos siempre 00:11:51
cuando estamos desarrollando 00:11:53
cuando el programa está bien pues ya no, las quitamos 00:11:54
¿vale? 00:11:56
más dudicas 00:12:02
de programa, uy de programación 00:12:03
sí, de programación, efectivamente 00:12:05
más dudas 00:12:06
de excepciones 00:12:09
vale, ves que es un 00:12:11
recurso 00:12:17
para un recurso 00:12:17
para hacer nuestros programas 00:12:20
pues un poquito más robustos 00:12:21
que no se paren las primeras de cambio 00:12:24
que sean más amigables 00:12:25
permitirles salidas 00:12:27
cuando pasan cosas raras que no nos gustan 00:12:30
darle nombre a esas cosas raras 00:12:32
¿Compensa dedicarse a hacer secciones 00:12:34
cuando puedes hacer un programa? 00:12:35
Depende de la aplicación, depende de con que 00:12:37
esté trabajando, depende 00:12:40
la respuesta es fácil pero es que es real 00:12:41
pues depende 00:12:44
del tamaño de la aplicación 00:12:44
de muchas cosas 00:12:48
claro, pero es que en este caso 00:12:49
realmente es que es así 00:12:56
claro 00:12:57
pero a ver 00:12:59
¿en qué casos no depende? 00:13:00
pues está clarísimo, hay que estar callado 00:13:04
y prestándome atención absoluta 00:13:06
en clase, sí 00:13:08
eso no depende, por ejemplo 00:13:09
vale 00:13:11
¿Se come en clase? 00:13:12
No, hay cosas que tienen respuesta inmediata 00:13:16
No hay, depende 00:13:18
Bueno, el jueves pasado, pero bueno 00:13:19
Cuatro días, exactamente 00:13:23
O cinco 00:13:27
Mentira 00:13:28
Bueno, vale, pues sí 00:13:30
¿Eh? 00:13:33
¿Pero cuándo es el día? 00:13:36
¿Cuándo es el día? 00:13:36
¿Cómo chiques? 00:13:38
Pues los chiques, a ver, si vais a comer 00:13:39
prefiero que comáis comida, no chicles 00:13:42
hombre, para tu salud 00:13:44
va a ser mucho mejor que te metas 00:13:55
un buen chuletón con patatas 00:13:56
que un chicle ajeroso 00:13:58
una hamburguesa 00:13:59
también 00:14:02
pero tiene que haber para todos, no vale solo para ti 00:14:03
Con cebolla 00:14:06
La cebolla siempre 00:14:12
Bueno, venga, a ver 00:14:14
Respondiendo de otra manera a la pregunta 00:14:15
Pues hombre, si uno ve 00:14:20
Un proyecto 00:14:22
Profesional 00:14:24
Con todos sus paquetes 00:14:26
Va a haber los paquetes de entidad 00:14:28
El de controlador, el de no sé qué 00:14:30
Y va a haber casi seguro, sí o sí 00:14:32
Un paquete que sea excepciones 00:14:34
que son las excepciones que uno se ha creado 00:14:35
es lo habitual 00:14:37
con lo cual es una práctica habitual 00:14:39
crear tus propias excepciones, salvo en aplicaciones 00:14:41
pequeñas, casi siempre vas a encontrar 00:14:43
el paquete que sea excepciones 00:14:45
y ahí van a estar las que se ha creado el programador 00:14:47
¿Por qué en tu código has casteado 00:14:49
el matrandon a un int? 00:14:51
¿Por qué he casteado 00:14:54
el matrandon a un int? Porque el 00:14:55
constructor, porque este parámetro 00:14:57
era entero, la propiedad 00:14:59
del alumno era entero 00:15:01
era la edad, no sé qué era 00:15:03
Entonces no es la edad 00:15:05
Porque 2000 no creo que fuera 00:15:11
El año 00:15:12
Sí, porque era el al año 00:15:15
Vale 00:15:17
A ver, es que este no es exactamente 00:15:20
Vuestro ejercicio 00:15:23
Este es uno con más cositas puestas 00:15:24
Pero es la misma idea 00:15:27
Es uno venido 00:15:28
Pero bueno 00:15:30
La idea es eso 00:15:32
Hacer un crear alumno con una excepción 00:15:36
Capturarlo y ver cómo funciona el tema 00:15:37
Bueno, ¿nos damos por satisfechos? 00:15:39
Con las excepciones 00:15:42
Sí 00:15:43
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:
8 de marzo de 2025 - 19:07
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
15′ 44″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
64.77 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid