java - todas - ¿Hay alguna forma de lanzar una excepción sin agregar la declaración throws?

todas las excepciones en java

Question

Tengo la siguiente situación.

Tengo una clase Java que hereda de otra clase base y anula un método. El método base no arroja excepciones y, por lo tanto, no tiene throws ... declaration.

Ahora mi propio método debería ser capaz de lanzar una excepción, pero o bien tengo la elección de

• Tragar la excepción
• Agregar una declaración de lanzamientos

Ambas cosas no son satisfactorias porque la primera ignoraría silenciosamente la excepción (vale, podría realizar algunos registros) y la segunda generaría errores de compilación debido a los diferentes encabezados de métodos.

public class ChildClass extends BaseClass {

        @Override 
        public void SomeMethod() {
            throw new Exception("Something went wrong");
        }
}

Answer 1

¿Por qué no lanzas una excepción sin marcar? Esto no tiene que ser declarado.

Dos alternativas son

• envolver con una excepción marcada con una desactivada.
• no permita que el compilador sepa que está lanzando una excepción marcada p. ej. Thread.currentThread (). stop (e);
• En Java 6, puede volver a lanzar la excepción si es final y el compilador sabe qué excepciones comprobadas puede haber atrapado.
• En Java 7, puede volver a lanzar una excepción si es efectivamente definitiva, es decir, no la cambia en el código.

Lo posterior es más útil cuando lanza una excepción de verificación en su código y lo captura en su código de llamada, pero las capas intermedias no saben nada sobre la excepción.

Answer 2

Aquí hay un ejemplo para interceptar excepciones comprobadas y envolverlas en una excepción sin marcar:

public void someMethod() {
   try {
      doEvil();
   }
   catch (IOException e)
   {
       throw new RuntimeException(e);
   }
}

Answer 3

Aquí hay un truco:

class Utils
{
    @SuppressWarnings("unchecked")
    private static <T extends Throwable> void throwException(Throwable exception, Object dummy) throws T
    {
        throw (T) exception;
    }

    public static void throwException(Throwable exception)
    {
        Utils.<RuntimeException>throwException(exception, null);
    }
}

public class Test
{
    public static void main(String[] args)
    {
        Utils.throwException(new Exception("This is an exception!"));
    }
}

Answer 4

Puede lanzar excepciones sin marcar sin tener que declararlas si realmente lo desea. Las excepciones no RuntimeException amplían RuntimeException . Los objetos acumulables que extienden el Error tampoco están marcados, pero solo deben usarse para problemas realmente graves (como el bytecode no válido).

Como un caso específico, Java 8 agregó UncheckedIOException para envolver y volver a lanzar IOException .

Answer 5

Puede usar cualquier excepción derivada de RuntimeException o RuntimeException

o

utiliza un try-block para el código de lanzamiento de excepción y maneja allí

Answer 6

Sí, hay un por qué, pero no se recomienda en absoluto que pueda usar:

Paquete inseguro de Java

getUnsafe().throwException(new IOException());

Este método arroja una excepción marcada, pero su código no está forzado a atraparlo o volver a lanzarlo. Al igual que la excepción de tiempo de ejecución.

Answer 7

Solo quiero agregar una respuesta alternativa, puramente como un FYI :

Sí, hay una forma de lanzar una excepción marcada sin agregar la declaración de throws , usando la clase sun.misc.Unsafe . Esto se describe en la siguiente publicación del blog:

Lanzar una excepción marcada de un método sin declararlo

Código de muestra:

public void someMethod() {
  //throw a checked exception without adding a "throws"
  getUnsafe().throwException(new IOException());
}

private Unsafe getUnsafe() {
  try {
    Field field = Unsafe.class.getDeclaredField("theUnsafe");
    field.setAccessible(true);
    return (Unsafe) field.get(null);
  } catch (Exception e) {
    throw new RuntimeException(e);
  }
}

Como sea, esto no es recomendable. Es mejor incluir una excepción sin marcar como se describe en algunas de las otras respuestas.

Answer 8

Una tercera opción es optar por la excepción de comprobación (al igual que la API estándar tiene que hacer a veces) y ajustar la excepción marcada en una RuntimeException :

throw new RuntimeException(originalException);

Es posible que desee utilizar una subclase más específica de RuntimeException .

Answer 9

puede capturar la excepción con el bloqueo try-catch en su método anulado. entonces no necesitas declarar throws- statement.