Saltar navegación

20250227 Excepciones_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 7 de marzo de 2025 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Y veis vosotros, que estáis a punto de decirme eso, jolines, pues si realmente las clases de Java que están hechas, que las ha hecho un tío o una tía, no las ha hecho nadie, las ha hecho alguien, y avisa de esa manera tan maravillosa de cuando algo ha ocurrido, lanzando un objeto que me obliga a mí a pronunciarme, porque yo no puedo hacer lo mismo con mis propios códigos, 00:00:00
porque ellos tienen la potestad de avisarme 00:00:25
de que algo está pasando mal 00:00:27
de esa manera tan chula 00:00:29
que es creando un objeto, lanzándolo para que yo 00:00:30
me llegue a las manos y diga ¿qué hago con él? 00:00:33
pues yo también quiero hacer eso en mis códigos 00:00:35
quiero poder lanzarse a los demás 00:00:37
el que los use 00:00:40
y decir vale, tú me estás usando al código que yo he hecho 00:00:40
esto que haces no me gusta 00:00:43
toma, te lanzo ese objeto 00:00:45
y ahora ya te toca a ti decidir qué haces con él 00:00:47
¿por qué no pueden hacer nosotros eso si lo hacen ellos? 00:00:49
pues claro que podemos si lo hacemos en 00:00:51
todos nuestros códigos y de hecho es una práctica 00:00:53
de programación muy buena 00:00:55
y sería de la siguiente manera 00:00:57
claro 00:01:01
a ver 00:01:05
lo vamos a meter en este mismo proyecto porque es un 00:01:08
ejemplito chorra y ya está 00:01:09
¿dónde está esto? 00:01:11
ya voy a tener que empezar 00:01:19
a separar por 00:01:20
esta aquí 00:01:22
a ver si aquí hay 00:01:24
aparte del workspace hay working set 00:01:26
que es mucho más 00:01:29
a ver, no son de hace años 00:01:29
porque solo llevo un año 00:01:35
con el portátil 00:01:36
ninguno, todos estos son 00:01:39
de hechos aquí en clase, o sea ninguno 00:01:42
son de estos de casa 00:01:44
por eso que los podría borrar todos 00:01:46
sí, efectivamente 00:01:48
ya, pero cuesta mucho, duele 00:01:50
Pero sí, los podría borrar todos 00:01:54
Y me quedaba igual 00:01:56
Vale 00:01:57
Ejemplo excepciones 00:02:00
Que ya lo tenía y me has distraído 00:02:03
Y ahora lo he perdido 00:02:05
Hombre, como siempre 00:02:06
¿Ahí dónde? 00:02:08
No, ejemplo excepciones 00:02:12
Con una barra baja 00:02:14
No, con una barra baja 00:02:14
Sin barra baja no es 00:02:17
Porque el que sin barra baja 00:02:19
Es el del año pasado 00:02:22
No tengo nada del año pasado 00:02:23
Bueno, he dicho un año 00:02:26
Es que los del año pasado no eran tan listos 00:02:28
Como vosotros e íbamos con retraso 00:02:30
A ver 00:02:32
Yo generalizo siempre 00:02:37
Luego cada uno por separado 00:02:40
Tenéis muchísimos recursos 00:02:42
Lo que pasa es que luego os ponéis juntos 00:02:43
Y cuando os ponéis juntos pues ya 00:02:46
Ahí está 00:02:48
Vale, pues por ejemplo 00:02:52
Por ejemplo, nosotros vamos a hacer una aplicación 00:02:56
que gestiona, pues yo que sé 00:03:02
que queremos que gestione 00:03:04
pedidos, por ejemplo, y nos van a 00:03:05
dar datos de pedidos 00:03:08
y una de las cosas que a nos gusta es que se empeñen 00:03:09
en cuando el precio del pedido y me lo pongan negativo 00:03:12
No, eso no se lo vamos a dejar 00:03:14
que me pongan un precio de pedido negativo 00:03:16
Pues, ¿cómo se lo vamos a 00:03:18
limitar con esto de las excepciones? 00:03:20
Pues venga, esta aplicación 00:03:23
vamos a ofrecer nosotros 00:03:24
una aplicación con unos métodos 00:03:26
para gestionar pedidos y ya está 00:03:28
venga, pues vamos a hacernos aquí 00:03:30
un paquete 00:03:33
sí, ejemplo 00:03:36
de nuestras excepciones 00:03:39
un nombre de paquete muy feo y muy raro 00:03:41
pero bueno, para cuando lo 00:03:45
ahora, aplicación que gestiona 00:03:46
pedidos, como no me ofrecéis nada más original 00:03:49
pues pedido 00:03:51
y del pedido solo nos interesa 00:03:53
la descripción y lo que cuesta. 00:04:00
Joder, es que realmente se me están olvidando las cosas. 00:04:15
Vale, pues venga, vamos a hacerle aquí un constructor. 00:04:24
Vale, pues venga, y ahora vamos a hacer nuestro main 00:04:48
que gestiona pedidos, y ya está. 00:04:50
Y esta aplicación, vale, es muy sencillita y muy pequeña, 00:04:53
pero podría ser una aplicación enorme que ya ofrecemos 00:04:56
a los demás para que la usen 00:04:59
entonces 00:05:01
vamos a hacer nuestro main, esta clase pedido 00:05:04
tan estupenda, ya la hemos ofrecido a alguien 00:05:06
y hemos dicho, uy tengo una clase pedido que es justo lo que necesitas 00:05:07
pues te la ofrezco 00:05:10
a ti para que tú la uses de tu aplicación 00:05:12
vale, pues venga, vamos a usarla 00:05:14
desde nuestra aplicación 00:05:16
nos hacemos aquí un main 00:05:17
y ahora que bien 00:05:19
que me han ofrecido una clase pedido 00:05:31
para usarla para hacer cosas 00:05:33
Pues voy a trabajar 00:05:34
Yo ahora ya con pedidos 00:05:37
Voy a trabajar 00:05:38
Pero si vamos a hacer nada, dos líneas de código y ya está 00:05:48
Venga y le voy a decir 00:05:50
A un tío, mi aplicación es 00:05:52
Meter un pedido y ya está 00:05:54
Bueno, es que de hecho no voy a poner ni un array 00:05:55
Vale, ni un array 00:05:57
Y le vamos a decir 00:06:03
Bueno, pues vais a ver 00:06:08
Que cosa tan maravillosa 00:06:25
Podemos hacer 00:06:27
Pues venga 00:06:28
La aplicación va a ser pedir los datos 00:06:31
Y crear el pedido 00:06:33
Y ya está 00:06:35
Ya, pero es que os ofrezco ideas 00:06:35
O sea, os pido ideas y no me dais ninguna 00:06:39
Claro, cuando ponemos magos 00:06:42
Robots 00:06:48
Criaturas cósmicas en general 00:06:49
Pues no os enfadáis 00:06:52
Ahora ya 00:06:53
A poca cosa jugar 00:06:58
stream 00:06:59
descripción 00:07:13
igual a 00:07:16
pues ya está 00:07:19
venga 00:07:22
pre-ci-o 00:07:33
next 00:07:40
dabel 00:07:50
y ahora la aplicación crea el pedido 00:07:55
y te dice pedido creado y 00:07:58
terminamos 00:08:00
que lo muestre además 00:08:01
y se acabó 00:08:19
con lo cual vamos a poner un toString para que lo muestre 00:08:21
ala pues 00:08:23
una aplicación 00:08:31
muy sofisticada que ha podido hacer 00:08:33
alguien para gestionar pedidos gracias a que 00:08:35
alguien le ha ofrecido una clase a su vez muy 00:08:37
sofisticada con muchas cosas pedidas. 00:08:39
Y nosotros pues probamos esta 00:08:41
aplicación. 00:08:43
¿Bajar a dónde? 00:08:46
Descripción. 00:08:58
Bollis. 00:08:59
Precio. 00:09:01
56. Pedido 00:09:02
creado. Vale. 00:09:03
Ya está. Ahora. 00:09:05
Venga. 00:09:09
Vamos a dar el pedido. 00:09:10
Descripción. 00:09:11
Rotus. Precio. 00:09:13
Pues como el usuario es muy espabilado, dice 00:09:15
le voy a meter un precio negativo a ver si hay suerte 00:09:17
y me lo ingresa en cuenta, en vez de retirármelo 00:09:20
de la cuenta 00:09:22
pues se lo ha comido 00:09:22
y cuando él vice un automático 00:09:25
que está conectado a este, lo que sea 00:09:28
pues en lugar de un ingreso, la transferencia 00:09:30
pues le va a hacer un ingreso al señor 00:09:32
con lo cual 00:09:34
este negativo a ver que controlarlo 00:09:36
vale 00:09:38
para que no nos la cuelen de esta manera 00:09:40
entonces claro, si es muy fácil controlarlo 00:09:41
pues bueno 00:09:44
tenemos mil recursos 00:09:45
podemos aquí meternos en un bucle 00:09:47
y estarle preguntando todo el rato 00:09:49
oye, mientras no sea negativo 00:09:51
introduja otra vez, introduja otra vez 00:09:53
introduja otra vez 00:09:55
hay miles de posibilidades 00:09:56
¿cuál es una? muy bonita 00:09:59
decir, a ver, en mi aplicación 00:10:03
hay una cosa 00:10:06
que no me gusta 00:10:07
y es que este dato 00:10:08
cuando me llega aquí 00:10:11
es decir, mi problema ha sido 00:10:13
en el constructor, mi problema es en el constructor 00:10:15
y es 00:10:17
precio del objeto pedido 00:10:19
negativo, no lo quiero 00:10:21
entonces yo identifico eso, situación de error 00:10:22
esa no me gusta 00:10:25
precio del pedido negativo 00:10:27
no me gusta, vale 00:10:29
lamentablemente es que no hay 00:10:31
un tipo de dato que sea 00:10:33
solo positivos, naturales 00:10:35
o reales positivos 00:10:37
es que no lo hay, entonces 00:10:39
si lo pongo double, pues el precio 00:10:41
va a poder ser negativo 00:10:43
entonces, esa situación de error 00:10:44
pues, ¿qué hago? me la voy a tener que tragar 00:10:47
vale, bueno, pues hemos identificado 00:10:49
situación de error, bueno, pues ¿qué es lo que hacemos? 00:10:51
pues lo que hace la máquina virtual, que se apunta 00:10:53
en su libretita, ¿no? en sus clases 00:10:55
libretita, no me gusta que cuando yo estoy 00:10:56
esperando un número sin comas, tú metas 00:10:59
uno con coma, esto no me gusta 00:11:01
me cleo una clase, pues 00:11:03
nosotros estamos apuntando, no me gusta 00:11:05
que esta variable 00:11:07
double, que es el precio 00:11:09
sea negativa, no me gusta 00:11:11
Pues me voy a hacer una clase excepción 00:11:12
Para esa situación que no me gusta 00:11:14
Vamos a hacerlo, pues venga, primer paso 00:11:16
Vamos a hacernos una clase excepción 00:11:18
Para esa situación que no nos gusta 00:11:21
Pues nos hacemos una clase 00:11:22
Precio negativo 00:11:24
Ponemos el nombre de la clase 00:11:28
Que nos dé la gana, suelen ser muy largas 00:11:30
Por convenio siempre acaban 00:11:31
Con excepción, para que se vea 00:11:34
Claro que son clases que reflejan 00:11:36
Una situación de excepción que no nos gusta 00:11:38
Pues precio negativo, excepción 00:11:39
Por ejemplo, la podemos llamar 00:11:41
Extens, excepción. 00:11:43
Muy bien, vale. 00:11:44
Entonces, precio negativo, excepción, 00:11:46
para que incorpore todo lo que ya tiene excepción en sí, 00:11:49
que es muy poco en realidad. 00:11:56
Ahora vamos a ver qué es lo importante que tiene. 00:12:00
Extens, pues la agredar de excepción. 00:12:02
Vale, entonces, precio negativo, excepción, 00:12:15
a heredar de exception 00:12:19
ya tiene dentro 00:12:20
un comportamiento 00:12:22
porque exception implementa 00:12:25
a su vez una interfaz 00:12:27
con lo cual ya tiene dentro un comportamiento 00:12:28
y tiene dentro además 00:12:31
entre otras cosas una variable 00:12:33
muy mona que se llama message 00:12:35
que es el mensajito 00:12:37
de error asociado a eso 00:12:39
¿vale? entonces exception 00:12:40
si uno entra dentro de exception 00:12:43
pues ve que 00:12:44
exception 00:12:48
ya hereda 00:12:49
de una cosa que se llama 00:12:51
throwable 00:12:53
throwable, acabado en able 00:12:54
es decir 00:12:57
significa que si yo heredo de exception 00:12:58
puedo ser lanzada 00:13:01
puedo ser lanzada como excepción 00:13:02
si yo no heredo de exception 00:13:05
yo no puedo ser lanzada como excepción 00:13:07
porque la que me da la capacidad 00:13:09
de ser lanzada como excepción 00:13:11
desde un código a otro 00:13:13
es esta 00:13:15
clase abstracta de ahí 00:13:16
Esa clase de ahí 00:13:18
No os trate, vale, esa clase 00:13:19
Quedaría más bonito, la verdad 00:13:21
Pero bueno, no pregunto 00:13:24
Seguramente habrá una respuesta, pero no me he preguntado nunca 00:13:25
Porque eso no es una interfaz 00:13:28
Pero el nombre es de interfaz de toda la vida 00:13:29
Throwable, vale, la sabe 00:13:31
Lo que pasa es que, vale, tendrá más cosas 00:13:33
Tendrá alguna propiedad o algo 00:13:35
Y por eso, vale 00:13:37
De hecho, throwable es la que tiene el message 00:13:38
Por lo que veo 00:13:41
Throwable 00:13:42
Que está aquí 00:13:46
no, no pasa nada 00:13:47
vale 00:13:51
probable 00:13:52
es una clase porque además de 00:13:54
tener el comportamiento de ser lanzaba 00:13:57
tiene 00:13:59
una propiedad 00:14:00
que es una propiedad 00:14:03
que es el mensajito 00:14:05
de error que a mí me dé la gana ponerle a esa excepción 00:14:07
el mensajito de error que me decimos 00:14:09
tío, no me inventas un precio negativo 00:14:10
vale 00:14:13
pues entonces, desde el momento en que le das excepción 00:14:14
tienes ya una variable para tu 00:14:17
configurarla con el mensaje que te dé la gana 00:14:19
y además tienes la capacidad de que 00:14:21
alguien te lance, pues no hay más que hacer 00:14:23
como mucho 00:14:25
darle ese 00:14:27
ese mensajito 00:14:28
es lo más que hacemos, no hay que hacer más 00:14:30
entonces el mensajito lo podemos en el propio constructor 00:14:32
que es la forma de hacerlo 00:14:35
ya inicializarlo 00:14:37
precio negativo exception 00:14:39
en el constructor 00:14:41
A ver, que yo no soy tan vaga como tú 00:14:43
Vale 00:14:53
Y el punto y coma que se me olvida 00:14:58
Vale, pues entonces 00:15:15
Este constructor 00:15:17
Llama al constructor de la superclase 00:15:18
Y el constructor de la superclase 00:15:21
Tiene un constructor 00:15:24
tiene uno sin parámetros 00:15:25
pero tiene otro con parámetros al que si tú le pasas 00:15:27
un string lo utiliza 00:15:29
para inicializar la variable 00:15:31
con lo cual de esta manera sencilla 00:15:32
pues ya está, la variable 00:15:34
mensaje que tiene esta dentro 00:15:36
la he inicializado con este valor 00:15:38
luego ya he conseguido una clase 00:15:41
cuyos objetos 00:15:43
podrán ser lanzados porque heredan 00:15:45
de exception que a su vez hereda de throwable 00:15:47
y además tiene una variable 00:15:49
mensaje dentro con ese dato 00:15:51
bueno pues hala estupendo 00:15:52
Ahora, ese es el primer paso, yo he identificado que aquí, yo que soy la que ofrezco esta clase pedido, he identificado que aquí hay un uso que van a hacer de mí que no me gusta, que es que me metan un precio negativo, ese no me gusta. 00:15:55
vale, bueno pues 00:16:11
en qué método 00:16:13
en qué método voy a 00:16:14
detectar yo si eso ha ocurrido 00:16:17
y lo voy a avisar, en este caso 00:16:19
en el constructor, en el constructor 00:16:21
que es cuando me instancian 00:16:23
yo digo, eh ojo, cuidadín 00:16:25
ojo 00:16:28
que si precio es negativo 00:16:29
ojo 00:16:31
si precio es menor que cero 00:16:34
yo no quiero hacer esto 00:16:38
y devolver el objeto 00:16:40
pedido para que se guarde en la variable 00:16:42
no quiero, dime 00:16:45
eso sería curioso hablarlo con el usuario 00:16:46
el que me ha pedido la aplicación a ver si 00:16:53
admite cosas gratis o no 00:16:54
pero sí, vale 00:16:56
bueno, vamos a dejarlo 00:16:57
este no regala nada 00:17:02
vale, pues entonces 00:17:04
él hace lo que le han pedido 00:17:06
bueno, él quiere regalar cosas 00:17:13
él no quiere regalar cosas gratis 00:17:15
venga, ya está 00:17:17
no, esto 00:17:21
vale, entonces 00:17:23
primera cosa que hemos hecho, identificar 00:17:25
que hay algo que no nos gusta y hemos hecho una clase 00:17:27
para ello, segunda cosa que hemos 00:17:29
hecho, identificar 00:17:31
en el código que yo estoy ofreciendo 00:17:33
cuando 00:17:35
quiero que salte ese error 00:17:36
en qué momento quiero que salte 00:17:39
pues podría ser en un método que hace algo 00:17:41
con el precio, podría ser donde fuera 00:17:43
en este caso, por ejemplo 00:17:45
pues en el momento de crear el pedido 00:17:46
yo en el momento de crear el pedido lo siento 00:17:48
pero no quiero que el constructor 00:17:50
continúe ni haga sus cosas 00:17:52
ni me devuelva luego el objeto como hacen los constructores 00:17:54
no quiero si el precio es menor o igual que cero 00:17:57
con lo cual identifico que ese es el punto 00:17:59
en el que quiero y en ese momento 00:18:01
hago esta sentencia 00:18:03
que es la que dice E aquí 00:18:05
en lugar de continuar con el 00:18:07
constructor y hacer lo que toque 00:18:09
no, voy a crearte 00:18:10
este objeto excepción porque he detectado esta cosa 00:18:13
tan fea y te lo lanza 00:18:15
pues vamos a crearlo 00:18:17
new pedido 00:18:18
negativo 00:18:21
exceptio 00:18:23
ala 00:18:25
y desde el momento en que hay un throw 00:18:30
ya no se hace nada más 00:18:32
de lo que hay abajo, ni se hace nada 00:18:34
porque esto ya, el método 00:18:36
se ha parado y se niega a seguir 00:18:39
el método se para aquí 00:18:41
se niega a seguir, es como 00:18:43
si fuera un return 00:18:45
pero es un return acompañado de 00:18:45
toma, toma este objeto 00:18:48
a ver qué haces con él, algo tienes que hacer, no te puedes callar 00:18:50
algo tienes que hacer 00:18:52
¿dónde pones super? 00:18:53
hombre, si quieres apoyarte en el constructor 00:19:00
de la superclase para usarlo 00:19:02
para inicializar la variable, sí 00:19:04
pero la podrías inicializar esa variable 00:19:05
haciendo a ella directamente, si está con 00:19:08
protected, que estará, supongo, si no 00:19:10
este es el uso más 00:19:12
cómodo, habitual, vale 00:19:14
entonces 00:19:16
ya está, el programa 00:19:17
aquí se va a parar, me niego 00:19:20
y encima te lanzo esta cosa 00:19:22
¿vale? ¿por qué no sale en rojo? 00:19:24
porque desde el momento en que un método 00:19:26
tiene un throw 00:19:28
hay que avisar por código 00:19:29
de que ese método puede que lance 00:19:32
una excepción aquí, poniendo throws 00:19:34
¿vale? de hecho 00:19:36
te ofrece la solución así 00:19:38
¿vale? 00:19:40
create class 00:19:43
ah, no 00:19:44
es que he puesto mal el nombre de la clase 00:19:46
precio, vale 00:19:48
Ahora ya sí 00:19:49
Precio negativo lo he puesto bien 00:19:51
Ahora ya me sale 00:19:53
Ahora ya me ofrece 00:19:56
Lo que yo tengo que hacer 00:19:57
Desde el momento en que un método 00:19:59
Tiene un throw 00:20:01
Y ahí puede que se pare 00:20:02
Y se acabó y te doy el objeto 00:20:04
Hay que avisar por código 00:20:07
En cualquiera 00:20:09
El constructor no pasa nada 00:20:12
Va a seguir siendo constructor 00:20:14
Lo que no puedes es cambiar el resto de su cabeza 00:20:15
el resto, o sea, no puedes poner aquí delante nada 00:20:17
pero el 3 lo puedes poner 00:20:20
y sigue siendo un constructor válido 00:20:22
vale 00:20:24
entonces ahora ya que pasa 00:20:25
ahora ya nosotros, nuestra parte 00:20:27
como desarrolladores de la clase 00:20:30
pedido que ya se la entregamos a los demás, ya ha terminado 00:20:32
que hemos hecho, lo siento, pero 00:20:34
si haces eso 00:20:35
te lanzo ese objeto, el que me use 00:20:37
que vea, vale, pues ahora yo 00:20:40
ahora ya viene el otro, que es el que está usando 00:20:41
esta clase 00:20:44
y va a leer el precio 00:20:44
y cuando va a instanciarlo 00:20:47
dice, uh, que me dice 00:20:48
el compilador, me dice, cuidado 00:20:50
que esto puede 00:20:52
que te lance una excepción 00:20:54
de precio negativo 00:20:56
entonces, eso ya es un 00:20:57
aviso de que 00:21:00
esa es una situación de error, que no le gusta a tu clase 00:21:02
pedido 00:21:04
tu clase pedido no le gusta que hagas eso 00:21:05
y te va a lanzar un objeto 00:21:08
si pasa eso 00:21:10
y te obliga 00:21:11
a que tú te pronuncies 00:21:14
y digas, vale, pues 00:21:16
tengo que hacer algo, entonces 00:21:18
tienes dos alternativas 00:21:20
ignorar 00:21:22
esa excepción y pasar de ella 00:21:25
o lo que es lo mismo 00:21:26
propagarla hacia arriba 00:21:28
que es la 00:21:30
primera que te ofrece, que es 00:21:32
vale, pues 00:21:34
mi método main 00:21:36
que la propague 00:21:37
hacia arriba, pero 00:21:40
cuando yo digo, oye, mi método main 00:21:42
que la propague, entonces, si 00:21:44
esa excepción aparece, el método 00:21:46
se para. El main se va a parar. 00:21:48
Pero es lo más cómodo 00:21:51
de programar. Digo, 00:21:52
ah, vale, me avisas de 00:21:54
que como meta un precio negativo, 00:21:56
aquí me llega un objeto de excepción. 00:21:59
Se lo paso 00:22:01
al main, que el main lo lance hacia arriba, 00:22:02
pero eso sí, el programa va 00:22:05
a parar. Es lo más cómodo. 00:22:06
¿Pero en el main tienes que poner el throw? 00:22:08
Tienes que ponerlo. Ahora me dirás, 00:22:10
¿Y por qué no lo pones en otras? 00:22:12
Siguiente fase 00:22:14
Siguiente fase, ¿vale? 00:22:15
Que tu curiosidad va muy rápido 00:22:18
¿Vale? 00:22:19
Dime 00:22:23
Sí, porque 00:22:24
Cuando lo que va a hacer va a llamar 00:22:29
Al print extract trace 00:22:31
Que el print extract trace te incluye el mensaje y luego lo para 00:22:32
Entonces, si nosotros ejecutamos esto 00:22:35
Descripción bolis 00:22:38
Le voy a meter 00:22:40
Los bolis me van a costar 98 00:22:41
No, no te dejo 00:22:44
Te estoy prohibiendo 00:22:47
Míralo, no me des precios negativos 00:22:49
Por Dios santo bendito 00:22:52
El print extract race 00:22:53
Te incluye dentro del message 00:22:56
Vale, entonces 00:22:58
Que sí que lo ve 00:23:10
Pues la interfaz te peta 00:23:15
Si tú como dejes ahí el print extract trace 00:23:17
Y tengas una consola abierta 00:23:19
Lo ves en la consola 00:23:21
Si no ve la consola, claro 00:23:22
Pero se le ha parado el programa 00:23:30
Eso sí 00:23:33
Claro, entonces 00:23:35
la idea es no trabajar así, hombre 00:23:38
si desde un código 00:23:40
me están avisando, que ojo 00:23:41
que te voy a lanzar excepción porque esto es gravísimo 00:23:44
si alguien lanza una excepción 00:23:46
es porque asume que eso es muy grave 00:23:48
pues hombre, no pases de su cara 00:23:50
está bastante feo 00:23:52
y aparte vas a hacer que tu programa 00:23:54
no pases 00:23:56
tú llamas a Brian 00:23:58
y Brian te hace aquí un try catch 00:24:01
cojonudo 00:24:04
esto es que en el otro caso 00:24:05
tú como desarrollador que cómodo 00:24:11
no tengo que escribir nada 00:24:13
pero luego tu programa cuando te mete uno negativo 00:24:14
al tío se le para el programa 00:24:17
vale como justo castigo por querer 00:24:19
hacerle una transferencia vale pero 00:24:21
mejor le dices que no 00:24:23
y que tu programa siga 00:24:25
vale pues la otra opción capturable 00:24:26
ya sabemos cuál es 00:24:29
pues tú la capturas 00:24:30
Y aquí en la captura 00:24:32
Pues le dices lo que sea 00:24:35
Como me has dado 00:24:37
Negativo 00:24:40
Te cobro 1000 00:24:42
Y ya está 00:24:44
Te cobro 1000 00:24:46
Y tú justo 00:24:47
Y ahora te haces 00:24:49
Esto de aquí 00:24:51
Te lo haces a precio 1000 00:24:53
¿Vale? 00:24:56
¿Puedes pasarle un número ahí? 00:25:09
Sí, sí, le puedo pasar un número ahí. 00:25:15
Ah. 00:25:23
Claro, porque es que le estoy llamando 00:25:28
otra vez. Entonces, 00:25:29
la manera de hacerlo, 00:25:31
claro, es que con el método de control 00:25:34
es muy retorcido. Pues, 00:25:35
podríamos hacer 00:25:37
como me has dado negativo, 00:25:38
te pongo precio mil 00:25:43
pero P ya está 00:25:47
declarada 00:25:52
entonces tiene que poner P.precio 00:25:53
ya pero 00:25:55
tiene que estar instanciada 00:25:58
es nul ahora mismo 00:25:59
no se ha llegado a instanciar 00:26:01
no no no 00:26:03
que no 00:26:05
a ver la excepción ha saltado aquí 00:26:07
con lo cual el objeto no se ha llegado 00:26:10
a crear. P es nul. Aquí P es nul. 00:26:12
Claro, eso es 00:26:17
lo que iba a hacer. Lo que pasa es que necesito... 00:26:18
Al meterlo en el constructor 00:26:20
es más retorcido. 00:26:21
A ver, nos podemos poner 00:26:24
aquí un constructor sin parámetros. 00:26:26
Uy, qué hago. 00:26:32
Perdón. 00:26:33
Te pongo muy nerviosa, 00:26:35
¿verdad? Haciendo las cosas así. 00:26:37
Muy nervioso. 00:26:39
No te preocupes, no me molesta. 00:26:41
Se lo confunde a todo el mundo 00:26:46
Es que no distingo géneros 00:26:53
Ni la derecha ni la izquierda 00:26:55
Venga, pues a ver 00:26:56
P set descripción 00:27:00
Igual a la descripción 00:27:01
Y P punto 00:27:04
Set precio igual a mil 00:27:06
Ala 00:27:08
Ala, ya estaría 00:27:10
Para que no te diga, podría no estar inicializado 00:27:25
porque se inicializa dentro del 00:27:27
catch. A ver, si tú no le pones 00:27:29
nada aquí, ¿vale? 00:27:31
Bueno, vale. 00:27:34
Como es un objeto 00:27:35
el toString 00:27:37
que raro que no te 00:27:39
no sé. Pero a mí me gusta más así 00:27:43
porque normalmente siempre 00:27:45
se inicializa la... 00:27:47
Vale. Pero bueno, da igual. 00:27:49
Vale, pues ya está. Pues entonces 00:27:51
ahora ya efectivamente 00:27:53
si ejecutamos esto 00:27:55
y al tío le 00:27:56
intentamos colar el negativo 00:27:59
pues nada, te hace un pedido de mil 00:28:01
y ya está 00:28:04
entonces, esto es una 00:28:04
esto como veis es una herramienta más 00:28:07
simplemente, es una herramienta 00:28:10
más que yo puedo usar 00:28:12
en mis códigos para avisar 00:28:14
de que algo no está bien 00:28:16
entonces es un avisar 00:28:18
muy radical porque además 00:28:20
el método ya ni siquiera continúa 00:28:22
el método ni siquiera continúa 00:28:24
pero es un avisar 00:28:26
que le obliga al otro 00:28:28
a hacer algo con ello 00:28:30
es un avisar mejor 00:28:31
porque en este método es que no podemos avisar 00:28:33
con el valor de retorno porque es un constructor 00:28:36
pero imaginaos que tenemos un método 00:28:37
modificar precio, por ejemplo 00:28:40
entonces en el modificar precio 00:28:42
ese le podríamos poner 00:28:44
un valor de retorno 00:28:46
¿por qué las excepciones de la JRE 00:28:47
no te piden que tenga el programa? 00:28:50
sí, eso ahora mismito lo 00:28:52
sí, ahora tenemos tiempo 00:28:54
sí, sí, sí, ahora mismo lo completamos 00:28:56
¿vale? ahora mismo 00:28:57
entonces, como recopilación 00:28:59
esto es una forma radical 00:29:02
pero mejor forma de que un método avise 00:29:03
de que han pasado cosas, repito 00:29:06
aquí es que el constructor es un poco 00:29:07
especial porque no puede avisar de otra 00:29:10
manera además, porque no tiene valor de retorno 00:29:12
más allá que el propio objeto, pero imaginaos 00:29:13
que tenemos un método cualquiera 00:29:16
pues 00:29:18
yo que sé 00:29:19
modificar pedido 00:29:20
entonces 00:29:31
le pasamos el objeto 00:29:32
pedido 00:29:34
y le volvemos a poner el precio 00:29:36
el precio y aquí 00:29:38
p.setPrecio 00:29:51
igual a pre, vale 00:29:54
entonces 00:29:55
y el escáner 00:29:57
vale, pues aquí el desarrollador que está haciendo 00:30:00
este método 00:30:18
a ver 00:30:19
que he hecho mal 00:30:23
el retorno, claro 00:30:24
vale, el desarrollador 00:30:25
que está haciendo este método 00:30:31
pues dice, vale, hay una cosa 00:30:32
que puede que no me guste 00:30:35
que es que me metan un precio negativo 00:30:36
entonces de alguna manera 00:30:38
tengo yo que avisar, bueno pues 00:30:40
puede avisar con el valor de retorno 00:30:42
y ya no podría hacer esto 00:30:44
y decir 00:30:47
si precio es menor que 0 00:30:47
pues retún 00:30:52
falsi, que no me vea rosa 00:30:54
que no me vea rosa 00:30:55
que sí 00:30:57
que tiene sentido salir por 00:31:00
en varias zonas del código feo 00:31:02
pero bueno 00:31:04
vale 00:31:04
y si no 00:31:14
pues entonces ya le pongo el precio 00:31:17
y retún true 00:31:19
Vale, entonces este método al menos algo ha hecho, que es avisar de si el precio es negativo o no y en el caso de que sea negativo no lo ha modificado y te avisa. 00:31:20
Entonces, el desarrollador que es bueno y lo hace bien, pues aquí lo comenta y te dice, oye, true, si se pudo modificar porque era positivo, false, si no se modificó porque era negativo. 00:31:32
y este es el método ya muy bien hecho 00:31:58
entonces ahora 00:32:01
el usuario que usa este método 00:32:02
por ejemplo 00:32:05
en nuestro main 00:32:07
vamos a modificar el pedido 00:32:08
a ver que tontería estoy haciendo 00:32:11
le estoy pasando a pedido el parámetro 00:32:21
cuando es el que llama el método 00:32:23
que tontería es el dis 00:32:24
dis.setPrecio 00:32:27
o setPrecio 00:32:31
o precios sin más, o sea, estoy haciendo el tonto 00:32:32
pero de mala manera 00:32:35
precio igual a pre 00:32:36
y ya está, que tontería, si estoy en la clase pedido 00:32:38
vale 00:32:41
bueno, pues entonces 00:32:42
el que llama ahora al método 00:32:44
este pedido, le vamos a modificar el precio 00:32:46
pues p. 00:32:48
tengo aquí 00:32:51
modificar pedido 00:32:53
y veis el eclipse que listo es 00:32:56
os pone aquí a la derecha lo que hayáis puesto 00:32:58
en el comentario de arriba 00:33:00
porque está puesto 00:33:01
como formato javadoc 00:33:05
que es empezando así 00:33:06
vale, claro 00:33:07
vale, entonces pues vale 00:33:09
esto al menos 00:33:12
al menos el desarrollador 00:33:13
te ofrece aquí 00:33:16
te dice, ah, espérate 00:33:18
true se puede modificar, false si no 00:33:20
pero tú puedes pasar de ese valor 00:33:22
de retorno de comprobación 00:33:24
y ya está 00:33:26
entonces es una forma de avisar 00:33:29
un poquito más suave 00:33:32
tú avisas con el valor de retorno 00:33:34
y el desarrollador pues ya decide 00:33:36
si usa ese valor de retorno, si no lo usa 00:33:38
es más suave 00:33:41
y ya, y no solo que es 00:33:42
más suave, sino que a veces a lo mejor 00:33:44
ni siquiera puedes avisar de si algo 00:33:46
ha ido bien o mal con el valor de retorno 00:33:48
porque puede que el propio método, aunque este no sea el caso 00:33:50
su resultado sea devolverte 00:33:53
algo, entonces el valor de retorno 00:33:55
ya está empleado en devolverte 00:33:57
un resultado, con lo cual no puedes usarlo 00:33:58
como aviso 00:34:01
para los métodos void conviene mucho usar los booleans 00:34:02
claro, para los métodos void siempre habría 00:34:04
que devolver un boolean 00:34:06
que verifique si se ejecutó correctamente 00:34:08
o si no 00:34:11
la mayoría de hecho de las librerías lo tienen 00:34:11
claro, pero 00:34:14
los métodos que ya usa el valor de retorno 00:34:16
como resultado se quedan sin poder 00:34:18
avisar de si algo ha ido bien o mal 00:34:20
se quedan sin poder avisar 00:34:22
entonces ahí sí que la forma buena 00:34:23
de avisar es con una excepción 00:34:26
entonces aquí 00:34:28
en lugar de avisar con el Boolean 00:34:29
pues podríamos hacer la versión 2 00:34:32
de este método 00:34:34
que es más guay 00:34:35
bueno, depende de lo que te importe 00:34:37
a ti el precio negativo 00:34:40
bueno, hay proyectos 00:34:41
que tienen, efectivamente 00:34:46
un montón de paquetes cada uno con sus cosas 00:34:48
y uno de ellos es el paquete Exception 00:34:50
con las tropecientas mil que tú has identificado 00:34:52
y las vas lanzando donde interesa 00:34:54
entonces el modificar pedido 00:34:56
versión 2 00:34:58
este no devuelve nada porque el valor de retorno 00:34:59
no lo necesitamos 00:35:02
y en lugar de hacer return false 00:35:04
pues lo que hace es esto 00:35:06
throw new 00:35:08
throw new esto de aquí 00:35:10
vale 00:35:15
con lo cual 00:35:25
esto ya no es feo porque no es un return 00:35:29
es que esto ya es el propio return 00:35:32
bueno más que importarla avisar que este 00:35:36
Si el precio es negativo 00:35:38
Yo lanzo la excepción 00:35:41
Es un aviso mucho más radical 00:35:42
Porque el otro tiene que decir 00:35:43
Salvo con la cosita esta 00:35:45
Que veo que estás nervioso 00:35:48
Entonces de otra forma 00:35:50
Que no ha saltado el throw 00:35:53
El código sigue y actualiza el precio 00:35:55
Y ya está 00:35:58
Como este método puede que lance throw 00:35:58
Pues entonces 00:36:02
Hay que avisar poniéndole el throw 00:36:03
vale, se avisa 00:36:06
poniéndole el flush 00:36:09
vale, ahora mi main 00:36:09
yo ahora quiero cambiar el precio 00:36:12
de este 00:36:15
p.modificar 00:36:15
pedido 00:36:18
pues es que ya directamente aquí 00:36:19
ya en tiempo de escritura de código ya me está 00:36:22
diciendo, ¿qué pasa? 00:36:24
y si te dan 00:36:27
uno negativo, ¿qué vas a hacer? 00:36:28
no me ignores 00:36:30
¿qué haces? 00:36:32
bueno, aún así le podemos ignorar 00:36:33
como ya sabemos, aún así podemos ignorarle 00:36:36
y decir 00:36:38
que se pare el programa, si es negativo que se pare 00:36:38
o lo capturamos, ¿vale? 00:36:42
lo que ya sabemos 00:36:44
o esto 00:36:44
o lo capturamos 00:36:46
lo que sea que queramos hacer 00:36:50
¿vale? luego esta 00:36:53
bueno, es otra forma, repito 00:36:55
de avisar de que algo está mal 00:36:57
avisas con una excepción tuya 00:36:59
y el otro tiene que pronunciarse 00:37:01
y ahora ya sí que lo último 00:37:02
último, último, que es lo que ha preguntado 00:37:06
él, pero os lo iba a contar igual aunque no lo había preguntado 00:37:08
así que no hace falta que le deis ahora 00:37:10
collejas en el patio porque es que 00:37:12
lo iba a contar igualmente 00:37:14
ahora es cuando vosotros 00:37:15
preguntáis 00:37:18
vosotros, los demás 00:37:20
jolines, pero si hemos estado 00:37:21
usando el next in, el next double 00:37:23
todo el rato, que puede lanzar excepciones 00:37:26
y a mí no me han obligado a decir qué pasa 00:37:27
ni me han obligado a poner un cross 00:37:29
ni me han obligado a nada 00:37:31
vale, es que hay un 00:37:32
dentro de exception, que es la superclase 00:37:35
hay una subclase 00:37:37
que son las excepciones 00:37:40
sobre las que no es obligado 00:37:42
pronunciarse 00:37:44
porque es que salen tanto en tiempo de ejecución 00:37:44
como la de saltarte una ray 00:37:48
la de que si estuvieras 00:37:50
todo el rato, no te puedo traer cacho throws 00:37:51
entonces, y esas excepciones 00:37:53
se llaman run time exception 00:37:56
vale 00:37:58
entonces 00:37:59
esta excepción 00:38:00
de aquí, la que yo 00:38:03
ajusto, claro 00:38:05
si yo la heredo como excepción 00:38:06
es súper grave, gravísima 00:38:08
y el usuario que está usando 00:38:10
mi clase que tiene el throw 00:38:13
tiene que decidir qué hace 00:38:15
pero si esta es una excepción de las que 00:38:16
se llaman de que puedes ir en tiempo de 00:38:19
ejecución en cualquier momento y que no voy a estar ahí 00:38:21
ya desde tiempo de desarrollo 00:38:23
pronunciándome, sino que me importan 00:38:25
solo en tiempo de ejecución, solo aparecen 00:38:27
ahí y solo son visibles ahí 00:38:29
pues lo puedo decir, venga 00:38:30
pues que sea 00:38:33
runtime exception 00:38:35
entonces si heredan 00:38:36
de runtime exception 00:38:39
estas yo puedo 00:38:40
en tiempo de desarrollo ignorarlas 00:38:43
me van a aparecer en tiempo 00:38:45
de ejecución 00:38:47
y me aparecerán y cuando yo las vea 00:38:49
pues tendré que ver que hago, pero no las tengo 00:38:51
que capturar, no tengo que hacer nada 00:38:53
entonces si esta heredara de runtime exception 00:38:54
pues aquí efectivamente 00:38:57
yo podría 00:38:59
haber llamado a modificar 00:39:01
pedido v2 00:39:04
y ni me obliga a capturarla ni a propagarla 00:39:05
ni nada, pero me va a salir 00:39:08
si luego meto un número negativo me va a salir 00:39:09
ah, perdona, que es que 00:39:11
ah, vale, precio, ahora es, ahora, ahora 00:39:19
ahora, ahora, ahora, menos 87 00:39:21
pon otro menos 87 00:39:24
que creo que has metido a la descripción 00:39:29
aunque te haya pedido 00:39:31
No, no puede ser 00:39:32
O sea, me ha mostrado esto 00:39:34
Modificar pedido 00:39:36
Precio 00:39:39
Si precio, que es 00:39:40
Ah, pre, vale, vale 00:39:43
Si precio es negativo, no pre 00:39:45
Si pre es negativo, vale 00:39:47
Sí, bueno, esto 00:39:50
Me lo pone a 1000 00:39:53
Vale, me lo ha puesto a 1000, me lo vuelve a pedir 00:39:56
Menos 9 00:39:58
Y sale la excepción, claro 00:39:59
Pero esta es una excepción 00:40:01
Runtime, o sea, me ha salido aquí en tiempo de ejecución 00:40:03
Pero en tiempo de desarrollo 00:40:05
Yo no he hecho nada 00:40:07
¿Vale? 00:40:09
Y claro, muchas de esas, pues, son muy pesadas 00:40:11
Si las estuviéramos facturando todo el rato, son muy pesadas 00:40:13
A ver 00:40:15
Claro, las que tú haces 00:40:23
Las que tú haces en tus propios códigos 00:40:26
Para avisar a los demás 00:40:28
las vas a hacer exception, porque las has hecho 00:40:29
para eso, pero luego hay muchas 00:40:32
otras que 00:40:34
por naturaleza deberían 00:40:35
parar el programa, como la de salirte 00:40:38
de una RAI, porque deberían pararlo 00:40:40
porque si no las cosas van a ir mal 00:40:41
pero no puedes estar obligando a capturarlas todo el rato 00:40:43
entonces es como un término medio 00:40:46
oye, el programa lo va a tener que parar, porque si sigue 00:40:47
la liamos, pero no te voy a estar 00:40:50
obligando a todo el rato a decir que hacer 00:40:52
porque serían demasiadas situaciones 00:40:54
¿vale? 00:40:56
Entonces 00:40:57
Ya está, pues esto 00:40:59
Lo ponemos aquí 00:41:02
Solamente como comentario 00:41:06
Y ya está 00:41:12
Si heredara de 00:41:13
Runtime exception 00:41:16
No sería obligatorio 00:41:19
Tratar 00:41:23
¡Hala! Ya está 00:41:24
No vamos a contar 00:41:35
nada más decepciones. 00:41:39
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:
5
Fecha:
7 de marzo de 2025 - 17:43
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
41′ 41″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
190.83 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid