lanzar - retornar exception java

¿Por qué es necesaria la "excepción de lanzamientos" al llamar a una función?

Question

class throwseg1
{
    void show() throws Exception
    {
        throw new Exception("my.own.Exception");
    }

    void show2() throws Exception  // Why throws is necessary here ?
    {
        show();
    }

    void show3() throws Exception  // Why throws is necessary here ?
    {
        show2();
    }

    public static void main(String s[]) throws Exception  // Why throws is necessary here ?
    {
        throwseg1 o1 = new throwseg1();
        o1.show3();
    }
}

¿Por qué el compilador informa que los métodos show2() , show3() y main() tienen

Excepción no reportada Excepción que debe ser capturada o declarada como lanzada

Cuando elimino throws Exception de estos métodos?

Answer 1

En Java, como usted sabe, las excepciones se pueden clasificar en dos: una que necesita la cláusula de throws o debe manejarse si no especifica una y otra que no. Ahora, vea la siguiente figura:

En Java, puedes lanzar cualquier cosa que extienda la clase Throwable . Sin embargo, no es necesario especificar una cláusula de throws para todas las clases. Específicamente, las clases que son un Error o una RuntimeException o cualquiera de las subclases de estas dos. En su caso, la Exception no es una subclase de un Error o una Exception RuntimeException . Por lo tanto, es una excepción marcada y debe especificarse en la cláusula de throws , si no maneja esa excepción en particular. Por eso necesitabas la cláusula de los throws .

Desde el Tutorial de Java :

Una excepción es un evento, que ocurre durante la ejecución de un programa, que interrumpe el flujo normal de las instrucciones del programa.

Ahora, como saben, las excepciones se clasifican en dos: activadas y desactivadas. ¿Por qué estas clasificaciones?

Excepción marcada: se utilizan para representar problemas que se pueden recuperar durante la ejecución del programa. Normalmente no son culpa del programador. Por ejemplo, un archivo especificado por el usuario no es legible, o no hay conexión de red disponible, etc., en todos estos casos, nuestro programa no necesita salir, en su lugar, puede tomar medidas como alertar al usuario o realizar una recuperación mecanismo (como trabajo fuera de línea cuando la red no está disponible), etc.

Excepciones sin marcar : de nuevo se pueden dividir en dos: Errores y RuntimeExceptions. Una de las razones por las que no se pueden controlar es que son numerosos en número y que, para manejarlos todos, saturará nuestro programa y reducirá su claridad. La otra razón es:

• Excepciones de tiempo de ejecución: generalmente ocurren debido a fallas de los programadores. Por ejemplo, si se produce una ArithmeticException de división por cero o una ArrayIndexOutOfBoundsException , es porque no tenemos suficiente cuidado en nuestra codificación. Ocurren generalmente debido a algunos errores en la lógica de nuestro programa. Por lo tanto, deben borrarse antes de que nuestro programa entre en modo de producción. No están verificados en el sentido de que nuestro programa debe fallar cuando se produce, de modo que los programadores puedan resolverlo en el momento del desarrollo y las pruebas.

• Errores: los errores son situaciones de las que normalmente el programa no puede recuperarse. Por ejemplo, si se produce un StackOverflowError , nuestro programa no puede hacer mucho, como aumentar el tamaño de la pila de llamadas a la función del programa. O si ocurre un OutOfMemoryError , no podemos hacer mucho para aumentar la cantidad de RAM disponible para nuestro programa. En tales casos, es mejor salir del programa. Es por eso que se hacen sin marcar.

Para información detallada vea:

• Excepciones no verificadas - La controversia
• El requisito de captura o especificación

Answer 2

Java requiere que usted maneje o declare todas las excepciones. Si no está manejando una excepción usando un bloque try / catch, entonces debe declararse en la firma del método.

Por ejemplo:

class throwseg1 {
    void show() throws Exception {
        throw new Exception();
    }
}

Debe escribirse como:

class throwseg1 {
    void show() {
        try {
            throw new Exception();
        } catch(Exception e) {
            // code to handle the exception
        }
    }
}

De esta manera puede deshacerse de la declaración de "Excepciones de lanzamientos" en la declaración de método.

Answer 3

La declaración de throws Exception es una forma automatizada de realizar un seguimiento de los métodos que pueden generar una excepción por razones anticipadas pero inevitables. La declaración suele ser específica sobre el tipo o los tipos de excepciones que se pueden lanzar, como throws IOException o throws IOException, MyException .

Todos tenemos o finalmente escribiremos un código que se detiene inesperadamente e informa una excepción debido a algo que no anticipamos antes de ejecutar el programa, como la división por cero o el índice fuera de límites. Como el método no esperaba los errores, no se podían "capturar" y manejar con una cláusula de captura de prueba. Cualquier usuario confiado del método tampoco sabría de esta posibilidad y sus programas también se detendrían.

Cuando el programador sabe que ciertos tipos de errores pueden ocurrir pero desea manejar estas excepciones fuera del método, el método puede "lanzar" uno o más tipos de excepciones al método de llamada en lugar de manejarlas. Si el programador no declaró que el método (podría) lanzar una excepción (o si Java no tenía la capacidad de declararlo), el compilador no podría saberlo y estaría en manos del futuro usuario del método, atrapa y maneja cualquier excepción que el método pueda lanzar. Dado que los programas pueden tener muchas capas de métodos escritos por muchos programas diferentes, se hace difícil (imposible) hacer un seguimiento de qué métodos podrían generar excepciones.

A pesar de que Java tiene la capacidad de declarar excepciones, aún puede escribir un nuevo método con excepciones no manejadas y no declaradas, y Java lo compilará y podrá ejecutarlo y esperar lo mejor. Lo que Java no te permitirá hacer es compilar tu nuevo método si usa un método que ha sido declarado como excepción (es) de lanzamiento, a menos que manejes la (s) excepción (es) declarada (s) en tu método o declares que tu método es el mismo. excepción (es) o si hay varias excepciones, puede manejar algunas y tirar el resto.

Cuando un programador declara que el método lanza un tipo específico de excepción, es solo una forma automática de advertir a otros programadores que usan el método que es posible una excepción. El programador puede decidir manejar la excepción o pasar la advertencia declarando que el método de llamada también lanza la misma excepción. Dado que se advirtió al compilador que la excepción es posible en este nuevo método, puede verificar automáticamente si los futuros llamadores del nuevo método manejan la excepción o la declaran y hacen que suceda uno u otro.

Lo bueno de este tipo de solución es que cuando el compilador informa Error: Unhandled exception type java.io.IOException no Error: Unhandled exception type java.io.IOException , proporciona el archivo y el número de línea del método que se declaró para lanzar la excepción. Luego, puede elegir simplemente pasar la pelota y declarar que su método también "lanza IOException". Esto se puede hacer hasta el método principal, lo que provocaría que el programa se detuviera e informara la excepción al usuario. Sin embargo, es mejor atrapar la excepción y tratarla de una manera agradable, como explicando al usuario lo que ha sucedido y cómo solucionarlo. Cuando un método captura y maneja la excepción, ya no tiene que declarar la excepción. La pelota se detiene ahí por así decirlo.

Answer 4

Exception es una clase de excepción comprobada. Por lo tanto, cualquier código que llame a un método que declare que throws Exception debe manejarlo o declararlo.

Answer 5

package javaexception;


public class JavaException {
   void show() throws Exception
    {
        throw new Exception("my.own.Exception");
    }

void show2() throws Exception  // Why throws is necessary here ?
{
    show();
}

void show3() throws Exception  // Why throws is necessary here ?
{
    show2();
}
public static void main(String[] args) {

   JavaException a = new JavaException();

   try{
   a.show3();
   }catch(Exception e){
       System.out.println(e.getMessage());
   }
}

Sólo pequeños cambios en su programa. Lo que parece ser malinterpretado por muchos en relación con el problema principal, es que cada vez que lanza una excepción necesita manejarlo, no es necesario en el mismo lugar (por ejemplo, el método show1,2,3 en su programa), pero primero debe hacerlo. dentro de la ''principal''. en una palabra, hay "lanzar", debe haber "captura / intento", incluso si no es el mismo método donde ocurre la excepción.

Answer 6

void show() throws Exception
{
    throw new Exception("my.own.Exception");
}

Como hay una excepción verificada en el método show (), que no se está manejando en ese método, usamos la palabra clave throws para propagar la excepción.

void show2() throws Exception //Why throws is necessary here ?
{
show();
}

Ya que está usando el método show () en el método show2 () y ha propagado la excepción, al menos debe estar manejando aquí. Si no está manejando la excepción aquí, entonces está usando la palabra clave throws. Así que esa es la razón para usar la palabra clave throws en la firma del método.