Comment éviter de nombreux blocs try catch en java

L'idée de la gestion des exceptions est que vous pouvez gérer les erreurs à points dans votre flux de programme où vous pouvez traiter avec eux de manière significative. Plutôt que de vérifier chaque valeur renvoyée de la fonction comme dans C, où la plupart du temps vous ne pouvez pas faire quelque chose de sensé autre que le passage de l'erreur plus haut, vous installez un bloc try/catch au sensible points dans votre programme:

En gros, quand il y a un point où vous peut réagir de façon significative à une erreur, puis rattraper cette erreur, et passer tout le reste. De cette façon, la gestion des erreurs n'est invoquée lorsqu'il est plausible de la récupération de l'erreur.

Par exemple, dans le pire des cas si tout erreur s'arrête votre programme de s'exécuter de façon significative, alors vous pourriez presque pas attraper quelque chose à tous et de laisser le système d'exploitation de gérer la situation (bien, peut-être un seul try/catch pour produire un sympathique message d'erreur).

Exemple (en C++, désolé, j'ai pas de type de Java à l'aveugle):

int main()
{
  try {
    while (masterloop()) { }
  catch (...) {
    LOG("Fatal program error, terminating!"); //nothing else we can do!
  }
}

/* lots of program logic */

void process_image()
{
  try {
    Image im = load_image_from_disk();
    /* ... */
  }
  catch (const OutOfMemoryExc & e) {
    LOG("Not enough memory to process the image.");
    return;
  }
  catch (const DataErrorExc & e) {
    LOG("Could not read the image data.");
    return;
  }
  catch (...) {
    throw; //pass everything else along
  }
}

Dans cet exemple, on peut essayer de traiter une image et l'échec de certains anticipable raisons (manque de mémoire, ou de l'échec à la lecture de l'image). Dans ce cas, nous venons de rentrer sans faire le travail et de laisser le programme continuer normalement. Toutes les autres erreurs sont propagées jusqu'à un point plus élevé. Plus important encore, nous ne pas besoin de salir la réelle fonction de traitement d'image avec des contrôles d'erreur et les réponses tout le temps, il suffit, pour que tout le code de là à jeter l'un de nos deux bonnes exceptions et ne pas s'inquiéter davantage.

Moral: Si vous avez des blocs try/catch absolument partout, vous le faites mal.

Vous pouvez prendre plusieurs exceptions dans le même essayez par exemple

try{

  xyz;

}catch(NullPointerException npx){
  npx.getMessage();
}catch(ArrayOutOfBoundsException ax){
  ax.getMessage();
}

Aussi, en déclarant l'Exception que throws dans vos signatures de méthode, vous pouvez passer l'Exception de la pile.

Si vous avez un bloc de code dans lequel plus d'un type d'exception peut être levée, vous pouvez déclarer les deux blocs catch:

try {
    JSONObject jsonObject = new JSONObject(jsonString);
    int aCount = jsonObject.getInt("acount");
    String devTok = jsonObject.getString("dt");
    String qURL = jsonObject.getString("qu");

    DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
    Key qKey = KeyFactory.createKey("qu", qURL);
    int dsACount = (Integer) datastore.get(qKey).getProperty(kLastKnownANumber);
} catch (EntityNotFoundException e) {
    e.printStackTrace();
} catch (com.google.appengine.repackaged.org.json.JSONException e) {
    e.printStackTrace();
}
//..etc.. as many catch blocks as needed

Alternativement, si vous n'avez pas de soins sur le type exact de l'exception, vous pouvez avoir onyl un bloc catch qui attrape Exception (ou peut-être Throwable; je ne me souviens pas exactement ce que la super-classe d'exceptions en Java).

Un autre point que je vais faire maintenant, c'est que vous pourriez ne pas avoir la plupart du code modulaire. Rappelez-vous, le code qui fait une chose bien fait pour de bon, code modulaire. Si vous trouvez que vous avez beaucoup de imbriquée noir (si les blocs try/catch, si/d'autre blocs, etc.) vous voudrez peut-être vérifier si le code peut être extraite dans sa propre méthode. Cela peut également rendre votre code plus belle lorsque de nombreuses exceptions qui doivent être gérés.

Vous devez utiliser les blocs try/catch si vous avez un moyen de le récupérer à partir de l'exception, par exemple, si vous voulez vérifier si une chaîne est un entier valide, vous pouvez écrire une méthode (c'est une lame de méthode, mais juste pour montrer l'idée):

public boolean isInteger(String str) {
    try {
        new Integer(str);
    }
    catch(NumberFormatException e) {
        return false;
    }
    return true;
}

Si vous n'avez pas de moyen de récupérer de l'exception et tout ce que vous faire est d'imprimer la trace de la pile, il est proposé d'ajouter jette déclaration (comme eclipse proposer) à la méthode, et l'appelant de gérer l'exception (ou de le jeter à son appelant).

Si vous souhaitez gérer des exceptions, et de jeter quelques autres, vous pouvez le faire aussi bien.

Vous avez deux code de base de style de choix ici (qui n'impliquent pas de changement de méthode de signatures)

Method1: Mettre le tout dans une try catch et ont plusieurs blocs catch, comme ceci:

try {
    JSONObject jsonObject = new JSONObject(jsonString);
    int aCount = jsonObject.getInt("acount");
    String devTok = jsonObject.getString("dt");
    String qURL = jsonObject.getString("qu");
    DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
    Key qKey = KeyFactory.createKey("qu", qURL);
    int dsACount = (Integer) datastore.get(qKey).getProperty(kLastKnownANumber);
    //..etc.. more try catch blocks needed
} catch (EntityNotFoundException e) {
    e.printStackTrace();
} catch (com.google.appengine.repackaged.org.json.JSONException e) {
    e.printStackTrace();
}

Méthode 2: Casser votre code en sections qui ont chacune une catch, comme ceci:

String qURL = null;
try {
    JSONObject jsonObject = new JSONObject(jsonString);
    int aCount = jsonObject.getInt("acount");
    String devTok = jsonObject.getString("dt");
    String qURL = jsonObject.getString("qu");
} catch (EntityNotFoundException e) {
    e.printStackTrace();
} 

try {    
    DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
    Key qKey = KeyFactory.createKey("qu", qURL);
    int dsACount = (Integer) datastore.get(qKey).getProperty(kLastKnownANumber);
} catch (EntityNotFoundException e) {
    e.printStackTrace();
} 

La méthode 2 est celui qui est recommandé, comme il est évident que les lignes sont en jetant des exceptions et généralement les segments du code dans les blocs de traitement.