027.- Curso de Java. Manejar errores y excepciones.

00:51:51
https://www.youtube.com/watch?v=M1sS9Zkm5is

Resumo

TLDREl video explica las excepciones en Java, que son formas de manejar errores que pueden surgir durante la ejecución de un programa. Se abordan conceptos como el manejo de excepciones con bloques 'try-catch', la creación de excepciones personalizadas y el uso de las palabras clave 'throw', 'throws', y 'finally'. Además, se ofrecen ejemplos que muestran cómo manejar errores comunes, como intentar acceder a un elemento fuera de los límites de un array o convertir entradas no numéricas. Se concluye discutiendo cómo lanzar excepciones y la importancia de la gestión adecuada de errores en la programación Java.

Conclusões

  • 🐞 Las excepciones son errores en tiempo de ejecución que pueden ser manejados.
  • 💻 Utilizar bloques 'try-catch' permite capturar y manejar excepciones.
  • 🔄 La palabra clave 'throw' se usa para lanzar excepciones intencionalmente.
  • 🚫 La palabra clave 'throws' indica que un método puede lanzar excepciones.
  • 🔍 Los bloques 'finally' aseguran la ejecución de código de limpieza.
  • 📜 Las excepciones de Java tienen una jerarquía estructurada.
  • 📥 Se pueden crear excepciones personalizadas extendiendo la clase 'Exception'.
  • 👨‍💻 Es importante manejar excepciones para mejorar la robustez del software.
  • ⚠️ Manejar errores de usuario puede evitar fallos inesperados en el programa.
  • 📊 Ejemplos prácticos ayudan a entender cómo manejar excepciones en situaciones comunes.

Linha do tempo

  • 00:00:00 - 00:05:00

    Este video tutorial aborda las excepciones en Java, que son errores comunes en la programación y cómo manejarlos. Se explican cuatro aspectos clave: manejar excepciones, ignorarlas, generar excepciones de manera intencionada, y crear excepciones personalizadas.

  • 00:05:00 - 00:10:00

    Las excepciones en Java se introducen como un conjunto de clases diseñadas para gestionar errores, que se clasifican en dos tipos: Error y Exception. La clase Throwable es la superclase de todas las excepciones en Java, de donde derivan otros tipos como RuntimeException.

  • 00:10:00 - 00:15:00

    Las excepciones se dividen en errores fatales, que son difíciles de controlar, y situaciones excepcionales que pueden manejarse mediante el uso de clases de excepciones. El tutorial también menciona la técnica de manejo de errores con estructuras condicionales como condicionales y switch-case.

  • 00:15:00 - 00:20:00

    Se introducen las palabras clave 'throw' para lanzar excepciones y 'catch' para capturarlas. Se discute la jerarquía de las clases de excepciones y se destaca la importancia de manejar adecuadamente estas excepciones para no interrumpir la ejecución del programa.

  • 00:20:00 - 00:25:00

    Un error común es tratar de acceder a un índice fuera de un array, lo que genera una excepción al ejecutar el programa a pesar de que compile correctamente. Se menciona que estos errores son bastante descritos explícitamente en los mensajes de error generados.

  • 00:25:00 - 00:30:00

    El video proporciona un ejemplo de un programa que suma argumentos pasados desde la línea de comandos. Se muestra cómo manejar la conversión de entradas que podrían no ser válidas, como cuando el usuario introduce caracteres no numéricos, utilizando bloques try-catch.

  • 00:30:00 - 00:35:00

    Se ilustra un bloque try-catch en un programa que suma números decimales, mostrando cómo el programa puede manejar excepciones como NumberFormatException. Se presentan pasos prácticos sobre cómo configurar y modificar el código para manejar excepciones correctamente.

  • 00:35:00 - 00:40:00

    Se exploran otras excepciones que podrían surgir al dividir números, centrándose en ArithmeticException al intentar dividir por cero y cómo el bloque try-catch maneja ambos tipos de errores.

  • 00:40:00 - 00:45:00

    El bloque finalmente se utiliza para asegurarse de que ciertas declaraciones se ejecuten independientemente de si ocurrió o no una excepción. Esto es útil para asegurar que las conexiones a archivos se cierren adecuadamente después de su uso.

  • 00:45:00 - 00:51:51

    Finalmente, se analiza cómo lanzar excepciones en métodos, utilizando 'throws' para indicar que un método puede lanzar excepciones. Se presentan ejemplos prácticos de cómo crear clases que utilicen y gestionen excepciones adecuadamente.

Mostrar mais

Mapa mental

Vídeo de perguntas e respostas

  • ¿Qué son las excepciones en Java?

    Las excepciones en Java son errores que ocurren durante la ejecución de un programa y que pueden ser manejados para evitar que el programa falle.

  • ¿Cómo se puede manejar una excepción?

    Se puede manejar una excepción utilizando bloques 'try' y 'catch' que permiten ejecutar código y capturar errores.

  • ¿Qué palabras clave se utilizan para trabajar con excepciones en Java?

    Las palabras clave son 'try', 'catch', 'finally', 'throw' y 'throws'.

  • ¿Qué es la palabra clave 'throw'?

    'throw' se utiliza para lanzar explícitamente una excepción cuando se detecta un error.

  • ¿Cómo se pueden crear excepciones personalizadas?

    Se pueden crear excepciones personalizadas creando una nueva clase que extienda de la clase 'Exception'.

  • ¿Qué es un bloque 'finally'?

    El bloque 'finally' se ejecuta al final de un bloque 'try' y se utiliza para realizar operaciones de limpieza, independientemente de si ocurrió una excepción.

  • ¿Qué tipo de errores se pueden presentar en un programa Java?

    Pueden presentarse errores debido a typos, incompatibilidad de tipos de datos, entre otros.

  • ¿Qué es un 'catch'?

    Un 'catch' es un bloque que captura las excepciones lanzadas dentro de un bloque 'try'.

  • ¿Cuál es la diferencia entre 'throws' y 'throw'?

    'throws' se utiliza en la declaración de un método para indicar que puede lanzar una excepción, mientras que 'throw' se usa para lanzar una excepción en un punto específico del código.

  • ¿Cómo se puede producir una excepción intencionalmente?

    Se puede lanzar una excepción intencionalmente utilizando la palabra clave 'throw' seguido de una instancia de la excepción.

Ver mais resumos de vídeos

Obtenha acesso instantâneo a resumos gratuitos de vídeos do YouTube com tecnologia de IA!
Legendas
es
Rolagem automática:
  • 00:00:00
    [Música]
  • 00:00:08
    [Música]
  • 00:00:18
    [Música]
  • 00:00:42
    eh qué tal video tutorial número 27 del
  • 00:00:45
    curso de Java en el que vamos a ver las
  • 00:00:48
    denominadas excepciones las
  • 00:00:51
    exceptions que es el modo de tratar los
  • 00:00:53
    errores los bgs los typos que impiden
  • 00:00:57
    que un programa se ejecute correctamente
  • 00:00:59
    en Java son una parte natural del
  • 00:01:02
    proceso de desarrollo de software Aunque
  • 00:01:04
    tan natural como
  • 00:01:08
    desagradable en resumen lo que vamos a
  • 00:01:10
    ver en este víde tutorial es en primer
  • 00:01:13
    lugar Cómo poder responder a las
  • 00:01:17
    excepciones que se producen en un
  • 00:01:19
    programa Java en segundo lugar veremos
  • 00:01:22
    Cómo crear métodos que puedan ignorar
  • 00:01:24
    esas excepciones dejando que sea otra
  • 00:01:27
    clase la que las maneje veremos En
  • 00:01:30
    tercer lugar Cómo usar métodos que
  • 00:01:33
    provoquen ellos mismos excepciones por
  • 00:01:35
    alguna razón queremos que se produzca Y
  • 00:01:38
    por último veremos Cómo podemos crear
  • 00:01:40
    también nuestras propias
  • 00:01:43
    excepciones las excepciones son desde
  • 00:01:46
    luego algo muy natural Aunque natural
  • 00:01:49
    probablemente sea la palabra más amable
  • 00:01:51
    que se ha usado para describirlas en la
  • 00:01:54
    mayoría de las ocasiones se dice que las
  • 00:01:56
    letras de las canciones de rap son
  • 00:01:58
    tomadas de los de los programadores
  • 00:02:01
    desesperados después de horas intentando
  • 00:02:03
    localizar la causa de algún
  • 00:02:06
    error eh Porque Además este tipo de
  • 00:02:09
    errores suele ser de lo más variado eh
  • 00:02:12
    Como decíamos puede ser un simple error
  • 00:02:14
    de typo que ponemos una letra de más o
  • 00:02:17
    que se nos olvida de poner un punto y
  • 00:02:18
    coma al final de una declaración Pero
  • 00:02:22
    además de eso dentro de la clasificación
  • 00:02:24
    de los errores más comunes en una
  • 00:02:26
    aplicación existen aquellos que no
  • 00:02:29
    pueden evitar totalmente hagamos lo que
  • 00:02:31
    hagamos en el código por ejemplo que el
  • 00:02:34
    usuario tenga que escribir un número y
  • 00:02:36
    que escriba una letra le podemos poner
  • 00:02:38
    un mensaje muy grande eh lo más
  • 00:02:41
    llamativo posible diciéndole al usuario
  • 00:02:43
    que no escriba letras que no escriba
  • 00:02:46
    letras que escriba números pero no hay
  • 00:02:47
    un sistema para impedir que el usuario
  • 00:02:49
    lo haga eh Qué hacer en situaciones ante
  • 00:02:54
    circunstancias como estas si has
  • 00:02:57
    trabajado con otros lenguajes de
  • 00:02:58
    programación con php por ejemplo es muy
  • 00:03:00
    común usar condicionales que ejecutarán
  • 00:03:03
    una acción un mensaje por ejemplo si
  • 00:03:06
    alguno de esos errores ocurre si el
  • 00:03:09
    servidor no contesta si se recibe un
  • 00:03:11
    tipo de dato que no se espera etcétera
  • 00:03:13
    etcétera son los errores más comunes y
  • 00:03:16
    en Java también podríamos hacerlo de
  • 00:03:18
    este modo creando un condicional y
  • 00:03:21
    dentro por ejemplo otro tipo de
  • 00:03:23
    condicionales switch Case con los
  • 00:03:25
    distintos Case que serían para cada uno
  • 00:03:28
    de los errores que se podrían producir
  • 00:03:31
    eh pero cuando hablamos de Java existe
  • 00:03:35
    una técnica mejor para tratar con
  • 00:03:38
    circunstancias excepcionales que se
  • 00:03:40
    puedan producir al ejecutarse un
  • 00:03:42
    programa y es el uso de un grupo de
  • 00:03:45
    clases que se denominan así
  • 00:03:47
    exceptions las exceptions en este caso
  • 00:03:50
    Recuerda que ya no estamos hablando de
  • 00:03:52
    una palabra en inglés sino de el nombre
  • 00:03:55
    de un grupo de clases de un lenguaje de
  • 00:03:57
    programación así que por tanto las exion
  • 00:04:00
    incluyen errores que pueden ser fatales
  • 00:04:03
    para nuestro programa pero también otras
  • 00:04:05
    situaciones excepcionales pues manejando
  • 00:04:07
    estas exceptions podemos manejar los
  • 00:04:10
    errores y posiblemente darles una
  • 00:04:12
    solución cuando se produzca eh Por tanto
  • 00:04:17
    Java cuenta con su propio sistema para
  • 00:04:20
    el manejo de errores y condiciones
  • 00:04:22
    excepcionales en la ejecución de
  • 00:04:25
    programas una serie de características
  • 00:04:28
    que realizan comprobaciones en tiempo de
  • 00:04:30
    ejecución del programa y que utilizan
  • 00:04:33
    este conjunto de clases exón con las que
  • 00:04:36
    cuenta
  • 00:04:38
    Java
  • 00:04:40
    eh Para empezar cuando intentamos
  • 00:04:42
    entender las exceptions en Java tenemos
  • 00:04:45
    que adaptarnos a la terminología que
  • 00:04:47
    usan terminología que aunque sea
  • 00:04:50
    terminología Java está tomada de el
  • 00:04:52
    inglés en este caso eh de los deportes
  • 00:04:56
    usan los términos thrown Z o tirar
  • 00:05:00
    cuando se produce una excepción y el
  • 00:05:03
    término Cat capturar cuando la
  • 00:05:06
    excepción es respondida por el programa
  • 00:05:09
    Por tanto se produce una excepción
  • 00:05:10
    cuando un programa Java trown lanza un
  • 00:05:13
    tipo de error que es cogido que es
  • 00:05:16
    cazado que es cult y neutralizado
  • 00:05:19
    mediante el uso de estas clases
  • 00:05:23
    exens cuando hablamos de clases en Java
  • 00:05:26
    hablamos de su organización jerárquica y
  • 00:05:30
    dependencia y dentro de la jerarquía de
  • 00:05:33
    exón de las excepciones en La Cúspide se
  • 00:05:37
    encuentra la clase thr wobble que es
  • 00:05:40
    superclase de todos los errores y
  • 00:05:42
    excepciones en Java y siempre que se
  • 00:05:45
    produce un throne un lanzamiento de
  • 00:05:47
    algún tipo de error o estación siempre
  • 00:05:50
    se crea una instancia de esta clase trel
  • 00:05:54
    que es la
  • 00:05:57
    superclase superclase que tiene dos
  • 00:05:59
    subclases la clase error y la clase
  • 00:06:03
    exces las instancias de error suelen
  • 00:06:06
    hacer referencia siempre a errores
  • 00:06:08
    internos relacionados con la máquina
  • 00:06:10
    virtual de Java con el entorno de
  • 00:06:12
    ejecución errores bastante raros y sobre
  • 00:06:16
    todo aunque son fatales en ocasiones no
  • 00:06:18
    podemos hacer mucho para solucionarlos a
  • 00:06:20
    través de nuestro código sin embargo la
  • 00:06:23
    clase
  • 00:06:24
    exón Sí es la más relevante para nuestro
  • 00:06:27
    código de programación y de ahí que en
  • 00:06:30
    Java cuando se habla de errores se le
  • 00:06:32
    suele Llamar excepciones y no errores
  • 00:06:35
    justo por estas dos clases a las que
  • 00:06:37
    estamos haciendo referencia las
  • 00:06:39
    subclases de exces a su vez se dividen
  • 00:06:42
    en dos grandes grupos
  • 00:06:45
    generales que aunque son muchas como
  • 00:06:48
    vemos el grupo más importante se incluye
  • 00:06:51
    dentro de la clase que es su clase de
  • 00:06:54
    exion sobre todo la clase runtime excep
  • 00:06:57
    que es la que aquí ponemos
  • 00:07:00
    y dentro de ell se encuentran otras
  • 00:07:02
    subclases que se usan mucho como Index
  • 00:07:04
    bounds en fin tienen unos nombres como
  • 00:07:07
    siempre compuestos veremos unos cuantos
  • 00:07:10
    a lo largo de este víde tutorial pero
  • 00:07:12
    aquí puedes ver una lista desde luego de
  • 00:07:14
    nuevo en la documentación
  • 00:07:17
    eh puedes acceder a información mucho
  • 00:07:20
    más precisa Aquí vemos las subclases de
  • 00:07:23
    extensión y entre ellas como decíamos
  • 00:07:25
    runtime extensión que a su vez cuenta
  • 00:07:28
    con otra eh otro grupo de
  • 00:07:32
    subclases estas excepciones en tiempo de
  • 00:07:35
    ejecución suelen producirse son las que
  • 00:07:38
    se pueden solucionar de modo más
  • 00:07:41
    sencillo ya que suelen deberse siempre A
  • 00:07:43
    falta de eh consistencia en el código
  • 00:07:47
    veremos algunos ejemplos pronto pero por
  • 00:07:48
    ejemplo array Index of bounds se puede
  • 00:07:51
    producir cuando señalamos por ejemplo
  • 00:07:54
    que se busque dentro de una Ray un
  • 00:07:56
    elemento que no existe es un error muy
  • 00:07:58
    común vos algún ejemplo otro por ejemplo
  • 00:08:01
    cuando se crea una variable que
  • 00:08:03
    pertenece a un objeto que aún no se ha
  • 00:08:07
    instanciado y por lo tanto no puede
  • 00:08:12
    encontrarse pero eh los tipos de
  • 00:08:15
    excepciones son muy variados las clases
  • 00:08:18
    excepción primarias son parte del
  • 00:08:20
    paquete jabang como podemos ver también
  • 00:08:22
    aquí en esta información y se incluye
  • 00:08:26
    dentro de ella TR ex y r time sesión
  • 00:08:29
    pero eh muchos otros paquetes definen
  • 00:08:32
    también sus propias excepciones y esas
  • 00:08:35
    excepciones son usadas a través de la
  • 00:08:37
    propia librería de sus clases eh Por
  • 00:08:42
    ejemplo por poner un ejemplo el paquete
  • 00:08:44
    Java io eh Define una clase estricción
  • 00:08:48
    general propia que se llama así io
  • 00:08:51
    excepción Recuerda que io hace
  • 00:08:53
    referencia a input output y eh cuenta
  • 00:08:57
    con subclases que se encuentran de este
  • 00:08:58
    Dentro de este mismo paquete Java io
  • 00:09:00
    pero también se pueden encontrar dentro
  • 00:09:02
    de otros paquetes es la realidad en
  • 00:09:04
    cuanto profundizamos los temas desde
  • 00:09:07
    luego se complican y este de las
  • 00:09:08
    excepciones que intenta dar respuesta a
  • 00:09:11
    todas las posibles situaciones o
  • 00:09:13
    problemas que puede acarrear un código
  • 00:09:15
    hace que sean muy numerosas y que de
  • 00:09:17
    nuevo para profundizar en ellas primero
  • 00:09:19
    hay que entenderlas desde luego pero
  • 00:09:21
    después hay que acceder a la información
  • 00:09:24
    a la documentación para saber cuál usar
  • 00:09:26
    Cuál es su sintaxis y demás no creo que
  • 00:09:29
    a nadie se le ocurra intentar memorizar
  • 00:09:32
    la cantidad enorme de excepciones de las
  • 00:09:35
    que aquí vemos solo una
  • 00:09:37
    parte Aunque es ahora cuando vamos
  • 00:09:40
    verlas en profundidad ya hemos tenido
  • 00:09:42
    que tratar con excepciones en lo que
  • 00:09:44
    llevamos de curso y este tipo de errores
  • 00:09:47
    tienen lugar cuando escribimos un
  • 00:09:49
    programa Java que compila correctamente
  • 00:09:52
    sin Mostrar ningún error pero que en el
  • 00:09:55
    momento en el que lo ejecutamos se
  • 00:09:57
    encuentra algún problema
  • 00:09:59
    eh Por ejemplo un error muy común al
  • 00:10:03
    programar y también de los más sencillos
  • 00:10:05
    de solucionar es referirse a un elemento
  • 00:10:08
    de un array que no existe como podemos
  • 00:10:11
    ver en este ejemplo tenemos un array eh
  • 00:10:15
    de strings llamado cursos que cuenta con
  • 00:10:18
    tres strings y indicamos que se nos
  • 00:10:21
    muestre en pantalla con el uso de
  • 00:10:22
    printel cursos tres eh Como ya sabemos
  • 00:10:27
    los elementos de un aray empiezan a
  • 00:10:29
    contar desde cero por lo tanto aquí
  • 00:10:30
    tenemos cursos cer cursos 1 y cursos dos
  • 00:10:35
    cursos tres no existe Y aunque si
  • 00:10:39
    compilamos se compila bien en el momento
  • 00:10:41
    en el que ejecutamos este
  • 00:10:48
    programa observa como nos aparece un
  • 00:10:52
    error un error que hace referencia
  • 00:10:55
    dentro del paquete Java lang a una de
  • 00:10:58
    esas clases es que dijimos que se llama
  • 00:11:01
    en este caso array Index out of bouns
  • 00:11:04
    excession por eso el de andar leyendo
  • 00:11:07
    los nombres de estas clases a veces es
  • 00:11:09
    un lío pero es bastante explicativo lo
  • 00:11:11
    que nos indica aquí es que se ha
  • 00:11:13
    producido una excepción en el que el el
  • 00:11:16
    índice del array que estamos utilizando
  • 00:11:18
    está fuera de los límites de ese array
  • 00:11:21
    recuerdo hace años cuando estudiaba arte
  • 00:11:25
    que tenía una compañera que decía que
  • 00:11:27
    los las pinturas neoclásicas que el
  • 00:11:30
    título que tenían ya las explicaba y era
  • 00:11:33
    cierto porque tenían títulos larguísimos
  • 00:11:35
    en los que decía eh viriato agonizante
  • 00:11:37
    rodeado por sus compañeros que juran
  • 00:11:39
    venganza realmente ya explicaba todo lo
  • 00:11:41
    que aparecía en el cuadro Pues con los
  • 00:11:43
    nombres que se le da a estas clases
  • 00:11:44
    prácticamente pasa lo mismo para Ros es
  • 00:11:47
    un lío pero realmente resumen cuál es el
  • 00:11:51
    problema que se ha producido en este
  • 00:11:53
    caso como vemos nos indica que el índice
  • 00:11:56
    de la Ray está fuera de los límites que
  • 00:11:58
    se array
  • 00:12:00
    permite Pues hay cientos de de este tipo
  • 00:12:03
    de excepciones en Java muchas como esta
  • 00:12:07
    excepción array indican un problema que
  • 00:12:10
    puede ser arreglado con un simple cambio
  • 00:12:12
    de código tendríamos que cambiar aquí 3
  • 00:12:14
    por 2 y solucionado el problema Son por
  • 00:12:17
    tanto comparables errores de compilación
  • 00:12:20
    una vez que lo hayamos corregido la
  • 00:12:22
    situación ya eh No volverá a producirse
  • 00:12:25
    y nuestro programa debería ejecutarse de
  • 00:12:27
    modo ya correcto pero existen otras
  • 00:12:30
    excepciones eh Como decíamos hace un
  • 00:12:31
    momento que tienen que ser tratadas eh
  • 00:12:33
    cada vez que se ejecute un programa
  • 00:12:35
    porque no sabemos Eh qué es lo que se
  • 00:12:38
    puede producir cuando se lleva a cabo la
  • 00:12:40
    ejecución decíamos antes El ejemplo de
  • 00:12:43
    Pues que tenga que escribir algo el
  • 00:12:45
    usuario y que escriba e algo que no debe
  • 00:12:49
    escribirse pues hay que ver De qué modo
  • 00:12:51
    las excepciones nos permiten solucionar
  • 00:12:53
    esos problemas y para ello necesitamos
  • 00:12:56
    usar esas palabras clave a las que
  • 00:12:59
    hacíamos referencia en
  • 00:13:02
    Java y para esas excepciones que tienen
  • 00:13:06
    que ser tratadas Cada vez que un
  • 00:13:07
    programa se ejecuta vamos a poder
  • 00:13:10
    hacerlo usando cinco nuevas palabras
  • 00:13:13
    clave que aquí vemos try Catch Finally
  • 00:13:18
    thr y
  • 00:13:24
    th veamos Cómo usar un bloque TR Catch
  • 00:13:27
    para tratar con es iciones que no
  • 00:13:29
    podemos arreglar simplemente modificando
  • 00:13:32
    el código lo vemos en un ejemplo
  • 00:13:35
    práctico en el que vamos a crear una
  • 00:13:36
    pequeña aplicación a la que llamaremos
  • 00:13:39
    por ejemplo
  • 00:13:41
    sumador
  • 00:13:42
    eh a esta aplicación le Tendremos que
  • 00:13:45
    pasar uno o varios argumentos a través
  • 00:13:48
    de la línea de comando cosa que ya
  • 00:13:51
    hicimos en alguna otra ocasión y la
  • 00:13:53
    aplicación lo que va a hacer es sumarlos
  • 00:13:56
    y mostrarnos el eh total eh Como todos
  • 00:14:00
    los argumentos de línea de comando en
  • 00:14:02
    Java como ya sabemos son representados
  • 00:14:04
    por String eh el programa tiene que
  • 00:14:07
    convertirlos en números decimales antes
  • 00:14:10
    de eh poder eh añadirlos aquí lo hacemos
  • 00:14:14
    mediante el uso del método parse float
  • 00:14:17
    convertimos cada uno de los argumentos
  • 00:14:19
    que se pase eh en un número
  • 00:14:23
    decimal en fin una aplicación que estoy
  • 00:14:26
    seguro a estas alturas no hay que
  • 00:14:27
    explicar a nadie simplemente hacemos un
  • 00:14:30
    Loop y eh por cada vez que se itere ese
  • 00:14:34
    Loop se irá tomando uno de los valores
  • 00:14:36
    de El argumento al ir aumentando en uno
  • 00:14:40
    cada vez lo convertimos a un decimal y
  • 00:14:43
    lo añadimos lo sumamos al valor que
  • 00:14:46
    tenga la variable suma que empieza
  • 00:14:48
    siendo cero e irá añadiendo sumando
  • 00:14:51
    todos los argumentos que se
  • 00:14:54
    pasen para Añadir argumentos ya sabemos
  • 00:14:57
    desde eh
  • 00:14:59
    Run set project configuration en
  • 00:15:03
    customize eh aquí le indicamos como
  • 00:15:07
    clase principal la que estemos
  • 00:15:08
    utilizando y ahora en argumentos vamos a
  • 00:15:10
    empezar poniéndole pues cualquier número
  • 00:15:12
    vamos a poner por ejemplo los números
  • 00:15:14
    que ya están ahí los dejamos y pulsamos
  • 00:15:18
    Ok y
  • 00:15:21
    ejecutamos la
  • 00:15:23
    aplicación y vemos cómo lleva a cabo la
  • 00:15:26
    suma y aparece lo que aquí indicamos en
  • 00:15:28
    printel este número estos números suman
  • 00:15:30
    un total de y aquí el valor que tenga en
  • 00:15:32
    ese momento sum que es la suma de todos
  • 00:15:35
    los argumentos que se han
  • 00:15:37
    pasado puedes seguir poniendo valores
  • 00:15:40
    numéricos como argumentos las veces que
  • 00:15:42
    quieras y verás como nos da un resultado
  • 00:15:46
    correcto siempre así que podríamos que
  • 00:15:49
    preguntarnos que para qué necesitamos
  • 00:15:51
    entonces las excepciones para ver para
  • 00:15:53
    qué sirven vamos a cambiar los
  • 00:15:55
    argumentos
  • 00:15:59
    Y imaginémonos que cuando vamos a poner
  • 00:16:01
    los argumentos no nos damos de cuenta y
  • 00:16:04
    creemos Que aquí hay que poner los
  • 00:16:05
    argumentos separados por comas y ponemos
  • 00:16:07
    23 coma 54 coma eh 34 en este caso aquí
  • 00:16:13
    no nos pasa los números sino lo que va a
  • 00:16:15
    pasar es Recuerda es un String que es 23
  • 00:16:17
    coma cuando intente convertir este 23
  • 00:16:20
    coma en un número no va a poder hacerlo
  • 00:16:23
    así que vamos a ver con estos argumentos
  • 00:16:25
    qué es lo que ocurre cuando eh
  • 00:16:28
    ejecutamos la aplicación y observa como
  • 00:16:32
    aquí nos aparece una nueva
  • 00:16:34
    excepción y en este caso nos dice que la
  • 00:16:37
    estación es number format exens input
  • 00:16:41
    Stream 23 coma no puede
  • 00:16:46
    hacerlo justo porque no es un Stream que
  • 00:16:49
    pueda convertirse en un
  • 00:16:52
    número este tipo de mensajes son muy
  • 00:16:55
    informativos nos da muchísima
  • 00:16:56
    información nos indican Cuál es la exón
  • 00:16:59
    que se produce nos indican incluso dónde
  • 00:17:02
    En qué parte de Stream se está
  • 00:17:04
    produciendo esto lo escribimos
  • 00:17:06
    directamente nosotros y lo podemos
  • 00:17:07
    cambiar pero imagínate lo vimos ya
  • 00:17:09
    también en el curso có podíamos
  • 00:17:10
    cambiarlo que fuera una caja de entrada
  • 00:17:13
    de texto un área de texto donde tuviera
  • 00:17:15
    que escribir el usuario y que cuando
  • 00:17:17
    escribiera pues pusiera también así en
  • 00:17:18
    lugar de poner un número o que pusiera
  • 00:17:20
    5x o lo que fuera iba a tener el mismo
  • 00:17:23
    error Cómo podemos entonces eh tratar
  • 00:17:26
    con ese error que no podemos solucionar
  • 00:17:28
    directamente en el código ya que aquí
  • 00:17:31
    como vemos no podemos modificar código
  • 00:17:32
    para que este problema no se produzca
  • 00:17:35
    porque va a depender de los argumentos
  • 00:17:37
    que se le pasen a nuestro
  • 00:17:41
    método pues Tendremos que solucionarlo
  • 00:17:44
    mediante el uso de el bloque try Catch
  • 00:17:49
    en el cual va a tener que solucionar una
  • 00:17:52
    excepción que es la sección que aquí nos
  • 00:17:53
    indica vamos a tener que darle una
  • 00:17:56
    respuesta por si se produce esta
  • 00:17:59
    excepción que aquí vemos number format
  • 00:18:03
    ex vemos aquí en pantalla la sintaxis de
  • 00:18:08
    una
  • 00:18:08
    eh un bloque try Catch de declaración la
  • 00:18:12
    parte try que son las declaraciones que
  • 00:18:15
    pueden causar la excepción si no causan
  • 00:18:16
    la excepción se Ejecutan Sas y continúa
  • 00:18:19
    el programa pero si se lanza la
  • 00:18:22
    excepción si se produce esa excepción
  • 00:18:26
    Entonces tenemos que utilizar el Catch
  • 00:18:29
    al que hay que pasarle la posible
  • 00:18:31
    excepción y tenemos que indicar aquí con
  • 00:18:34
    una o varias declaraciones Qué es lo que
  • 00:18:36
    tiene que hacer el programa cuando se
  • 00:18:38
    produce esa excepción esta como vemos
  • 00:18:40
    aquí es la sintaxis de un try
  • 00:18:44
    Catch y el objeto extension que aparece
  • 00:18:49
    en la declaración Catch puede ser una de
  • 00:18:53
    dos cosas bien la clase de la excepción
  • 00:18:56
    que puede ocurrir o bien una de clase
  • 00:18:59
    que englobe varias excepciones
  • 00:19:00
    diferentes que puedan
  • 00:19:03
    ocurrir lo vemos en la aplicación
  • 00:19:07
    sumador vamos a modificarla en la cual
  • 00:19:10
    el try que como decimos es el que puede
  • 00:19:13
    lanzar esa excepción es el parse float
  • 00:19:16
    que convierte un String en número puede
  • 00:19:19
    convertirlo si es un número como vimos
  • 00:19:21
    que ocurría Pero puede eh dar un error
  • 00:19:24
    provocar una excepción si lo que se le
  • 00:19:25
    pasa como argumento no se puede
  • 00:19:27
    convertir y Entonces cuando tiene que
  • 00:19:29
    saltar el Catch en la otra parte de el
  • 00:19:33
    código vamos a verlo y en este caso lo
  • 00:19:37
    que tendremos que usar es el number
  • 00:19:39
    format exception que veíamos que era el
  • 00:19:41
    que nos daban el mensaje de excepción
  • 00:19:44
    cuando Eh no funcionaba
  • 00:19:47
    bien aquí podemos ver esta nueva versión
  • 00:19:49
    de sumador al que vamos a llamar así
  • 00:19:51
    nuevo sumador para guardar también la
  • 00:19:53
    otra observa como esta parte sigue
  • 00:19:55
    siendo exactamente Igual hasta donde
  • 00:19:58
    inicia el for int que por lo tanto
  • 00:20:01
    también va a recuperar cada uno de los
  • 00:20:04
    argumentos que se le pase pero ahora
  • 00:20:06
    dentro es donde incluimos el try Catch
  • 00:20:09
    dentro del try ponemos el mismo código
  • 00:20:11
    que poníamos antes que vaya añadiendo
  • 00:20:14
    sumando cada uno de los argumentos y
  • 00:20:17
    guardándolo en la variable zoom pero
  • 00:20:20
    ahora como vemos añadimos también el
  • 00:20:22
    Catch y como vemos le pasamos como eh
  • 00:20:25
    objeto number format exens que Recuerda
  • 00:20:29
    que es la excepción que nos había
  • 00:20:30
    lanzado antes cuando nos daba el error
  • 00:20:34
    Así que lo que hacemos Es que si se
  • 00:20:37
    produce la excepción Entonces que e eh
  • 00:20:42
    ponga en pantalla un mensaje diciendo
  • 00:20:45
    que lo que se está pasando ahora como
  • 00:20:47
    argumento I no es un
  • 00:20:50
    número y eh después lo que hacemos Es
  • 00:20:54
    simplemente imprimir el valor observa qu
  • 00:20:56
    tal como está esto se encuentra dentro
  • 00:20:57
    de un Loop por lo tanto esta aplicación
  • 00:21:00
    tal como está H va a sumar todos los eh
  • 00:21:05
    argumentos que se le pasen que se puedan
  • 00:21:07
    convertir a números y va a devolver un
  • 00:21:10
    mensaje que es el que indicamos aquí con
  • 00:21:13
    todos aquellos argumentos que no se
  • 00:21:14
    puedan convertir pero suma los otros
  • 00:21:16
    porque es lo que indicamos aquí así que
  • 00:21:18
    por lo tanto Aquí vemos un ejemplo de
  • 00:21:20
    uso de try Catch y como le pasamos el
  • 00:21:24
    objeto excep y como lo indicamos en una
  • 00:21:26
    declaración qué es lo que tiene que
  • 00:21:30
    hacer
  • 00:21:32
    eh vamos a la configuración y vamos aquí
  • 00:21:36
    elegir esta nueva clase nuevo sumador y
  • 00:21:39
    vamos a pasarle por ejemplo para que
  • 00:21:41
    quede más claro número sencillos vamos a
  • 00:21:43
    poner por ejemplo cinco o seis da igual
  • 00:21:45
    eh cuatro vamos a poner aquí eh 7a Como
  • 00:21:50
    vemos 6 y cuatro son argumentos que se
  • 00:21:52
    pueden convertir a número sin problema
  • 00:21:53
    7a no Así que con esto así lo guardamos
  • 00:21:57
    y vamos a ejecutar a ver que
  • 00:21:59
    ocurre pulsamos aquí para que se ejecute
  • 00:22:03
    y observa como nos devuelve 7a no es un
  • 00:22:06
    número por lo tanto es cuando se produce
  • 00:22:10
    se lanza la excepción y por tanto Catch
  • 00:22:12
    hace que se muestre pero sin embargo con
  • 00:22:14
    los otros dos argumentos sí que se pasan
  • 00:22:17
    y como vemos aparece aquí estos números
  • 00:22:18
    suman un total de 10 que son los otros
  • 00:22:20
    dos números que pusimos 6 y 4 creo que
  • 00:22:23
    era así que por lo tanto vemos aquí un
  • 00:22:25
    ejemplo práctico de El uso de try Catch
  • 00:22:30
    y entender bien el objeto que hay que
  • 00:22:33
    pasar dentro del Catch que coincide con
  • 00:22:35
    la excepción que puede saltar con
  • 00:22:39
    el la declaración o declaraciones que
  • 00:22:41
    están en
  • 00:22:44
    try así que de este modo lo que hacemos
  • 00:22:47
    Es que la excepción sea manejada dentro
  • 00:22:50
    de la propia clase y por tanto el
  • 00:22:52
    interprete Java no nos va a mostrar el
  • 00:22:55
    error y podemos en muchas ocasiones
  • 00:22:58
    tratar con problemas sobre todo
  • 00:22:59
    relacionados con entradas de usuario con
  • 00:23:02
    la entrada de tipo de datos que no se
  • 00:23:04
    esperan dentro de la aplicación usando
  • 00:23:06
    este tipo de bloques try Catch
  • 00:23:09
    eh pero los bloques try Catch pueden ser
  • 00:23:13
    usados para manejar diferentes tipos de
  • 00:23:16
    excepciones Incluso si son lanzadas por
  • 00:23:19
    declaraciones diferentes no tiene por
  • 00:23:22
    qué haber un único Catch podemos hacer
  • 00:23:24
    tantos Catch como excepciones queramos
  • 00:23:27
    lanzar
  • 00:23:29
    eh vamos a crear una nueva aplicación
  • 00:23:31
    muy sencilla a la que vamos a llamar
  • 00:23:34
    División y que va a tomar dos argumentos
  • 00:23:37
    de tipo integer que se le pasaremos a
  • 00:23:40
    través de la línea de comando como en el
  • 00:23:42
    anterior ejemplo y los vamos a usar para
  • 00:23:44
    llevar a cabo eh una
  • 00:23:48
    división pero a diferencia del anterior
  • 00:23:51
    ejemplo esta aplicación va a tener que
  • 00:23:54
    poder tratar con dos problemas
  • 00:23:56
    potenciales en las entradas de de los
  • 00:23:58
    usuarios igual que en el otro eh ejemplo
  • 00:24:01
    que los argumentos eh sean no numéricos
  • 00:24:05
    y por tanto no se puedan convertir a eh
  • 00:24:08
    números pero también que no se pueda
  • 00:24:10
    dividir por cer0 que es el segundo de
  • 00:24:13
    los problemas a los que tenemos que dar
  • 00:24:14
    una
  • 00:24:16
    respuesta esta aplicación que a estas
  • 00:24:19
    alturas Eh pues tiene muy poco que
  • 00:24:21
    explicar empezamos con un condicional en
  • 00:24:23
    el que comprobamos que el número de
  • 00:24:26
    argumentos que se le pasa sea dos para
  • 00:24:28
    poder llevar a cabo la división tienen
  • 00:24:29
    que ser dos Ni más ni menos si es así
  • 00:24:32
    creamos una variable llamada eh
  • 00:24:35
    resultado de tipo integer y le damos un
  • 00:24:37
    valor de cer0 y ahora en el try en esta
  • 00:24:40
    parte de aquí es donde llevamos a cabo
  • 00:24:42
    la división convertimos los dos
  • 00:24:45
    argumentos pasados a enteros comparse
  • 00:24:48
    int y los dividimos y posteriormente
  • 00:24:52
    hacemos que se muestre en pantalla el
  • 00:24:54
    resultado Ni más ni
  • 00:24:56
    menos y configuramos dos excepciones dos
  • 00:25:00
    Catch uno como en el anterior ejemplo si
  • 00:25:03
    lo que pasa el usuario no se puede
  • 00:25:05
    convertir a número pero otra por eso
  • 00:25:08
    usamos integer Porque si usáramos float
  • 00:25:10
    se podría dividir por cero nos
  • 00:25:12
    devolvería infinito Pero si son integer
  • 00:25:15
    no permite y devuelve otro tipo de
  • 00:25:17
    sección que se llama by cer que impide
  • 00:25:20
    dividir por C Que es lo que hacemos en
  • 00:25:21
    este segundo
  • 00:25:23
    ejemplo Así que como en el ejemplo
  • 00:25:26
    anterior si pasamos uno de los dos
  • 00:25:28
    argumentos que no sea convertible a un
  • 00:25:30
    entero nos devolverá la primera
  • 00:25:33
    excepción pero aquí ahora vemos la
  • 00:25:35
    segunda que como vemos es una aritmetic
  • 00:25:37
    excepción vamos a empezar por e quitar
  • 00:25:40
    este trozo de código voy a
  • 00:25:43
    comentarlo para poder mantenerlo sin
  • 00:25:46
    problema y dentro de un momento lo
  • 00:25:47
    volvemos a utilizar a ver creo que tiene
  • 00:25:50
    que ser a ver eh Pues aquí
  • 00:25:55
    esto antes de la llave de cierre tiene
  • 00:25:58
    que ser después desde luego así que así
  • 00:26:01
    sí Ahora lo mantenemos pero eh vamos a
  • 00:26:04
    probar pasándole
  • 00:26:09
    eh Como clase principal ponemos división
  • 00:26:11
    la que estamos usando y le pasamos como
  • 00:26:13
    vemos como segundo argumento un cero que
  • 00:26:16
    es lo que no se puede hacer en este
  • 00:26:18
    momento este Catch no está activo por lo
  • 00:26:20
    tanto vamos a ver lo que ocurre si
  • 00:26:22
    ejecutamos la aplicación así observa
  • 00:26:25
    como nos devuelve el error y como decí
  • 00:26:28
    diamos la excepción aritmetic ex by zer
  • 00:26:33
    by Zero que es la que vamos a tener que
  • 00:26:36
    utilizar que es la que utilizamos aquí
  • 00:26:38
    como puedes ver para crear nuestro
  • 00:26:44
    Catch podíamos hacer Igual que hicimos
  • 00:26:47
    con la anterior pasar un String pues
  • 00:26:49
    diciendo no se puede dividir por cero
  • 00:26:52
    por ejemplo pero también podemos
  • 00:26:54
    utilizar como hacemos en este caso y
  • 00:26:56
    aquí lo vemos el método get
  • 00:26:59
    message que nos permite recuperar el
  • 00:27:02
    error que nos devuelve el objeto que
  • 00:27:04
    tenemos aquí y por tanto por eso ponemos
  • 00:27:07
    e get message con lo cual nos va a
  • 00:27:11
    devolver el mensaje de El error error y
  • 00:27:13
    nos pondrá en este caso el error que
  • 00:27:14
    vemos aquí por cero cuando ahora
  • 00:27:18
    sea cogido cuando se ha cazado por
  • 00:27:22
    nuestro Catch es
  • 00:27:25
    error si guardamos si lo ejecutamos con
  • 00:27:27
    esta nueva versión observa como ahora
  • 00:27:30
    aparece
  • 00:27:31
    el mensaje que tenemos aquí porque se
  • 00:27:35
    dispara este segundo Catch error y get
  • 00:27:38
    message nos devuelve el mensaje del tipo
  • 00:27:41
    de error del que estamos hablando que en
  • 00:27:42
    este caso como decíamos es
  • 00:27:44
    by que es el que
  • 00:27:48
    aparece cuando estamos tratando con
  • 00:27:50
    múltiples excepciones usando try y Catch
  • 00:27:54
    seguro que va a haber ocasiones en las
  • 00:27:55
    que queramos que el programa haga algo
  • 00:27:57
    al fin del bloque tanto si ocurre una
  • 00:28:00
    excepción como si no pues podemos
  • 00:28:02
    hacerlo usando lo que se denomina un
  • 00:28:04
    bloque try Catch Finally que toma la
  • 00:28:09
    siguiente forma que puedes ver aquí en
  • 00:28:13
    pantalla
  • 00:28:15
    eh la declaración o declaraciones que se
  • 00:28:17
    encuentran dentro de la sección Finally
  • 00:28:21
    se Ejecutan después de todo lo que
  • 00:28:23
    incluye el bloque ocurra o no ocurra la
  • 00:28:26
    excepción esto puede ser útil en muchas
  • 00:28:28
    ocasiones por poner un ejemplo cuando el
  • 00:28:31
    eh programa quiere acceder a datos desde
  • 00:28:33
    un archivo en el disco eh se pueden
  • 00:28:36
    producir excepciones por distintas
  • 00:28:38
    causas que el archivo Puede que no
  • 00:28:40
    exista puede que se produzca un error de
  • 00:28:42
    disco Eh puede que se encuentre en un
  • 00:28:44
    formato que no sea compatible etcétera
  • 00:28:47
    Pero si las declaraciones para leer el
  • 00:28:49
    disco están en la sección try y los
  • 00:28:51
    errores son manejados en las distintas
  • 00:28:54
    secciones Catch que incluyamos podemos
  • 00:28:57
    asegurarnos que el archivo se va a
  • 00:28:59
    cerrar siempre poniendo la sección
  • 00:29:02
    Finally ese cierre de el archivo Así
  • 00:29:06
    tanto se produce la excepción como si no
  • 00:29:08
    nos aseguramos que el archivo acabará
  • 00:29:13
    cerrado eh podemos verlo en un ejemplo
  • 00:29:15
    simplemente ampliando el try Catch que
  • 00:29:18
    teníamos antes poniendo al final un una
  • 00:29:21
    nueva sección dentro del el bloque
  • 00:29:23
    Finally en la cual podemos Pues por
  • 00:29:26
    ejemplo poner que se imprima un mensaje
  • 00:29:28
    y este mensaje se va a imprimir tanto si
  • 00:29:31
    se produce la excepción como si no se
  • 00:29:33
    produce es la función que tiene puedes
  • 00:29:36
    probarlo pasándole datos que no
  • 00:29:38
    provoquen error o que provoquen error y
  • 00:29:40
    veremos como tanto un caso como en otro
  • 00:29:43
    se imprimirá en pantalla el mensaje que
  • 00:29:45
    se encuentra dentro de final y este es
  • 00:29:49
    el uso que tiene eh este tipo de bloque
  • 00:29:51
    tra Catch
  • 00:29:53
    Finally eh veamos ahora el mecanismo que
  • 00:29:57
    podemos usar para para lanzar
  • 00:29:58
    excepciones Recuerda que cuando hablamos
  • 00:30:01
    de lanzar nos referimos al término throw
  • 00:30:03
    o throws
  • 00:30:05
    Eh Pues cuando usamos clases que forman
  • 00:30:07
    parte de la librería de clases de Java
  • 00:30:09
    en ocasiones podemos ver que nos lanzan
  • 00:30:12
    mensajes como el que aquí vemos mas be c
  • 00:30:16
    o decare to be
  • 00:30:18
    thr que podríamos Traducir por algo así
  • 00:30:21
    como debe ser cogido o declarado para
  • 00:30:24
    ser lanzado son las opciones que
  • 00:30:27
    tendremos dentro de nuestro método
  • 00:30:30
    dentro de nuestra clase pero para
  • 00:30:31
    empezar entender cómo se llega hasta
  • 00:30:33
    aquí estamos hablando de una clase de la
  • 00:30:36
    librería de Java en la cual se han
  • 00:30:38
    definido una serie de excepciones Y en
  • 00:30:41
    este caso se indica que eh tiene que
  • 00:30:45
    lanzar a cualquier clase que llame a un
  • 00:30:47
    método de esa clase tiene que lanzarle
  • 00:30:50
    una excepción de este tipo de ahí Que
  • 00:30:52
    aparezca lo de must be cod o decare to
  • 00:30:55
    be thrown eh Como tantas otras ocasiones
  • 00:30:58
    es bastante más sencillo de lo que puede
  • 00:31:00
    parecer en un principio lo que nos
  • 00:31:03
    indica con esto es que el método al que
  • 00:31:05
    estamos llamando que estamos intentando
  • 00:31:07
    usar nos lanza una excepción Así que eh
  • 00:31:12
    eso tiene que estar determinado en la
  • 00:31:14
    clase veremos después como nosotros
  • 00:31:16
    podemos determinar que nuestra clase
  • 00:31:18
    también Lance este tipo de excepciones
  • 00:31:20
    pero de momento no la estamos lanzando
  • 00:31:22
    la estamos recibiendo un método de una
  • 00:31:25
    clase al que llamamos nos lanza esta
  • 00:31:27
    excepción qué es lo que podemos hacer
  • 00:31:29
    nosotros cuando recibimos esta
  • 00:31:33
    excepción bien podemos manejar la
  • 00:31:36
    excepción mediante el uso de un bloque
  • 00:31:38
    try Catch como acabamos de hacer hace un
  • 00:31:40
    momento bien eh podemos rebotar lo que
  • 00:31:44
    nos lanzan y a su vez lanzarlo nosotros
  • 00:31:46
    usando trown veremos ahora cómo hacemos
  • 00:31:49
    y por tanto lo pasaríamos al método eh
  • 00:31:52
    que llamara a nuestra clase al método de
  • 00:31:55
    nuestra clase por tanto eh podemos
  • 00:31:58
    lanzar algo que nos llega lanzado o
  • 00:32:00
    podemos hacer las dos cosas podemos
  • 00:32:03
    gestionarlo mediante un try Catch pero
  • 00:32:04
    después también hacer que sea lanzado
  • 00:32:07
    cuando cualquier otro otra clase llame a
  • 00:32:10
    el método que estamos creando nosotros
  • 00:32:12
    Así que las posibilidades son esas
  • 00:32:14
    gestionarlo con un trycatch lanzarlo
  • 00:32:16
    otra vez con un trown o hacer las dos
  • 00:32:19
    cosas un trycatch y un
  • 00:32:23
    thrown vamos a ver nuestro código Cómo
  • 00:32:25
    podemos hacer que además de eh llevar a
  • 00:32:29
    cabo con el try Catch eh el la respuesta
  • 00:32:34
    cuando se produce un error podemos
  • 00:32:36
    también lanzar de nuevo ese error el
  • 00:32:39
    sentido que tiene el uso de trow como
  • 00:32:41
    vamos ver ahora es si esta clase
  • 00:32:45
    contiene métodos que pueden ser llamados
  • 00:32:46
    por otras clases utilizando este trow e
  • 00:32:49
    cuando se llame a el método le va a
  • 00:32:52
    pasar siempre
  • 00:32:53
    eh le va a lanzar de nuevo la excepción
  • 00:32:57
    para ello aquí lo vemos control e nos va
  • 00:33:00
    a HM hacer que Lance en cada momento la
  • 00:33:04
    excepción que se dispara podemos ponerlo
  • 00:33:08
    en alguno o en todos los Catch y esto
  • 00:33:11
    Como creo que tiene que estar Claro si
  • 00:33:13
    vemos hasta ahora solo se va a ejecutar
  • 00:33:16
    si se produce la excepción si por tanto
  • 00:33:18
    el try cuando se lleva a cabo el intento
  • 00:33:22
    de ejecutar el código da error y
  • 00:33:25
    entonces sea un cacho sea el otro nos
  • 00:33:29
    enviará el true no solo el mensaje sino
  • 00:33:31
    que también envía el
  • 00:33:33
    error veamos primero el código en
  • 00:33:38
    funcionamiento observa como al
  • 00:33:41
    ejecutarlo seguimos teniendo los mismos
  • 00:33:42
    datos en el argumento lo primero que
  • 00:33:45
    hace es Mostrar lo que incluimos en este
  • 00:33:49
    Catch pero observa como después lanza la
  • 00:33:53
    excepción en esta parte que aquí vemos
  • 00:33:58
    de momento esto pues como estamos
  • 00:33:59
    ejecutando el código Eh puede que no
  • 00:34:02
    tenga mucho sentido Pero recuerda que el
  • 00:34:05
    objetivo es que eh si esta clase que
  • 00:34:08
    estamos creando tiene métodos que son
  • 00:34:09
    llamados por otras clases pues queremos
  • 00:34:12
    que cuando eh otra clase llame a este
  • 00:34:15
    método si se produce la excepción que no
  • 00:34:17
    solo trate con la excepción sino que
  • 00:34:19
    también la Lance e informe a la clase
  • 00:34:23
    que llama al método de que se ha
  • 00:34:25
    producido este error en concreto esto es
  • 00:34:28
    muy importante en distintas ocasiones
  • 00:34:29
    desde luego ya tienes que entender que
  • 00:34:31
    si los datos que tuviéramos
  • 00:34:34
    aquí estuvieran correctos y por tanto no
  • 00:34:37
    se produjera el error
  • 00:34:41
    Bueno si aquí en vez de cero pues
  • 00:34:43
    ponemos cualquier otro número cuatro por
  • 00:34:50
    ejemplo no se produce ni el Catch ni se
  • 00:34:53
    produce el true no lo lanza porque no
  • 00:34:55
    hay excepción esto simplemente es cuando
  • 00:34:58
    queremos que el código eh trate mediante
  • 00:35:02
    el Catch con eh la excepción que se
  • 00:35:04
    produce pero que también la Lance a
  • 00:35:07
    cualquier otro método que llame a este
  • 00:35:09
    método para que tenga información de
  • 00:35:11
    cuál es el error que se está
  • 00:35:14
    produciendo imagínate en un ejemplo
  • 00:35:16
    concreto que tengamos un programa que
  • 00:35:19
    chequea una tarjeta de crédito y
  • 00:35:23
    eh llama a un a una clase que se llama
  • 00:35:27
    check database para llevar a cabo esa
  • 00:35:30
    comprobación eh Cuando check database
  • 00:35:33
    lleva a cabo la comprobación puede que
  • 00:35:35
    funcione correctamente pero que sin
  • 00:35:36
    embargo eh lo que falle sea por ejemplo
  • 00:35:39
    la conexión con el servidor del lugar
  • 00:35:42
    donde se encuentra la tarjeta de crédito
  • 00:35:44
    si eh tenemos en check database el Catch
  • 00:35:48
    para que trate con ese problema pues lo
  • 00:35:49
    soluciona pero no informa a la clase que
  • 00:35:52
    llama al método que es lo que ha
  • 00:35:54
    ocurrido para que se haya producido ese
  • 00:35:57
    error por tanto eh puede ser importante
  • 00:35:59
    que un método una clase no solo trate
  • 00:36:02
    con una excepción sino que también la
  • 00:36:04
    Lance Y eso es lo que tiene sentido
  • 00:36:06
    cuando usamos trow eh Como lo que
  • 00:36:09
    estamos haciendo en este
  • 00:36:11
    ejemplo la otra palabra clave que
  • 00:36:14
    tenemos que entender es la palabra
  • 00:36:16
    throws y es la que va a permitir que un
  • 00:36:19
    método pueda ignorar totalmente una
  • 00:36:22
    excepción que le es lanzada por otro
  • 00:36:25
    método al que llama así que por lo tanto
  • 00:36:28
    eh Cuando un método de una clase Llama a
  • 00:36:32
    otro método que le lanza una excepción
  • 00:36:35
    eh lo que puede hacer ese método es
  • 00:36:37
    ignorar esa llamada a la excepción eh
  • 00:36:40
    incluyendo en su eh definición thrones a
  • 00:36:44
    esa excepción en
  • 00:36:46
    concreto por tanto ese método les
  • 00:36:49
    lanzada una excepción que a su vez él
  • 00:36:52
    lanza a otro método que lo llame y sería
  • 00:36:55
    ese otro método el encargado de tratar
  • 00:36:57
    con excepción o hacer exactamente lo
  • 00:36:59
    mismo lanzarlo también a el siguiente
  • 00:37:03
    método así que por lo tanto es posible
  • 00:37:05
    también ignorar eh excepciones mediante
  • 00:37:08
    el uso de
  • 00:37:10
    thrs
  • 00:37:13
    eh aquí vemos un ejemplo de sintaxis de
  • 00:37:16
    código utilizando thrones que en un
  • 00:37:19
    momento veremos en un ejemplo práctico
  • 00:37:21
    completo pero de momento para entender a
  • 00:37:23
    qué nos referimos como vemos aquí este
  • 00:37:26
    método load URL
  • 00:37:29
    eh utiliza en su definición throws con
  • 00:37:34
    lo cual Aunque llame a un método que le
  • 00:37:37
    envíe un una excepción mal format URL
  • 00:37:41
    extension no va a tratar con ella no
  • 00:37:44
    tenemos que hacer referencia ni con
  • 00:37:45
    trycatch ni con TR ni con nada dentro de
  • 00:37:47
    su código automáticamente con trow en su
  • 00:37:51
    definición lo pasará se lo lanzará a
  • 00:37:54
    cualquier otro método que lo llame a él
  • 00:38:01
    veamos Lu un ejemplo práctico en el que
  • 00:38:03
    una clase en sus constructors usa
  • 00:38:06
    thrones para lanzar sin tener que tratar
  • 00:38:10
    eh para nada con esas excepciones y
  • 00:38:13
    lanzarlo a el método que va a llamar a
  • 00:38:15
    sus constructores
  • 00:38:17
    eh vamos en este taller de trabajo
  • 00:38:20
    elaborar un par de clases la primera de
  • 00:38:23
    ellas será la encargada de lanzar a la
  • 00:38:26
    otra el aviso sobre un error que haya
  • 00:38:29
    tenido lugar esta primera clase la vamos
  • 00:38:32
    a llamar página inicial y es donde
  • 00:38:35
    crearemos la base para un catálogo
  • 00:38:38
    online y eh posteriormente una segunda
  • 00:38:41
    clase a la que llamaremos página
  • 00:38:43
    catálogo que usará objetos de esta clase
  • 00:38:45
    página inicial para mostrar la
  • 00:38:49
    información vamos a empezar importando
  • 00:38:52
    el paquete
  • 00:38:53
    javanet ya que como decíamos Aquí vamos
  • 00:38:56
    a crear la base para la información de
  • 00:38:59
    páginas web y una uno de las variables
  • 00:39:03
    va a ser un objeto de la clase URL por
  • 00:39:07
    lo tanto necesitamos importar el paquete
  • 00:39:12
    javanet eh continuamos creando la clase
  • 00:39:15
    y ahora dentro de la clase en primer
  • 00:39:17
    lugar vamos a crear las tres variables
  • 00:39:20
    que contendrán la información que eh se
  • 00:39:23
    mostrará para cada página
  • 00:39:27
    se trata de dos variables de tipo String
  • 00:39:30
    y una de tipo URL como eh dijimos eh en
  • 00:39:35
    categoría le damos un valor por defecto
  • 00:39:37
    como porque como veremos ahora no va a
  • 00:39:39
    ser obligatorio y ahora dentro de esta
  • 00:39:41
    clase lo que vamos a hacer es crear dos
  • 00:39:44
    constructors que son los que van a
  • 00:39:46
    permitir eh crear cada una de las
  • 00:39:49
    páginas con información desde la eh
  • 00:39:53
    página catálogo que es la que
  • 00:39:54
    construiremos en un momento
  • 00:39:58
    Así que
  • 00:40:00
    ponemos la firma para el primero de los
  • 00:40:04
    constructors en el que como vemos
  • 00:40:06
    pasamos de las tres variables Solo dos
  • 00:40:09
    el nombre del propietario y la dirección
  • 00:40:13
    la variable URL este no contiene la
  • 00:40:16
    categoría pero ahora como cualquier
  • 00:40:19
    clase que cree objetos
  • 00:40:21
    URL esta página inicio tiene que tratar
  • 00:40:24
    con las excepciones marf
  • 00:40:28
    URL excep de la que ya hablamos y puedo
  • 00:40:31
    hacerlo como ya sabemos También bien un
  • 00:40:33
    bloque trycatch o puede declarar la
  • 00:40:36
    excepción en la firma y de este modo
  • 00:40:39
    ignorar esa excepción y pasársela a la
  • 00:40:42
    clase que llame a sus métodos que es
  • 00:40:44
    justo lo que vamos a hacer ahora así que
  • 00:40:46
    por lo tanto tanto en este constructor
  • 00:40:49
    como en el otro vamos tener que utilizar
  • 00:40:52
    thrones como dijimos hace un momento
  • 00:40:58
    vamos a colocar en otra línea para que
  • 00:41:00
    se vea completo pero recuerda que va
  • 00:41:03
    dentro de la firma por tanto antes de
  • 00:41:05
    las llaves de apertura justo después de
  • 00:41:07
    que cerramos los paréntesis de los
  • 00:41:09
    parámetros
  • 00:41:11
    escribimos el TR pasando el nombre podía
  • 00:41:16
    ser más de una también excepción en este
  • 00:41:18
    caso es esta
  • 00:41:19
    excepción la que queremos que
  • 00:41:24
    Lance y ahora el contenido sencillo las
  • 00:41:27
    declaraciones para hacer en
  • 00:41:30
    propietario lo que se pase como
  • 00:41:32
    parámetro cuando se llama el constructor
  • 00:41:34
    la variable de prioritario y en
  • 00:41:36
    dirección de la URL dirección Así que
  • 00:41:40
    simplemente esto como vemos y tenemos el
  • 00:41:43
    primer constructor creamos ahora el
  • 00:41:46
    segundo constructor que simplemente toma
  • 00:41:48
    la información ya recogida en el primero
  • 00:41:51
    y le añade categoría como ya viemos
  • 00:41:54
    tambén en su momento que se podía hacer
  • 00:41:57
    pero también vamos a tener que poner en
  • 00:41:59
    ese constructor el trones para que Lance
  • 00:42:03
    la
  • 00:42:05
    excepción queé Tenemos aquí y como vemos
  • 00:42:09
    lo que se hace aparte de
  • 00:42:11
    usar los que ya teníamos en el anterior
  • 00:42:14
    constructor le añadimos categoría con
  • 00:42:17
    esto puede llamarse a esta clase tanto
  • 00:42:21
    pasando dos parámetros el propietario y
  • 00:42:25
    la url Us and tres se incluida también
  • 00:42:28
    la categoría el resto como vemos
  • 00:42:30
    Exactamente igual y lo que nos interesa
  • 00:42:32
    el uso de
  • 00:42:36
    trs vemos por tanto una clase que
  • 00:42:39
    utiliza objetos URL sin necesidad de eh
  • 00:42:44
    crear un TR Catch para eh tratar con la
  • 00:42:47
    excepción mal formet URL exón porque
  • 00:42:50
    mediante el uso de trow lo va a lanzar y
  • 00:42:52
    se lo pasa a la clase que llame a los
  • 00:42:55
    métodos en este caso los constructors de
  • 00:42:58
    esta clase Así que con esto tenemos
  • 00:43:00
    nuestra primera clase creada vamos ahora
  • 00:43:03
    a crear la clase página catálogo
  • 00:43:07
    eh clase en la que para empezar
  • 00:43:10
    importamos el paquete Java net y ahora
  • 00:43:13
    creamos la estructura para la clase y
  • 00:43:16
    para el método
  • 00:43:20
    Main y ahora dentro de main lo primero
  • 00:43:23
    que vamos a hacer es crear un arr de
  • 00:43:25
    objetos página inicial cada uno de ellos
  • 00:43:29
    será el de los datos de una página Así
  • 00:43:32
    que creamos el eh array de objetos vamos
  • 00:43:37
    a hacer que sean cinco podía ser el
  • 00:43:39
    número que quisiéramos
  • 00:43:42
    y ahora vamos a utilizar el bloque try
  • 00:43:46
    Catch en el try que será donde
  • 00:43:49
    eh creemos cada uno de los objetos de la
  • 00:43:52
    clase página inicial y el Catch que será
  • 00:43:55
    el que nos permita
  • 00:43:58
    recoger la excepción que puede ser
  • 00:44:01
    lanzada por la clase página inicial Así
  • 00:44:05
    que aquí tenemos el try Catch en el cual
  • 00:44:08
    en el CCH ya ponemos que la excepción es
  • 00:44:11
    malformed URL excepción como
  • 00:44:15
    sabemos y ahora en el trke como decíamos
  • 00:44:19
    lo que vamos a ir haciendo es Llamando
  • 00:44:21
    al constructor de página inicial
  • 00:44:24
    pasándole los tres argumentos o los dos
  • 00:44:27
    argumentos que decíamos lo vemos en el
  • 00:44:30
    primero catálogo cero New página inicial
  • 00:44:33
    y pasamos el nombre Eh pasamos la
  • 00:44:36
    dirección Pero Observa que no como un
  • 00:44:38
    objeto URL sino que es como un String eh
  • 00:44:42
    cuando el constructor se ejecute de
  • 00:44:44
    página inicial será el que tenga que
  • 00:44:47
    comprobar mediante trow si esa URL que
  • 00:44:50
    se pasa como Stream se puede convertir
  • 00:44:52
    en un objeto URL o no Si no se puede
  • 00:44:56
    convertir es cuando lanzará la excepción
  • 00:45:00
    que será eh recogida aquí Así que
  • 00:45:03
    hacemos esto para cada uno de los
  • 00:45:05
    elementos que vamos a crear que en este
  • 00:45:07
    Vimos una ra que eran cinco Así que
  • 00:45:09
    hacemos lo mismo
  • 00:45:12
    eh para los otros
  • 00:45:14
    cuatro aquí lo vemos y
  • 00:45:18
    eh vemos como en el quinto el que parece
  • 00:45:22
    aquí como catálogo cuatro eh pasamos
  • 00:45:25
    solamente dos argumentos no pasamos
  • 00:45:27
    categoría esto podíamos hacerlo con
  • 00:45:28
    cualquier otro porque recuerda que no es
  • 00:45:29
    obligatorio pero lo que ahora tenemos
  • 00:45:32
    que fijarnos es que aquí ponemos eh Como
  • 00:45:35
    Stream una URL que está mal formateada
  • 00:45:38
    le falta el
  • 00:45:40
    http por tanto esto cuando el
  • 00:45:44
    constructor lo intente convertir en un
  • 00:45:45
    objeto URL no va a poder y es cuando
  • 00:45:48
    lanza la excepción pero excepción que en
  • 00:45:50
    lugar de ser recogida en esta clase es
  • 00:45:54
    recogida en esta con el que aquí
  • 00:46:00
    ponemos Eh Pues ahora dentro del triler
  • 00:46:03
    lo único que nos queda es utilizar un
  • 00:46:06
    Loop para que muestre en pantalla la
  • 00:46:10
    información de cada uno de los elementos
  • 00:46:12
    que hemos creado de este modo Tan
  • 00:46:17
    sencillo como
  • 00:46:20
    siempre y ahora nos queda ya simplemente
  • 00:46:23
    por poner alguna declaración sobre lo
  • 00:46:25
    que queremos que haga si se lanza la
  • 00:46:27
    excepción cuando la recoge vamos a poner
  • 00:46:30
    simplemente error y utilizamos el método
  • 00:46:32
    que decíamos antes get message para Que
  • 00:46:35
    aparezca el mensaje de la excepción en
  • 00:46:38
    concreto que se está
  • 00:46:42
    produciendo el funcionamiento creo que
  • 00:46:45
    tiene que estar más que claro de este
  • 00:46:47
    modo lo que hacemos es estar llamando a
  • 00:46:48
    los constructors y le pasamos tres
  • 00:46:51
    argumentos los tres argumentos que
  • 00:46:53
    tenemos aquí en página inicial de los
  • 00:46:56
    Cuál es el segundo es un objeto URL
  • 00:47:01
    cuando se le pase un String que no puede
  • 00:47:04
    convertirse en un objeto URL no tiene un
  • 00:47:06
    buen formato es cuando se lanza esta
  • 00:47:09
    excepción marf URL excepción que es
  • 00:47:13
    recogida por el Catch que hemos puesto
  • 00:47:18
    aquí si ejecutamos tal como está ahora
  • 00:47:22
    página
  • 00:47:24
    catálogo vemos
  • 00:47:27
    cómo
  • 00:47:28
    aparece el mensaje y el get mensaje
  • 00:47:32
    recupera no protocol y nos indica dónde
  • 00:47:36
    no se cumple el protocolo que es aquí en
  • 00:47:38
    W wt org si aquí simplemente añadimos
  • 00:47:45
    http y lo
  • 00:47:48
    ejecutamos ahora como vemos se ejecuta
  • 00:47:51
    tal como queríamos que
  • 00:47:54
    apareciera esta parte de el try recupera
  • 00:47:59
    toda la
  • 00:48:00
    información y si no aparece categoría lo
  • 00:48:03
    que pasemos por defecto
  • 00:48:07
    ninguna por tanto podemos resumir para
  • 00:48:10
    finalizar que el manejo de las
  • 00:48:11
    excepciones en Java se centra en el uso
  • 00:48:15
    de block spr Catch y de throne y de
  • 00:48:21
    thrones sistemas que pueden
  • 00:48:24
    usarse separados pero pueden usarse
  • 00:48:27
    también juntos incluso podemos usar los
  • 00:48:31
    tres sistemas en una misma
  • 00:48:34
    clase
  • 00:48:36
    en una situación en la que queramos
  • 00:48:39
    manejar las excepciones entrantes que
  • 00:48:42
    sean eh lanzadas
  • 00:48:45
    eh Y sean recogidas por nuestro método
  • 00:48:49
    pero al mismo tiempo También queremos la
  • 00:48:51
    opción de poder pasar esa excepción a
  • 00:48:53
    cualquier otro método que llame al
  • 00:48:56
    nuestro Así que usando trycatch
  • 00:48:59
    eh podemos tratar con lación pero no
  • 00:49:02
    podemos pasarla y añadiendo la cláusula
  • 00:49:05
    throws eh podemos pasar la sección pero
  • 00:49:10
    no podemos tratar con
  • 00:49:12
    ella si queremos tanto manejar la
  • 00:49:14
    excepción como pasarla al método que
  • 00:49:17
    llame a nuestro método usamos estos tres
  • 00:49:19
    mecanismos la cláusula throws la
  • 00:49:22
    declaración try Catch y una declaración
  • 00:49:25
    throw aquí en este ejemplo de código
  • 00:49:27
    podemos verlo con esta declaración trout
  • 00:49:31
    explícitamente relanzamos la excepción
  • 00:49:33
    eh Aunque haya sido tratada en nuestro
  • 00:49:36
    código eh mediante el uso de
  • 00:49:41
    Catch y este código es totalmente válido
  • 00:49:44
    y funcionará las excepciones pueden ser
  • 00:49:47
    anidadas así que manejamos la excepción
  • 00:49:50
    dentro de nuestra clase pero al mismo
  • 00:49:51
    tiempo permitimos que el método que
  • 00:49:54
    llame a nuestro método pueda manejar
  • 00:49:56
    también esa excepción gracias a este
  • 00:49:58
    sistema de anidamiento las excepciones
  • 00:50:02
    por tanto pueden ir saltando de método a
  • 00:50:04
    método sin que muchos de ellos tengan
  • 00:50:07
    que tratar para nada con las excepciones
  • 00:50:09
    Aunque sí que en alguno de los métodos
  • 00:50:12
    hay que tratar con excepción si no se
  • 00:50:14
    hace si se produce esa excepción nos
  • 00:50:16
    dará un error nuestro programa como ya
  • 00:50:19
    sabemos pues hasta aquí el tema
  • 00:50:22
    relacionado con las excepciones que con
  • 00:50:24
    esto tiene que quedar claro eh Para
  • 00:50:27
    siempre que lo utilicemos a lo largo de
  • 00:50:30
    el curso nos queda por ver el otro tema
  • 00:50:33
    al que hacíamos referencia ya en otras
  • 00:50:35
    ocasiones los threats la el sistema que
  • 00:50:38
    Java utiliza para poder realizar
  • 00:50:42
    multiples tareas
  • 00:50:44
    y con eso terminamos este segundo bloque
  • 00:50:48
    del curso y entraremos ya en el tercero
  • 00:50:50
    en el que hoy hemos hablado de objetos
  • 00:50:52
    como URL la web
  • 00:50:55
    el bajo de Java en la web será la clave
  • 00:50:59
    de ese tercer bloque Pero antes como
  • 00:51:01
    digo en el próximo trataremos los thre
  • 00:51:05
    por hoy nada más os hablo Jesús Conde
  • 00:51:07
    nos vemos
  • 00:51:08
    [Música]
  • 00:51:16
    [Música]
  • 00:51:27
    [Música]
  • 00:51:42
    Oh
  • 00:51:45
    [Música]
Etiquetas
  • Java
  • excepciones
  • errores
  • manejo de errores
  • programación
  • try-catch
  • throw
  • throws
  • bloque finally
  • excepciones personalizadas