java - tipos - Manejo de excepciones: lanzar, lanzar y Throwable

tipos de excepciones en java netbeans

Question

¿Puede alguno de ustedes explicar cuáles son las diferencias entre throw , throws y throws y cuándo usar qué?

Answer 1

Esto realmente fácil de entender.

Java.lang.Throwable :

La clase Throwable es la superclase de todos los errores y excepciones en el lenguaje Java. Solo los objetos que son instancias de esta clase (o una de sus subclases) son lanzados por la Máquina Virtual de Java o pueden ser lanzados por la declaración Java throw . De forma similar, solo esta clase o una de sus subclases puede ser el tipo de argumento en una cláusula catch . More

La palabra clave throws se usa en la declaración del método, esto especifica qué clase de excepción [Throwable class] podemos esperar de este método.

La palabra clave throw se usa para lanzar un objeto que es instancia de la clase Throwable.

Para que no vea un ejemplo:

Nos creamos una clase de excepción

public class MyException super Exception {

}

Creamos un método que crea un objeto a partir de nuestra clase de excepción y lo lanza usando el lanzamiento de palabras clave.

private  void throwMeAException() throws MyException //We inform that this method throws an exception of MyException class
{
  Exception e = new MyException (); //We create an exception 

  if(true) {
    throw e; //We throw an exception 
  } 
}

Cuando vamos a usar el método throwMeAException() , nos vemos obligados a ocuparnos de él de manera específica porque tenemos la información de que arroja algo, en este caso tenemos tres opciones.

La primera opción es usar block try y catch para manejar la excepción:

private void catchException() {

   try {
     throwMeAException();
   }
   catch(MyException e) {
     // Here we can serve only those exception that are instance of MyException
   }
}

La segunda opción es pasar la excepción

   private void passException() throws MyException {

       throwMeAException(); // we call the method but as we throws same exception we don''t need try catch block.

   }

La tercera opción es atrapar y volver a lanzar la excepción

private void catchException() throws Exception  {

   try {
     throwMeAException();
   }
   catch(Exception e) {
      throw e;
   }
}

Reanudando, cuando necesites detener alguna acción, puedes lanzar la Excepción que volverá hasta que no sea servidor mediante algún bloque try-catch. Donde sea que use el método que arroje una excepción, debe manejarlo mediante el bloqueo try-catch o agregar las declaraciones a sus métodos.

La excepción de esta regla son java.lang.RuntimeException que no tienen que declararse. Esta es otra historia como el aspecto del uso de excepciones.

Answer 2

Hay 2 tipos principales de excepciones:
Excepciones de tiempo de ejecución (sin marcar) : ej. NullPointerException, ClassCastException, ..
Excepciones marcadas: ej. FileNotFoundException, CloneNotSupportedException, ..

Las excepciones de tiempo de ejecución son excepciones que ocurren en tiempo de ejecución y el desarrollador no debe intentar atraparlo o detenerlo. Solo se escribe el código para evitarlos o se emite un lanzamiento de comando cuando se cumplen los criterios de error. Usamos throw dentro del cuerpo del método.

public Rational(int num, int denom){
if(denom <= 0) {
  throw new IllegalArgumentException("Denominator must be positive");
}
this.num=num;
this.denom=denom;
}

Sin embargo, para las excepciones controladas, la JVM espera que usted lo maneje y dará error de compilación si no se maneja, por lo que declara que arroja ese tipo de excepción como se ve a continuación en el método clone ().

Class Employee{
public Employee clone() throws CloneNotSupportedException{
    Employee copy = (Employee)super.clone();
    copy.hireDate = (Date)hireDate.clone();
    return copy;
}
}

Answer 3

La misma respuesta que arriba, pero con el placer de copiar y pegar :

public class GsonBuilderHelper {
    // THROWS: method throws the specified (checked) exception
    public static Object registerAndRun(String json) throws Exception {

        // registering of the NaturalDeserializer
        GsonBuilder gsonBuilder = new GsonBuilder();
        gsonBuilder.registerTypeAdapter(Object.class, new NaturalDeserializer());
        Gson gson = gsonBuilder.create();

        Object natural = null;
        try {
            // calling the NaturalDeserializer
            natural = gson.fromJson(json, Object.class);
        } catch (Exception e) {
            // json formatting exception mainly
            Log.d("GsonBuilderHelper", "registerAndRun(json) error: " + e.toString());
            throw new Exception(e);  // <---- THROW: instance of class Throwable. 
        }
        return natural;
    }
}

Answer 4

Listado pocos ...

Lanzar

1. La palabra clave Java throw se usa para throw explícitamente una excepción.
2. La excepción comprobada no se puede propagar utilizando throw only.
3. Throw es seguido por una instancia.
4. Throw se usa dentro del método.
5. No puedes throw múltiples excepciones.

Lanzamientos

1. La palabra clave Java throws se usa para declarar una excepción.
2. La excepción controlada se puede propagar con throws .
3. Throws seguido de clase.
4. Throws se usa con la firma del método.
5. Puede declarar múltiples excepciones, por ejemplo, public void method()throws IOException,SQLException

Answer 5

throw: se usa para lanzar una excepción. La instrucción throw requiere un único argumento: un objeto de clase arrojable

throws - Esto se usa para especificar que el método puede arrojar una excepción

Throwable: esta es la superclase de todos los errores y excepciones en el lenguaje Java. puedes lanzar solo objetos que se derivan de la clase Throwable. throwable contiene una instantánea de la pila de ejecución de su hilo en el momento de su creación

Answer 6

Throw se utiliza para arrojar excepciones, throws (si lo supuse correctamente) se usa para indicar que el método puede lanzar una excepción particular, y la clase Throwable es la superclase de todos los errores y excepciones en Java

Cómo lanzar excepciones

Answer 7

Throwable : en Java, todas las clases de error y de execption están agotadas de la clase java.lang.Throwable. Es la parte superior de la jerarquía de clases de error y excepciones. Solo los objetos que son instancias de esta clase (o una de sus subclases) son lanzados por la Máquina Virtual de Java o pueden ser lanzados por la declaración Java throw.

Throws: es un modificador posterior al método y especifica qué ejecuciones puede lanzar el método. Si se marcan excepciones, el compilador garantizará que el código que invoca ese método debe capturar estas excepciones marcadas.

Throw: statement se utiliza para arrojar un error o excepciones. La instrucción throw requiere un único argumento: una instancia de cualquier subclase de la clase Throwable o Throwable. La ejecución de la instrucción de lanzamiento activa la JVM para lanzar esta excepción y hace que se produzca una excepción.

Answer 8

Lanzar :

se usa para lanzar la excepción, mientras que throws es declarativo para el método. No son intercambiables.

throw new MyException("Exception!);

Lanza:

Esto se usará cuando no esté usando la declaración try catch en su código, pero usted sabe que esta clase en particular es capaz de arrojar una excepción (solo excepciones marcadas). En esto no usa el bloque try catch pero escribe usando la cláusula throw en el punto apropiado de su código y la excepción se lanza al llamador del método y es manejada por él. También se utiliza la palabra clave throws cuando la función puede arrojar una excepción marcada.

public void myMethod(int param) throws MyException 

Answer 9

• throw : instrucción para lanzar el objeto t donde t instanceof java.lang.Throwable debe ser verdadero.
• throws : un token de firma de método para especificar excepciones marcadas throw n por ese método.
• java.lang.Throwable : el tipo principal de todos los objetos que se pueden lanzar (y atrapar).

Vea aquí un tutorial sobre el uso de excepciones.

Answer 10

• throws : se usa cuando se escriben métodos, para declarar que el método en cuestión arroja la excepción especificada (marcada).

  A diferencia de las excepciones comprobadas, las excepciones de tiempo de ejecución (NullPointerExceptions, etc.) se pueden lanzar sin que el método declare throws NullPointerException .

• throw : instrucciones para lanzar la excepción. (O más específicamente, el Throwable ).

  La palabra clave throw viene seguida de una referencia a Throwable (generalmente una excepción).

Ejemplo:

• Throwable : una clase que debes ampliar para crear la tuya propia, personalizada, desechable.

Ejemplo:

• Excepción oficial-tutorial