web-dev-qa-db-fra.com

Est-il possible d'ignorer une exception?

En Java, est-il possible de ne pas vérifier une méthode qui a une instruction throws? 

Par exemple:

public class TestClass {
    public static void throwAnException() throws Exception {
        throw new Exception();
    }
    public static void makeNullPointer() {
        Object o = null;
        o.equals(0);//NullPointerException
    }
    public static void exceptionTest() {
        makeNullPointer(); //The compiler allows me not to check this
        throwAnException(); //I'm forced to handle the exception, but I don't want to
    }
}
javaexceptionexception-handling
27
Runemoro

Vous pouvez essayer de ne rien faire à ce sujet:

public static void exceptionTest() {
    makeNullPointer(); //The compiler allows me not to check this
    try {
        throwAnException(); //I'm forced to handle the exception, but I don't want to
    } catch (Exception e) { /* do nothing */ }
}

Gardez à l'esprit que, dans la vie réelle c'est extrêmement peu conseillé. Cela peut cacher une erreur et vous garder à la recherche de chiens toute une semaine alors que le problème était vraiment un chat (ch).  (Allez, mettez au moins un System.err.println() - La journalisation est la meilleure pratique ici, comme suggéré par @BaileyS.)

Exceptions non vérifiées en Java étendre la classe RuntimeException. Les lancer ne demandera pas une catch à leurs clients:

// notice there's no "throws RuntimeException" at the signature of this method
public static void someMethodThatThrowsRuntimeException() /* no need for throws here */ {
    throw new RuntimeException();
}

Les classes qui étendent RuntimeException ne nécessiteront pas non plus de déclaration throws.

Et un mot d'Oracle à ce sujet:

Voici la ligne directrice: Si un client peut raisonnablement s'attendre à récupérer d'une exception, faites-en une exception vérifiée. Si un client ne peut rien faire pour récupérer de l'exception, faites-en une exception non contrôlée.

52
acdcjunior

En Java, il existe deux types de Exceptions , Exceptions vérifiées et Exceptions non vérifiées.

  • Exception est une exception vérifiée, doit être capturée ou lancée. 
  • NullPointerException est une RuntimeException , (le compilateur ne les oblige pas à être déclaré dans les jets de Noël), vous pouvez l'ignorer, mais cela peut toujours se produire dans Runtime, et votre l'application va planter.

De Exception documentation:

La classe Exception et toutes les sous-classes qui ne sont pas également des sous-classes de RuntimeException sont des exceptions vérifiées. Les exceptions vérifiées doivent être déclarés dans une méthode ou une clause de constructeur du constructeur s'ils peuvent être levé par l'exécution de la méthode ou du constructeur et propager en dehors de la méthode ou du constructeur.

À partir de RuntimeException documentation:

RuntimeException est la superclasse de ces exceptions pouvant être levé pendant le fonctionnement normal de la machine virtuelle Java.

RuntimeException et ses sous-classes sont des exceptions non contrôlées . Les exceptions non vérifiées ne doivent pas nécessairement être déclarées dans une méthode ou La clause throws du constructeur si elles peuvent être lancées par l'exécution de la méthode ou le constructeur et se propager en dehors de la méthode ou limite du constructeur.

3
tarrsalah

Vous pouvez faire 3 choses:

  • Jetez une RuntimeException (ou quelque chose qui étend une RuntimeException, comme NullPointerException, IllegalArgumentException, ...), vous n'avez pas à les intercepter car il s'agit d'exceptions non vérifiées.

  • Catch l'exception et ne rien faire (non recommandé):

    public static void exceptionTest() {
    makeNullPointer(); //The compiler allows me not to check this
    try {
        throwAnException(); //I'm forced to handle the exception, but I don't want to
    } catch (Exception e) {
        // Do nothing
    }
}

  • Modifiez la déclaration exceptionTest () pour indiquer qu'elle jette une Exception et laissez la méthode qui l'appelle capturer la Exception et faire ce qui est approprié:

    public static void exceptionTest() throws Exception {
    makeNullPointer(); //The compiler allows me not to check this
    throwAnException(); //I'm no more forced to handle the exception
}
3
Florent Bayle

Vous pouvez utiliser une échappatoire dans le compilateur Java. Ajoutez le code suivant:

public RuntimeException hideThrow(Throwable e) {
    if (e == null)
        throw new NullPointerException("e");
    this.<RuntimeException>hideThrow0(e);
    return null;
}

@SuppressWarnings("unchecked")
private <GenericThrowable extends Throwable> void hideThrow0(Throwable e) throws GenericThrowable {
    throw (GenericThrowable) e;
}

Vous pouvez attraper l'exception, puis invoquer hideThrow avec l'exception pour la lancer sans que le compilateur s'en aperçoive. Cela fonctionne à cause de l'effacement du type. À la compilation, GenericThrowable représente RuntimeException car c'est ce que nous sommes en train de passer. Au moment de l'exécution, GenericThrowable représente Throwable car il s'agit du type de base dans la spécification du paramètre type.

3
Bailey Ridley

Non, cela génère une erreur du compilateur. En tant qu’exception cochée, vous devez l’attraper ou la propager en déclarant que votre méthode le jette potentiellement . Vérifiez this et this .

2
LexLythius

Comme je sais, c'est impossible dans le cas. Seule exception non cochée, le compilateur peut ignorer pour vérifier. tels que RuntimeException.

1
Stony

Jetez une RuntimeException ou une exception dérivée de RuntimeException. Ensuite, le compilateur ne vous obligera pas à l'attraper.

1
user93353

Attrapez juste une exception et ne faites rien avec elle, laissez-la telle quelle et attrapez l'exception générique si vous ne connaissez pas l'exception spécifique

try{
//Your logic goes here
}
catch(Exception e)//Exception is generic
{
//do nothing
}
1
Rahul Saksule

Il n'est pas conseillé d'éviter une exception avec un bloc catch vide, même si vous êtes absolument sûr que cela ne va pas échouer en aucune circonstance. Parfois, nous ne sommes pas conscients du facteur humain.

Si vous êtes certain qu'il est très peu probable qu'une exception se produise (voire impossible), vous devez créer votre propre exception et y insérer l'exception inattendue.

Par exemple:

private class UnlikelyException extends RuntimeException {
    public UnlikelyException (Exception e){
        super (e);
    }
}

Enveloppez ensuite votre code avec un bloc try-catch et lancez votre exception, que vous n'avez pas à intercepter.

try {
    // Your code
} catch  (Exception e) {
    throw new UnlikelyException(e);
}
0
JCalcines