Plongée en profondeur dans les exceptions Java

Classe d'exceptions Java Core

hiérarchie des classes d'exception : Throwable < Erreur < Exception où le Throwable est la superclasse

Jetable

La classe Throwable est la superclasse de toutes les erreurs et exceptions du langage Java. Seuls les objets qui sont des instances de cette classe (ou de l'une de ses sous-classes) sont lancés par la machine virtuelle Java ou peuvent être lancés par l'instruction Java throw. référence

En pratique, Throwable n'est généralement pas utilisé directement par les développeurs. Au lieu de cela, il sert de base à ses deux sous-classes directes : Erreur et Exception.

try {
 // some process
} catch (Throwable t) {
    throw new Throwable(t);
}

Erreur

Une erreur est une sous-classe de Throwable qui indique des problèmes graves qu'une application raisonnable ne devrait pas essayer de détecter. Les erreurs représentent généralement des conditions anormales qui se produisent dans la référence JVM elle-même

Une condition anormale signifie que le problème provient généralement de facteurs indépendants de la volonté de l'application et est généralement irrécupérable. Ex : OutOfMemoryError, StackOverflowError

Exception

L'exception fait référence à un événement ou à une condition inattendue qui se produit lors de l'exécution d'un programme, et nous devrions essayer de catch. En détectant les exceptions, nous devrions être en mesure de gérer les situations inattendues avec élégance, en garantissant que le programme ne plante pas.

int[] arr = {1, 2, 3};
try {
    System.out.println(arr[3]); // This will throw ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Unchecked Exception: " + e.getMessage());
}

 

Types d'exceptions

Il existe 2 types d’exceptions en Java. référence

Exceptions vérifiées

L'exception vérifiée est comme une situation dont vous savez qu'elle pourrait mal tourner, vous devez donc la planifier. Ils doivent soit être interceptés à l'aide d'un bloc try-catch, soit être déclarés dans la signature de la méthode avec une clause throws. Si une méthode peut lever une exception vérifiée et que vous ne la gérez pas, le programme ne compilera pas.

// Checked exception
try {
    readFile("nonexistent.txt");
} catch (FileNotFoundException e) {
    System.out.println("Checked Exception: " + e.getMessage());
}

// Checked exception
public void getData() throws SQLException { // throw SQLException
    throw new SQLException("err");
}

Exception non vérifiée

Exceptions non vérifiées, alias. les exceptions d'exécution sont des exceptions que le compilateur Java ne nécessite pas que vous gériez. Ce sont des sous-classes de RuntimeException. Contrairement aux exceptions vérifiées, ces exceptions n'ont pas besoin d'être interceptées ou déclarées dans la signature de la méthode. Ils indiquent généralement des erreurs de programmation, telles que des défauts logiques, une utilisation incorrecte des API ou des violations des hypothèses du code.

String text = null;
System.out.println(text.length()); // This will throw a NullPointerException

 

Types courants d'exceptions Java

NullPointerException : se produit lorsqu'une application tente d'utiliser une référence d'objet qui n'a pas été initialisée.

String text = null; // text is not initialized
try {
    System.out.println(text.length()); // Attempting to call length() on a null reference
} catch (NullPointerException e) {
    System.out.println("Caught a NullPointerException: " + e.getMessage());
}

ArrayIndexOutOfBoundsException : levée lors d'une tentative d'accès à un tableau avec un index illégal.

int[] numbers = {1, 2, 3};
try {
    int value = numbers[5]; // Attempting to access index 5, which is out of bounds
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Caught an ArrayIndexOutOfBoundsException: " + e.getMessage());
}

IllegalArgumentException : levée lorsqu'une méthode reçoit un argument inapproprié.

public class IllegalArgumentExample {
    public static void setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative"); // Illegal argument
        }
        System.out.println("Age set to: " + age);
    }

    public static void main(String[] args) {
        try {
            setAge(-5); // Passing a negative age, which is illegal
        } catch (IllegalArgumentException e) {
            System.out.println("Caught an IllegalArgumentException: " + e.getMessage());
        }
    }
}

 

Comment gérer les exceptions

Essayer-Catch

Utilisez try-catch lorsque vous souhaitez gérer des exceptions spécifiques qui pourraient être générées dans un bloc de code

try {
    int result = 10 / 0; // This will throw ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("Caught an ArithmeticException: " + e.getMessage());
}

Multi-prises

Utilisez multi-catch lorsque vous souhaitez gérer plusieurs types d'exceptions de la même manière

try {
    String str = null;
    System.out.println(str.length()); // This will throw NullPointerException
} catch (NullPointerException | ArrayIndexOutOfBoundsException e) {
    System.out.println("Caught an exception: " + e.getMessage());
}

Essayer avec les ressources

Utilisez try-with-resources lorsque vous travaillez avec des ressources qui doivent être fermées après utilisation, telles que des fichiers, des sockets ou des connexions à une base de données.

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    System.out.println("Caught an IOException: " + e.getMessage());
}

Enfin

Utilisez le bloc enfin lorsque vous devez vous assurer que certains codes s'exécutent, qu'une exception ait été levée ou non

try {
    file = new FileReader("file.txt");
} catch (IOException e) {
    System.out.println("Caught an IOException: " + e.getMessage());
} finally {
    if (file != null) {
        file.close(); // Ensure the file is closed
    }
}

 

Meilleures pratiques pour la gestion des exceptions

Ne pas ignorer les exceptions : les exceptions doivent être traitées de manière appropriée, pas seulement détectées et ignorées.

try {
    file = new FileReader("file.txt");
} catch (IOException ignored) {
    // ignored
}

Utiliser des exceptions spécifiques : utilisez des exceptions spécifiques plutôt que des exceptions génériques.

try {
    // Code that may throw exceptions
    String text = null;
    text.length();
} catch (Exception e) {
    // Too broad; will catch all exceptions
    System.err.println("An error occurred: " + e.getMessage());
}

bonne façon de le gérer :

try {
    // Code that may throw exceptions
    String text = null;
    text.length();
} catch (NullPointerException e) {
    // Handle specific exception
    System.err.println("Null pointer exception: " + e.getMessage());
} catch (Exception e) {
    // Handle other exceptions
    System.err.println("An error occurred: " + e.getMessage());
}

Manipulation propre des ressources : fermez toujours les ressources pour éviter les fuites de mémoire

FileReader fileReader = null;
try {
    fileReader = new FileReader("file.txt");
    // Read from the file
} catch (IOException e) {
    System.err.println("File not found: " + e.getMessage());
} finally {
   fileReader.close(); // clouse resources
}

Exceptions personnalisées : créez des exceptions personnalisées lorsque les exceptions standard ne correspondent pas aux conditions d'erreur spécifiques.

// Custom Exception
public class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

// Usage
public class Example {
    public void performOperation() throws CustomException {
        // Some condition
        throw new CustomException("Custom error message");
    }

    public static void main(String[] args) {
        Example example = new Example();
        try {
            example.performOperation();
        } catch (CustomException e) {
            System.err.println("Caught custom exception: " + e.getMessage());
        }
    }
}

Journalisation : journaliser les exceptions pour le débogage et la maintenance.

public class Example {
    private static final Logger logger = Logger.getLogger(Example.class.getName());

    public void riskyMethod() {
        try {
            // Code that may throw an exception
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            // Log the exception
            logger.severe("An arithmetic error occurred: " + e.getMessage());
        }
    }
}

Évitez l'utilisation excessive des exceptions : mettez en garde contre l'utilisation d'exceptions pour contrôler le flux ; ils ne doivent être utilisés que pour gérer des situations vraiment exceptionnelles.

public class Example {
    public void process(int[] array) {
        try {
            // Using exceptions to control flow
            if (array.length < 5) {
                throw new ArrayIndexOutOfBoundsException("Array too small");
            }
            // Process array
        } catch (ArrayIndexOutOfBoundsException e) {
            // Handle exception
            System.out.println("Handled array size issue.");
        }
    }
}

bonne façon de le gérer :

public class Example {
    public void process(int[] array) {
        if (array.length >= 5) {
            // Process array
        } else {
            // Handle the condition without using exceptions
            System.out.println("Array is too small.");
        }
    }
}




<p></p>
<p> <br>
tout commentaire sera utile :)</p>





        <p>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!</p>