Saltar navegación

Clase 08-04-24 - 3 - 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 abril de 2024 por Raquel G.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

He elegido Runtan Estetio sin dar ninguna explicación, simplemente la explicación de que es una clase de la jerarquía y que mis clases excepción tienen que insertarse en la jerarquía y si la hago heredera de esta, pues ya hereda a través de ella todo lo de excepción y por tanto puede ser lanzable con el throw, etcétera, sin más. 00:00:00
Vale, pero dentro de esas superclases de la jerarquía está la excepción sin más. Vale, pues, ¿cuál es la diferencia entre si yo lo hubiera hecho de la excepción? Por ejemplo, para no seguir modificando sobre lo mismo una y otra vez, vamos a hacernos otro método en el cual quiera yo indicar otro tipo de excepción. 00:00:20
Por ejemplo, a ver qué se nos ocurre, un método para, yo qué sé, sacar un certificado de notas dado un objeto alumno, vale, por ejemplo, bueno, es que justo ese es el ejemplo que vais a hacer vosotros, entonces vamos a cambiar otra clase. 00:00:39
vale, pues imaginaos 00:01:04
que tenemos una clase factura 00:01:13
por aquí, vamos a hacer 00:01:16
rápidamente una clase 00:01:19
factura, vale 00:01:24
la clase factura, pues bueno 00:01:30
que tenga un número 00:01:32
y que tenga una fecha 00:01:33
fecha, pues venga, para no complicarnos 00:01:38
la vida, la vamos a hacer 00:01:49
de java útil 00:01:50
java time, recordáis que es otro paquete 00:01:52
que tiene clases para trabajar con fechas 00:01:55
más moderno 00:01:57
Java útil es un poco el de toda la vida 00:01:58
Java útil tiene utilidades varias 00:02:01
Para muchas cosas 00:02:04
Entre ellas para fechas 00:02:05
Que es un poco el de toda la vida 00:02:07
Y Java time es más específico 00:02:08
Para fechas, horas, etc 00:02:09
Venga, pues nada 00:02:10
Hacemos un constructor 00:02:13
Vale, y ya está 00:02:17
Y los get y set 00:02:30
Ala, pues venga 00:02:31
Tenemos aquí una aplicación 00:02:41
Para hacer cosas con facturas 00:02:42
esta es nuestra clase factura 00:02:43
que se caracteriza solo por el número y la fecha 00:02:46
ya está, lo que sea que 00:02:49
hace esta aplicación solo le importa 00:02:51
el número y la fecha, no le importa 00:02:52
ni los ítems que hay en la factura, ni el nombre 00:02:54
nada, por lo que sea esta aplicación 00:02:57
solo necesita saber el número y la fecha 00:02:58
para hacer cosas, ya está 00:03:00
pues solo le hace falta saber el número y la fecha 00:03:02
para que meter más propiedades 00:03:04
las propiedades que hay que meter son las que le interesan 00:03:06
a la aplicación 00:03:08
aunque luego una factura tenga muchas más 00:03:09
si a la aplicación le interesan solo esas dos 00:03:12
Pues no se meten esas dos 00:03:13
Venga, pues nuestra aplicación 00:03:15
Ahora pues ya está en un main 00:03:17
Pues vamos a hacernos otro main2 00:03:20
Con su método main 00:03:24
Vale, pues esta aplicación 00:03:32
Tiene una serie de requisitos 00:03:35
Para hacer con las facturas 00:03:36
Y uno de ellos 00:03:37
Que sea, pues yo que sé, por ejemplo 00:03:40
Mostrar 00:03:42
Mostrar datos factura 00:03:45
Al que se le pasa 00:03:50
Un objeto factura como parámetro 00:03:51
Entonces, pues le hacemos aquí un método y se le pasa un objeto factura, factura f, ¿vale? Ahí ves static void. Vale, y el objetivo de este método es simplemente mostrar los datos de la factura, ¿vale? 00:03:53
pero resulta que 00:04:34
puede ocurrir que la fecha 00:04:37
esté mal, entonces si la fecha 00:04:39
está mal, en ese caso 00:04:41
no queremos mostrar los datos de la factura 00:04:43
vale, pero queremos 00:04:45
avisar de que la fecha está mal con 00:04:47
una excepción, lanzando con una excepción 00:04:49
no con un mensajito la fecha 00:04:51
está mal, porque a lo mejor 00:04:53
esto que yo he llamado system out 00:04:55
va directamente, silencio 00:04:57
va directamente a la impresora 00:04:59
entonces yo podría 00:05:01
que avisar si la fecha está mal, 00:05:03
ahora veremos qué significa estar mal, podría poner 00:05:05
un System.out.println, la fecha está mal. 00:05:07
Y si no, muestro los datos. 00:05:09
Pero imaginaos que este System.out.println 00:05:11
en realidad es 00:05:13
mandar a la impresora. 00:05:15
Que yo no lo he puesto porque no sabemos mandar a la impresora. 00:05:17
Entonces, si es mandar a la impresora, 00:05:19
yo no quiero mandar a la impresora 00:05:21
la factura está mal, o sea, la fecha 00:05:23
está mal, vaya gasto de papel. 00:05:25
Entonces, sería estúpido hacer un método en el cual 00:05:27
yo, si la fecha 00:05:29
está mal, mande a la impresora 00:05:31
la factura está mal y si la fecha 00:05:33
está bien, mande a la impresora la factura. Sería 00:05:35
estúpido. Es mucho mejor un método 00:05:37
en el cual si la fecha está mal 00:05:39
el método avisa 00:05:41
y ya el programa principal que haga lo que 00:05:43
quiera, pero el método avisa 00:05:45
y si la factura está bien 00:05:47
la manda a la impresora. Bueno, pues 00:05:49
si yo eso es lo que quiero hacer porque es lo que tiene 00:05:51
sentido, pues entonces 00:05:53
tendré que avisar con un throw, con una excepción. 00:05:55
Tendré que hacer que este método lance 00:05:58
una excepción. Entonces 00:05:59
tendré que hacerme una excepción 00:06:01
¿qué excepción quiero yo recoger aquí? 00:06:04
la fecha 00:06:07
está mal, vamos a inventarnos 00:06:08
qué puede significar que esté mal 00:06:11
que sea posterior a la de hoy 00:06:12
por ejemplo, si me mandan una factura con fecha 00:06:14
posterior a la de hoy 00:06:16
esa no la puedo imprimir todavía, por ejemplo 00:06:18
lo primero que se me ocurre 00:06:20
lo digo por jugar un poco con fechas 00:06:22
ya que nos ponemos 00:06:24
vale, pues entonces, el error 00:06:25
la excepción que yo quiero recoger 00:06:28
es fecha posterior a la actual 00:06:30
ya he identificado 00:06:33
que eso es lo que quiero recoger 00:06:35
vale, pues venga, nos hacemos una clase excepción 00:06:36
a la que la llamo 00:06:39
con el nombre más parecido 00:06:44
al hecho que yo quiero reflejar 00:06:46
fecha posterior 00:06:49
actual excepción 00:06:54
ala, ya tengo una excepción 00:06:55
que es fecha posterior a la actual excepción 00:06:58
me hago el constructor 00:07:00
lo voy a generar aquí automáticamente 00:07:01
por comodidad 00:07:04
vale, bueno 00:07:05
se me había dado el extens 00:07:15
la vamos a hacer 00:07:16
heredera 00:07:18
pero ahora en lugar de derruntime exception 00:07:19
vamos a hacer la heredera de exception 00:07:22
a ver que implicaciones tiene 00:07:25
exception era una super clase 00:07:26
derruntime exception, la heredera de exception 00:07:29
vale 00:07:31
y venga, vamos a hacerle un constructor 00:07:32
venga 00:07:35
desde 00:07:40
constructor 00:07:41
estoy haciendo en source 00:07:43
para que os vayáis acostumbrando 00:07:47
generar constructor desde la superclase 00:07:48
y marco de la superclase 00:07:51
que dos quiero reutilizar con el super 00:07:53
veis y me lo hace 00:07:55
me lo hace el ya con el super 00:07:59
tan estupendo 00:08:01
estoy escribiendo 00:08:05
lo mismo que antes pero genera automáticamente 00:08:06
vale, en el constructor 00:08:08
sin parámetros hemos dicho que aquí 00:08:10
queremos poner el mensajito que nos interesa 00:08:12
La fecha de la factura 00:08:15
No es válida 00:08:19
Porque es posterior a la actual 00:08:21
Vale 00:08:30
A la actual 00:08:37
Vale 00:08:41
Nada, ya tenemos nuestra clase excepción 00:08:42
Hereda de excepción 00:08:45
Directamente es la única diferencia 00:08:47
Con antes hereda de excepción 00:08:48
Y he puesto el mensajito que yo quiero 00:08:49
Bueno, ahora ya tengo la clase excepción 00:08:51
Ahora vamos a hacernos nuestro método 00:08:54
Aquí tenemos que distinguir 00:08:55
si no hay error 00:08:57
si la fecha está bien 00:09:00
pues mostraremos los datos 00:09:01
de la factura, los mandaremos a la impresora 00:09:03
pues ya está 00:09:06
factura, ponemos aquí el número 00:09:09
f.get 00:09:12
número 00:09:16
más 00:09:17
f.get 00:09:19
fecha 00:09:23
ala 00:09:26
si la fecha 00:09:27
no es posterior a la actual 00:09:29
mostraremos el mensaje 00:09:31
y si la fecha es posterior a la actual 00:09:32
entonces ahora es cuando queremos 00:09:35
lanzar la excepción 00:09:37
entonces haremos 00:09:38
throw new, la excepción se llamaba 00:09:40
así 00:09:43
vale, este será mi método 00:09:46
si la fecha está bien 00:09:59
hago lo que tengo que hacer 00:10:01
y si no está bien, aviso 00:10:03
hasta ahora lo que hemos hecho 00:10:05
¿qué nos falta aquí? 00:10:07
poner la condición de que la fecha 00:10:08
de la factura sea posterior 00:10:11
a la fecha actual 00:10:13
vale 00:10:15
venga, buscadlo por internet 00:10:16
como sea con lo que vimos de 00:10:19
de aquí hasta la una, a ver que 00:10:21
que, como haríais 00:10:23
eso, pues para practicar un poco con fechas 00:10:25
vale, luego ya la una lo 00:10:27
seguimos completando 00:10:29
venga 00:10:30
vale, bueno, pues en que situación os habéis 00:10:32
encontrado, que estabais con este 00:10:35
método en el cual 00:10:37
había que efectivamente 00:10:38
resolver esto 00:10:41
yo tengo la fecha de mi factura 00:10:45
que es esta 00:10:47
tengo la fecha de mi factura 00:10:48
esta es la fecha de mi factura 00:10:51
porque mi factura ha llegado por aquí 00:10:53
y tengo la fecha de mi factura 00:10:56
que es esta, que la he sacado con el get 00:10:59
tengo la fecha de mi factura 00:11:00
y ahora tengo que ver si esa fecha 00:11:01
ese objeto date es posterior a otro 00:11:04
objeto date 00:11:07
entonces tengo dos cosas que resolver 00:11:08
primero, ver cómo averiguar 00:11:10
o sea, ver 00:11:14
si tengo alguna manera de 00:11:15
cómo calculo que esta fecha 00:11:17
sea posterior a otra 00:11:19
y luego esa otra 00:11:21
cómo la genero 00:11:23
entonces, esto es un objeto de una clase 00:11:24
que ya está hecha, como todas las clases 00:11:27
que ya están hechas tendrán mil métodos 00:11:29
para permitirnos hacer mil cosas 00:11:31
entonces, lo primero que uno hace es 00:11:32
investigar los métodos que tiene eso 00:11:35
dice, a ver, yo quiero 00:11:37
poder comparar un objeto fecha con 00:11:41
otra? Pues lo primero que se pregunta 00:11:43
uno es, ¿qué puedo hacer yo con los objetos fecha? 00:11:45
¿Qué puedo hacer? Tendré que poder 00:11:47
hacer cosas con los objetos fecha, porque 00:11:49
pertenecen a clases que ya están hechas. 00:11:51
Luego, esta clase tiene un montón de métodos. 00:11:53
Entonces, ¿me permitirá hacer cosas 00:11:55
con las fechas? 00:11:57
Yo, en particular, lo que quiero hacer con las fechas 00:11:59
es compararla con otra. 00:12:01
Bueno, pues vamos a ver. Vamos a ver qué tiene, 00:12:03
qué métodos me ofrece. O me voy a la documentación, 00:12:05
o si tengo un entorno de desarrollo 00:12:08
que me accede a la documentación en línea 00:12:09
como es este, lo hago 00:12:11
y me pongo a mirar. Y en este además, como es con la A, 00:12:12
pues es que es el primero ya que 00:12:16
me ofrece. Me dice, fíjate, 00:12:17
de los métodos que hay en 00:12:19
date, tienes uno 00:12:21
que por el nombre, tiene toda la pinta 00:12:23
que ya te está diciendo si 00:12:25
esa fecha que llama al método está después 00:12:27
que la que tú le pases como parámetro. 00:12:29
Pues ya lo tienes resuelto 00:12:32
y justo es lo que quiero hacer. 00:12:33
Ver si mi fecha que llama al método 00:12:35
está después que la que yo le paso 00:12:37
como parámetro, pues será 00:12:39
esto, será esto lo que yo voy 00:12:41
a usar, ¿vale? 00:12:43
Ese boolean 00:12:46
será true o false, si está después o no está 00:12:47
después, ¿vale? 00:12:49
Luego tengo un compare to, de hecho, claro, 00:12:51
el compare to, porque date 00:12:53
hereda de comparable, 00:12:55
a heredar de comparable le permite comparar fechas, 00:12:57
pero el compare to ya sabemos 00:13:00
que cumple los requisitos 00:13:01
y es que te devuelve un entero, 00:13:03
te devolverá negativo 00:13:05
si la fecha que llama el método 00:13:06
va después que esta 00:13:09
te devolverá cero si es la misma fecha 00:13:10
y te devolverá positivo 00:13:13
si la fecha que llama el método va después que esta 00:13:15
entonces el compareTo es más genérico 00:13:17
te devuelve 00:13:19
menos uno, cero o uno 00:13:21
en función de si la fecha que llama el método 00:13:22
va antes 00:13:25
es la misma después que esta 00:13:26
luego ya viendo esto ya vemos además 00:13:28
que date es comparable 00:13:31
con lo cual si yo tengo una lista de fechas 00:13:32
con el sort las puedo ordenar 00:13:34
pues ya había muchas cosas 00:13:36
y veo en particular que tengo un método 00:13:37
más concreto 00:13:40
que estará interiormente 00:13:41
está abarazado en comparable, claro 00:13:44
que ya me dice directamente en un true o false 00:13:46
ya en un true o false me dice 00:13:48
si la fecha que llama el método va después que esta 00:13:50
o no, pues es justo 00:13:52
justo lo que necesitamos 00:13:54
bueno, pues entonces uno dice, ah vale 00:13:55
pues voy a usar esto como 00:13:58
mi condición, esta va a ser 00:14:00
mi condición 00:14:04
si la fecha es posterior 00:14:07
a la actual 00:14:12
y sigo con el siguiente problema 00:14:15
que es como creo yo hay un objeto fecha 00:14:17
con la fecha actual 00:14:19
entonces aquí será un no delante 00:14:20
porque si no es 00:14:22
posterior a la actual, ese es el caso bueno 00:14:25
entonces imprimo la factura 00:14:27
en el else lanzo la excepción 00:14:29
porque la fecha no es buena, lanzo la excepción 00:14:32
¿vale? entonces 00:14:34
¿qué me falta a mí aquí? 00:14:35
me falta simplemente 00:14:38
ver cómo genero yo un objeto fecha 00:14:40
con la fecha actual 00:14:42
vale, pues si uno 00:14:43
busca documentación de date 00:14:45
cuando usamos date, ya 00:14:47
en algún momento dijimos, pero si no es que 00:14:49
uno lo encuentra en cuanto investigue 00:14:51
dos segundos, lo va a encontrar 00:14:53
que si tú instancias 00:14:54
un objeto date 00:14:57
así directamente 00:14:58
instancias tal cual con el constructor sin parámetros 00:15:00
lo instancia sin darle nada adentro 00:15:05
te genera un objeto fecha 00:15:07
con la fecha actual 00:15:08
con la fecha del momento de la instanciación 00:15:10
pues justo, ya lo tenemos 00:15:12
todo lo que necesitamos 00:15:14
¿vale? ya tenemos todo lo que necesitamos 00:15:15
la fecha de mi factura 00:15:21
esta 00:15:23
esta es la fecha 00:15:24
de mi factura 00:15:27
que la fecha de mi factura no es 00:15:28
posterior a la fecha actual 00:15:31
no es posterior 00:15:33
la mando a la impresora 00:15:34
que si es posterior 00:15:36
no tengo que mandar a la impresora y aviso 00:15:38
la fecha es posterior 00:15:41
y ya el que llama el método 00:15:42
que lo llama aquí arriba 00:15:44
que ya decida que hace 00:15:45
si para el programa, si no lo para 00:15:47
y le dice al usuario todavía no toca 00:15:50
imprimir estas facturas, ya depende 00:15:52
depende de lo que tenga que hacer mi software 00:15:54
¿vale? bueno 00:15:56
bueno, pues entonces, el método ya estaría 00:15:58
y la excepción lanzada 00:16:00
es esta, fecha posterior, que es esta de aquí 00:16:02
vale, entonces 00:16:04
esto lo había puesto para hacer una prueba 00:16:07
vale, pues a ver, hemos 00:16:09
decidido que esta excepción que hemos hecho 00:16:12
herede de la superclase 00:16:14
exception, que está todavía 00:16:15
por encima de runtime exception, que herede de ella. 00:16:17
Vale, pues, ¿qué diferencia 00:16:20
hay entre que herede de esta y que herede de la otra? 00:16:22
Pues, si una 00:16:25
excepción, si yo lanzo una excepción 00:16:25
que hereda directamente de exception, 00:16:27
esa excepción 00:16:30
es una excepción que ya en 00:16:31
tiempo de compilación 00:16:33
me obligan a tratarla. 00:16:35
Cuando yo lanzo una excepción 00:16:38
que hereda de runtime exception, la lanzo 00:16:39
y ya está. Y luego 00:16:41
llamo al método y no pasa nada. Y en tiempo 00:16:43
de ejecución puede que aparezca 00:16:45
o puede que no. 00:16:48
Pero cuando lanzo una excepción que hereda 00:16:49
de exception y no de runtime, 00:16:51
ya en tiempo de compilación, 00:16:54
ya desde mi código, tengo 00:16:56
que hacer un aviso. 00:16:57
Es decir, son excepciones 00:17:00
verificadas que se llaman. 00:17:02
Excepciones verificadas. 00:17:04
Y es lo que me está diciendo aquí al ponerse el compilador 00:17:06
en rojo. Me está diciendo 00:17:08
el compilador, oye, cuidado, este método 00:17:09
está lanzando una excepción 00:17:11
tienes que avisar 00:17:12
tienes que avisar 00:17:15
y este método tuyo 00:17:17
tiene que recoger en su cabecera 00:17:19
que puede 00:17:22
que lance esa excepción 00:17:23
entonces 00:17:25
si vosotros marcáis aquí 00:17:26
la opción que te da a throws 00:17:29
pues es justo lo que nos hace 00:17:31
si lo hago más pequeño para que se vea 00:17:34
lo hago grande 00:17:37
es decir, desde el momento en que un método 00:17:38
lanza una excepción 00:17:46
que hereda de exception 00:17:49
y no de runtime, sino de exception 00:17:49
que es más poderosa 00:17:51
ese método está obligado 00:17:53
a avisar de que puede que la lance 00:17:55
está obligado a avisar 00:17:58
¿y cómo avisa? 00:18:00
poniendo aquí el throws 00:18:02
throws y el nombre de la excepción 00:18:04
luego, si esta 00:18:06
heredara de runtime exception 00:18:09
esto no hace falta ponerlos 00:18:11
de hecho antes lo hemos hecho 00:18:13
y no hemos puesto ningún throw 00:18:15
esas son las excepciones 00:18:17
que se llaman no verificadas 00:18:19
por código en tiempo de compilación 00:18:21
yo la lanzo y ya en tiempo 00:18:23
de ejecución si sale que salga 00:18:25
ya está, pero en tiempo de 00:18:28
escritura de código yo no tengo 00:18:29
que hacer nada más 00:18:31
pues en las exception esas 00:18:32
por ser más 00:18:35
peligrosas, tener más 00:18:37
implicaciones, por lo que sea que uno quiera 00:18:39
decidir, eso ya es una cuestión subjetiva 00:18:41
si decidimos 00:18:43
que herede de exception 00:18:45
nuestro método tiene que avisar 00:18:46
se supone que esa es más 00:18:49
crítica, tiene que avisar 00:18:51
y avisa el método poniendo 00:18:53
el throws y el nombre de la excepción 00:18:55
¿vale? es obligatorio 00:18:57
como no avisen, el compilador nos deja seguir 00:18:59
si yo quito esto 00:19:01
si yo quito esto, como veis 00:19:03
el compilador se va a poner 00:19:12
rojo y me dice, no, lo siento 00:19:14
no puedes lanzar una exception 00:19:15
así por la buena si el método no avisa 00:19:17
si la haces 00:19:19
runtime exception, si la haces runtime exception, sí 00:19:21
pero si la haces 00:19:24
exception, lo siento, pero tienes 00:19:25
que avisar, bueno, pues ya está 00:19:27
nosotros queremos que sea exception, porque queremos 00:19:29
que sea de estas verificadas por código 00:19:31
que ahora vemos lo que implica, pues entonces 00:19:33
tenemos que hacer el throws, vale 00:19:35
vale, pues ya está, el método ya se 00:19:37
queda tranquilo porque ya hemos hecho el throws 00:19:39
pero claro 00:19:41
¿qué implica hacer el throws? 00:19:42
implica 00:19:47
que ahora 00:19:47
el que usa ese método 00:19:48
o sea, este método ya está hecho 00:19:51
lo hizo un tío por ahí, que no sabemos ni quién es 00:19:53
ahora yo vengo aquí a ejecutarlo 00:19:55
perdón, a usarlo 00:19:57
vengo yo aquí a usarlo 00:19:59
no tengo ni idea de cómo está hecho 00:20:03
ni idea, lo hizo otro, no tengo ni idea de cómo está hecho 00:20:05
solo sé que es un método 00:20:07
que si yo le paso una factura 00:20:09
me la manda por la impresora 00:20:11
entonces como me interesa 00:20:13
pues lo uso, pero ni lo he hecho yo 00:20:14
ni tengo ni idea 00:20:17
vale, pues yo lo uso, como me han dicho que lo tengo que usar 00:20:18
que es pasarle un objeto factura 00:20:21
luego lo estoy usando bien porque le estoy pasando un objeto factura 00:20:23
y se me pone 00:20:26
el compilador me sigue avisando 00:20:30
claro, ¿de qué me está avisando el compilador? 00:20:31
pues el compilador me está avisando 00:20:35
de que, oye, cuidado 00:20:37
me está diciendo, cuidado 00:20:41
que este método que estás llamando 00:20:47
perdonadme 00:20:48
sí, sí, soy yo 00:20:52
seguimos 00:21:03
vale, pues entonces 00:21:09
la ventaja que tienen 00:21:12
estas excepciones 00:21:15
es que 00:21:16
el que está usando el método ya le están avisando 00:21:17
le están dando una información que 00:21:21
si lo hubiéramos hecho en la de Runtime 00:21:23
no tendría ni idea 00:21:25
el que usa este método, lo usa 00:21:26
y se encuentra que la excepción 00:21:28
le sale en tiempo de ejecución 00:21:30
y ahí ya dice, ah, que me puede 00:21:33
salir esta excepción, en tiempo de ejecución se la 00:21:34
encuentra, pero antes 00:21:36
el desarrollador que la está usando 00:21:38
no tiene ni idea, sin embargo 00:21:40
si le hacemos heredera de excepción 00:21:42
el que está usando ese método 00:21:44
ya recibe 00:21:46
el aviso y le dice, cuidado 00:21:48
que este método te está lanzando una excepción 00:21:50
entonces tienes que 00:21:52
o capturarla o si no 00:21:54
la capturas tienes que a su vez 00:21:56
propagarla tú hacia arriba con otro throws 00:21:58
te está obligando 00:22:00
y mientras no hagas una cosa u otra 00:22:01
el error de combinación no se quita 00:22:03
luego esa es la diferencia 00:22:06
entre lanzar 00:22:08
una excepción 00:22:10
con 00:22:12
lanzar una excepción 00:22:15
que herede de runTimeException o que herede de exception 00:22:20
si esta hereda 00:22:23
de runTimeException, ya está 00:22:24
tranquilamente el método 00:22:26
lo terminamos, este throws 00:22:28
no hay que ponerlo 00:22:30
y luego cuando usamos ese método 00:22:32
de hecho 00:22:34
si lo cambiamos aquí 00:22:36
si yo aquí rápidamente a esto 00:22:37
la voy a cambiar, la voy a cambiar a runTimeException 00:22:40
la cambio a runTimeException 00:22:42
pues ya está 00:22:46
este método me ha dejado lanzarla 00:22:47
y aquí ni 00:22:50
throws ni nada 00:22:52
yo quito el throws 00:22:53
y no pasa absolutamente nada 00:22:55
no pasa nada 00:22:58
el método ya está terminado 00:23:00
y yo uso este método 00:23:01
y ya está, y lo uso tranquilamente. 00:23:03
¿Qué puede ocurrir? 00:23:06
Que luego en tiempo de ejecución me salga la excepción. 00:23:07
En tiempo de ejecución me sale. 00:23:10
Pero yo en tiempo de compilación 00:23:12
no sé que me puede salir o no. 00:23:14
O sea, si conozco este código, 00:23:17
sí lo sé que me puede salir. 00:23:19
Si no lo conozco, no tengo ni idea 00:23:20
de que me puede salir o no. 00:23:21
Me va a salir en tiempo de ejecución. 00:23:22
¿Qué quiero capturar por si acaso hay excepciones 00:23:25
que no conozco? 00:23:28
Puedo hacer un try-catch con excepción. 00:23:29
¿vale? es lo más que puedo hacer 00:23:31
pero me falta 00:23:34
información, entonces 00:23:35
algunas excepciones son así, por ejemplo 00:23:36
null pointer exception te hereda de run time 00:23:39
exception, porque es que es un 00:23:42
rollo que tuviéramos que capturar 00:23:44
todos los null pointer exception 00:23:46
es un rollo, entonces algunas se heredan 00:23:48
de run time exception porque 00:23:50
se asume, bueno, no te voy a estar 00:23:51
obligando a capturarlas todas 00:23:53
que te salga en tiempo de ejecución y ya está 00:23:55
y ya tú 00:23:57
te vas a arreglar lo que sea 00:23:59
¿vale? pero si nosotros 00:24:01
queremos nuestro software 00:24:03
al que va a usar el método 00:24:05
ya de partida, el que lo va a usar 00:24:06
para hacer su propio código, decirle 00:24:09
cuidado que te va a lanzar una excepción 00:24:11
si queremos eso 00:24:13
pues entonces la hacemos heredera de 00:24:13
exception sin más 00:24:17
y al hacer 00:24:19
la heredera de exception tiene todas estas 00:24:21
implicaciones 00:24:23
el método ya se queja y me dice 00:24:24
oye, tienes que poner 00:24:27
el throws, vale 00:24:29
ponemos el throws 00:24:30
el método se queda tranquilo 00:24:32
ya está, se queda tranquilo el método 00:24:34
pero ahora, el que usa 00:24:39
nuestro software 00:24:41
el que lo usa, le dice, oye 00:24:43
cuidado que estás usando 00:24:45
un método que te puede 00:24:47
lanzar esta excepción 00:24:49
fecha posterior a la actual, cuidado 00:24:50
o captúrala 00:24:53
o propágala, que se llama 00:24:55
que son las dos opciones que te da aquí 00:24:57
la de arriba, throws 00:24:59
es propagar 00:25:01
y la de abajo es capturar 00:25:02
que la capturamos con el try-catch 00:25:04
como he hecho otras veces, estupendo, capturar 00:25:07
ya sabemos lo que significa 00:25:09
que si sale la excepción, se va el catch, el programa no se para 00:25:10
que no quiero capturarla 00:25:13
porque no quiero try-catch, porque 00:25:15
si sale esta excepción, quiero que la máquina virtual 00:25:16
pare el programa, que no quiero capturarla 00:25:19
no quiero capturarla 00:25:21
pues entonces hay que hacer 00:25:22
lo que viene arriba 00:25:24
que es propagar, ¿y qué es propagar? 00:25:26
pues a su ir lanzando el throws 00:25:29
más arriba y más arriba y más arriba 00:25:31
es decir, el método en el que estoy 00:25:33
que aquí ya es el main 00:25:35
ya es el main directamente, pues en el que estoy 00:25:37
ponerle a su vez el throws 00:25:39
si dais aquí a esa opción 00:25:41
ya está 00:25:44
aquí está el throws 00:25:45
y ya está, ya se queda tranquilo 00:25:46
entonces repito, cuando un método 00:25:48
llama, perdón, puede lanzar 00:25:53
una excepción 00:25:54
de las verificadas que se llaman, que son las que llaman 00:25:55
de exception, no podemos 00:25:59
llamarlo sin más. Tenemos 00:26:01
que, además, o capturar 00:26:03
o propagar hacia arriba. 00:26:05
¿Vale? 00:26:10
Y si no capturamos, el método 00:26:11
en el que estemos, hay que ponerle el throws. 00:26:13
¿Qué es el main? Pues el main. ¿Qué es otro? 00:26:14
Porque yo puedo haber llamado a los altos desde otro método. 00:26:16
Pues otro método tendrá el throws. 00:26:19
Y ya cuando ya he puesto todos los throws, 00:26:21
ya puedo ejecutar esto. 00:26:23
Dime, ¿qué te...? 00:26:25
Claro, que o capturabas 00:26:25
o propagaba, si tenías que poner el throws arriba 00:26:34
claro, pues era exactamente por esto, porque 00:26:35
la IO exception 00:26:37
hereda de exception directamente 00:26:39
entonces una IO exception, cuando lees 00:26:41
del teclado y te sale en IO exception 00:26:44
o la metes en un try catch o pones el throws 00:26:45
en el main, porque la 00:26:48
IO exception es de esas 00:26:49
la null pointer exception 00:26:51
no, nos ha salido muchos 00:26:53
null pointer exception y no hemos tenido que poner throws en el main 00:26:55
ni nada, pero la IO exception 00:26:58
sí 00:27:00
bueno, pues ahora si probamos 00:27:00
esto, yo para hacer el main 00:27:03
bueno, he creado 00:27:05
una fecha 00:27:07
cualquiera, en su momento 00:27:08
cuando hicimos fechas, pues dijimos que esta era una forma 00:27:12
fácil, hacíamos un objeto 00:27:13
format 00:27:15
con el formato 00:27:16
con el que queríamos meter la fecha, con el formato 00:27:19
y ahora ya creamos 00:27:21
el objeto fecha 00:27:23
con el método parse 00:27:24
de ese objeto formato, pues yo he creado aquí 00:27:27
una fecha de dite de abril, he creado 00:27:29
esta fecha. A su vez 00:27:31
el método parse, a su vez el método 00:27:33
parse, te puede 00:27:35
lanzar la excepción parseException 00:27:37
que hereda la excepción. 00:27:39
Con lo cual, parseException 00:27:42
me ha obligado o a capturarla 00:27:44
o a propagarla. Es decir, 00:27:45
cuando yo he escrito esto así sin más 00:27:48
para intentar hacer la 00:27:49
fecha, cuando he escrito esto 00:27:51
así sin más, él me ha dicho 00:27:55
¡Ojo! El método al que 00:27:57
estás llamando tiene un throw dentro 00:27:59
de tipo parseException 00:28:01
y es de tipo exception 00:28:03
no runtimeException, con lo cual o la capturas 00:28:05
o la propagas 00:28:07
vamos a hacer el vago, que es propagarla 00:28:08
para que el método sea más corto 00:28:11
vamos a hacer el vago, pues yo pongo aquí 00:28:12
throws y ala, aquí me apareció 00:28:15
¿veis? mi main ahora 00:28:17
al throws pueden seguirle 200.000 excepciones 00:28:18
las que uno quiera, a este le sigue 00:28:21
esta mía, el parseException 00:28:23
un mismo método 00:28:26
puede hacer throws de un montón 00:28:27
bueno, pues entonces 00:28:29
ya tengo mi objeto fecha, este de aquí 00:28:31
con 17 de abril 00:28:34
y ahora llamo 00:28:35
a mostrar datos, pasándole una factura 00:28:37
del 17 de abril 00:28:40
le vamos a pasar primero una 00:28:41
que no es posterior a la actual, para ver si lo hace bien 00:28:44
el 2 de abril no es posterior a la actual 00:28:46
ejecutamos mostrar datos con fecha 00:28:48
del 2 de abril 00:28:52
y lo hace bien, me saca la factura 00:28:53
imprimida 00:28:55
Vamos a pasarle ahora una fecha posterior 00:28:57
Al 17 de abril 00:29:00
Pues efectivamente 00:29:01
Como no he capturado la excepción 00:29:05
La máquina virtual 00:29:07
Ha hecho el print de estas 3 el solito 00:29:10
Con el mensajito que yo le puse 00:29:12
No es válida porque he puesto ya la actual 00:29:14
Y ha parado el programa 00:29:15
Y ha parado y ya está 00:29:17
Yo podía haber optado por capturarla 00:29:19
En lugar de poner el throws este de aquí 00:29:23
Esto podía haber optado 00:29:25
Por 00:29:29
podía haber optado por 00:29:31
capturarla 00:29:39
haber hecho aquí un try catch 00:29:40
y ahora 00:29:42
por ejemplo, y aquí 00:29:45
venga, en el caso de que tú intentas 00:29:48
mostrar datos, que te sale 00:29:51
la excepción fecha posterior 00:29:53
actual, pues lo que tú quieras 00:29:54
print estas tres o lo que te dé la gana 00:29:57
puso mal la fecha 00:29:58
o sea, las fechas 00:30:04
posteriores no 00:30:05
se imprimen 00:30:10
lo que uno decide hacer en el catch 00:30:11
y el programita seguiría 00:30:14
no se pararía, en este caso no se pararía 00:30:17
porque he hecho un try catch 00:30:19
en el caso anterior se paraba 00:30:21
aunque yo tuviera un adiós, se paraba 00:30:23
entonces en este caso 00:30:25
con el try catch 00:30:27
va a saltar la excepción, va a hacer esto 00:30:28
y va a seguir 00:30:31
que es justo lo que ha hecho 00:30:32
me ha dicho, lo siento, las fechas postidas 00:30:36
no se imprimen, adiós 00:30:38
pues mucho mejor así, capturado 00:30:40
porque ya el usuario que está usando el programa 00:30:43
pues le sale la información 00:30:45
que él entiende, no lo rojo que él no entiende 00:30:47
y el programa sigue 00:30:49
¿vale? 00:30:50
pero repito, si estamos 00:30:55
si todavía no hemos entregado el programa al usuario 00:30:57
y estamos nosotros 00:31:00
todavía depurándolo 00:31:01
y trabajando con él 00:31:07
pues esto lo dejaremos 00:31:08
dejaremos el print extract trace 00:31:11
porque el print extract trace 00:31:13
nos saca toda la información 00:31:15
de lo que ha pasado 00:31:17
el print extract 3 nos saca todo 00:31:18
si yo ejecuto esto 00:31:21
pues efectivamente me saca 00:31:22
el print extract 3 ese, que es todo esto 00:31:25
luego además 00:31:27
me ha sacado el system.out.println 00:31:29
y luego el programa seguido 00:31:30
vale 00:31:31
bueno, pues más o menos esto es todo lo que nos interesa 00:31:34
saber de excepciones 00:31:42
y las excepciones obviamente se usan 00:31:43
las aplicaciones tienen sus propias excepciones creadas 00:31:45
para que 00:31:48
los diferentes métodos avisen con excepciones 00:31:50
de lo que ha pasado y el que usa 00:31:52
esos métodos, pues decida 00:31:53
qué hace, si los captura, si los 00:31:56
propaga, es la forma de comunicarse, es 00:31:58
una de las maneras de comunicarse entre sí 00:31:59
los métodos, no sólo a través de los parámetros 00:32:01
que se pasan en los métodos, 00:32:04
los retornos que se devuelven, sino a través 00:32:05
de excepciones que se van lanzando y que van avisando. 00:32:08
¿Vale? Eso por un lado. 00:32:10
Y luego por otro lado, también 00:32:12
tenemos que interpretar lo otro importante, las 00:32:14
implicaciones de hacer un try-catch y no hacerlo. 00:32:15
Claro. Entonces, los 00:32:18
try-catch hacen los programas 00:32:20
obviamente más robustos porque me permiten 00:32:21
a mí que el programa no se pare, avisarle al usuario 00:32:23
pero es 00:32:26
el código que da más engorroso 00:32:27
porque hay que irlo metiendo todo en try-catch 00:32:29
que es un rollo 00:32:31
y luego además cuidado con los try-catch 00:32:32
porque abren un bloque de código 00:32:36
cuidado, abren un bloque 00:32:38
de código 00:32:40
y todo lo que se declare aquí dentro 00:32:40
solo es visible 00:32:43
ahí dentro 00:32:46
porque esto es un bloque de código 00:32:46
entre llaves, si yo declaro aquí 00:32:49
una variable n 00:32:51
esta variable n 00:32:52
solo es visible 00:32:55
aquí dentro del try catch, si yo intento 00:32:59
acceder aquí 00:33:00
lógicamente no voy a poder, me va a decir 00:33:01
oye n no existe, vale, o sea cuidado 00:33:04
cuando hagáis try catch que todo lo que 00:33:06
esté dentro lo habéis hecho 00:33:08
automáticamente local 00:33:11
a esas llaves, fuera no está 00:33:12
que yo quiero que la n 00:33:14
sea visible fuera, pues tendríamos 00:33:16
que declararla aquí, aunque luego yo le diera valor 00:33:18
aquí dentro 00:33:20
aunque yo le diría valor aquí dentro, tendríamos que declararla ahí 00:33:21
vale, entonces ya sí 00:33:24
entonces cuidado con 00:33:26
cuando hacéis un try-catch 00:33:29
que las variables que estén declaradas dentro automáticamente 00:33:30
se han quedado ahí encerradas 00:33:32
vale, vale 00:33:33
bueno, pues entonces 00:33:38
del 00:33:39
aula virtual, a ver 00:33:40
vamos a 00:33:46
hacer visible algunos ejercicios 00:33:47
para que hagáis ya aquí al viernes 00:33:51
Y luego ya el viernes hacemos más ejercicios 00:33:53
De todo, más cosas y más rollos 00:33:55
A ver, vamos a parar esto 00:33:57
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
11
Fecha:
8 de abril de 2024 - 19:33
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
34′
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
172.36 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid