Pour gérer les exceptions dans les applications Java, vous devez identifier clairement le moment de la capture et du lancer et d'organiser raisonnablement le code. 1. Utilisez des coups d'essai mais pas en abuser. Il n'est capturé que lorsque les exceptions peuvent être manipulées, sinon elle doit être lancée; 2. Multi-capch peut être utilisé pour le traitement unifié de plusieurs exceptions, simplifiant le code mais faisant attention au traitement différencié de différentes exceptions; 3. Les exceptions personnalisées améliorent la lisibilité, hériter des exceptions ou RuntimeException dépend des besoins commerciaux; 4. Finalement utilisé pour le nettoyage des ressources, mais la priorité est donnée à l'utilisation de ressources TRYS-With pour gérer automatiquement les ressources. La ma?trise de ces points clés peut rendre le code de traitement plus clair et plus robuste des exceptions.

Gestion des exceptions dans les applications Java est en fait une tache très courante. La clé est d'être clair quand attraper, quand lancer et comment organiser le code afin que la gestion des exceptions ne semble pas désordonnée. Les points suivants sont des suggestions plus pratiques dans le développement réel.

Utilisez des coups d'essai mais ne vous en abusez pas

Try-Catch est la base de la gestion des exceptions Java, mais tout ne sera pas bien si vous le mettez sur une couche. Par exemple, lorsque vous rencontrez IOException lorsque vous lisez le contenu du fichier, il est logique de l'attraper; Mais si vous appelez simplement une méthode qui peut lancer des exceptions et ne savez pas comment y faire face, il est préférable de le lancer.

Par exemple:

 essayer {
    String Content = Files.ReadString (Path);
} catch (ioexception e) {
    System.err.println ("Read a échoué:" e.getMessage ());
}

Dans ce cas, vous savez déjà quoi faire après une erreur (comme enregistrer un journal ou inviter l'utilisateur), alors ce n'est pas un problème d'ajouter Catch. Mais si la pile est juste imprimée dans la prise, elle peut couvrir le problème et il sera difficile de dépanner.

Le multi-efforts peut être utilisé pour le traitement unifié de plusieurs exceptions

Parfois, une opération peut lancer plusieurs types d'exceptions différents, tels que les demandes de réseau peuvent avoir des délais de connexion, des erreurs IO, etc. Java 7 a commencé à prendre en charge la gestion de plusieurs types d'exceptions dans le même bloc de capture, et la méthode d'écriture est également plus simple.

 essayer {
    // une opération qui peut lancer une ioException ou SQException} catch (ioException | sqlexception ex) {
    // Traitement unifié}

Cela évite les blocs de capture en double et rend la logique plus claire. Cependant, il convient de noter que si différentes exceptions nécessitent différentes méthodes de manutention, vous devez toujours les attraper séparément.

Exception personnalisée: n'ayez pas peur d'écrire la classe d'exception par vous-même

Bien qu'il existe de nombreux types d'exceptions qui viennent avec le système, il ne peut parfois pas exprimer avec précision les erreurs commerciales. Par exemple, si vous créez un système de commande et que la commande n'est pas valide, vous pouvez personnaliser une InvalidOrderException afin que l'appelant puisse savoir que quelque chose ne va pas en un coup d'?il.

Les exceptions personnalisées héritent généralement RuntimeException ou Exception , et décidez de forcer le traitement:

• Si vous voulez que l'appelant ait à le gérer, héritez Exception
• S'il s'agit d'une erreur d'exécution et ne veut pas forcer les autres à essayer, hériter de RuntimeException

C'est également très facile à utiliser:

 if (order.gettotalprice () <= 0) {
    Jetez un nouvel invalidorDereXception ("Le montant de l&#39;ordre ne peut pas être nul ou négatif");
}

Cela rend non seulement la logique claire, mais améliore également la lisibilité du code.

Enfin et essai avec les ressources pour distinguer le but

Le bloc enfin est utilisé pour effectuer des travaux de nettoyage, tels que la fermeture du flux et la libération de ressources, et sera exécuté, qu'il existe des exceptions ou non. Cependant, Java 7 a introduit la méthode d'écriture TRY-With-Resources, qui convient plus pour gérer automatiquement les ressources sans avoir à écrire manuellement.

Par exemple, écriture traditionnelle:

 BufferedReader Reader = NULL;
essayer {
    Reader = new BufferedReader (nouveau FileReader ("file.txt"));
    // Lire le contenu} catch (ioException e) {
    // gérer l'exception} enfin {
    if (lecteur! = null) {
        essayer {
            Reader.Close ();
        } catch (ioexception e) {
            // ignorer ou enregistrer}
    }
}

Et utiliser des ressources TRY-With est beaucoup plus propre:

 Try (BufferedReader Reader = new BufferedReader (new FileReader ("file.txt"))) {
    // Lire le contenu} catch (ioException e) {
    // gérer l'exception}

Remarque: seules les ressources qui implémentent l'interface AutoCloseable peuvent être utilisées de cette manière.

Fondamentalement, c'est tout. Le mécanisme d'exception de Java est con?u assez flexible. La clé est de choisir la méthode de manutention raisonnablement selon la scène, de ne pas attraper toutes les exceptions à la fois, et de ne pas lancer du tout RuntimeException. En triant ces détails, le code sera plus robuste et plus facile à entretenir.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!