mot-clé throw en Java

Le mot-clé throw en Java est utilisé pour lancer explicitement une exception à partir d'une méthode ou d'un bloc de code. Il s'agit d'un élément essentiel du mécanisme de traitement des exceptions de Java, qui permet aux développeurs de créer et de gérer des conditions d'erreur de manière contrôlée.

Utilisation

Le mot-clé throw est généralement utilisé pour lancer des exceptions vérifiées ou non vérifiées. Lorsqu'une exception est levée, le déroulement normal du programme est interrompu et le contrôle est transféré au bloc enveloppant le plus proche try-catch qui peut gérer l'exception.

Syntax

throw new ExceptionType("Error message");Propulsé par

• ExceptionType: Le type d'exception à lever (par exemple, ArithmeticException, NullPointerException).
• "Error message": Un message sous forme de chaîne de caractères fournissant des détails sur l'exception.

Exemples

Exemple 1 : Lancer une exception vérifiée

public class ThrowExample {
    public static void main(String[] args) {
        try {
            checkAge(15);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

    static void checkAge(int age) throws Exception {
        if (age < 18) {
            throw new Exception("Age must be 18 or older.");
        }
    }
}Propulsé par

Dans cet exemple, la méthode checkAge génère une erreur Exception si l'âge fourni est inférieur à 18 ans. La méthode main appelle checkAge à l'intérieur d'un bloc try et capture l'exception, en imprimant le message d'erreur.

Exemple 2 : Lancer une exception non vérifiée

public class ThrowExample {
    public static void main(String[] args) {
        try {
            divide(10, 0);
        } catch (ArithmeticException e) {
            System.out.println(e.getMessage());
        }
    }

    static void divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("Division by zero is not allowed.");
        }
        System.out.println(a / b);
    }
}Propulsé par

Ici, la méthode divide lance un ArithmeticException si le diviseur est zéro. La méthode main capture l'exception et imprime le message d'erreur.

Exemple 3 : Exception personnalisée

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

public class ThrowExample {
    public static void main(String[] args) {
        try {
            validate(0);
        } catch (CustomException e) {
            System.out.println(e.getMessage());
        }
    }

    static void validate(int number) throws CustomException {
        if (number <= 0) {
            throw new CustomException("Number must be greater than zero.");
        }
    }
}Propulsé par

Cet exemple montre comment lancer une exception personnalisée. La méthode validate lance un CustomException si le nombre est inférieur ou égal à zéro, et la méthode main l'attrape et le traite.

Conseils et bonnes pratiques

• Utilisez des messages significatifs: Fournissez toujours des messages significatifs et descriptifs lorsque vous lancez des exceptions afin de faciliter le débogage.

  throw new IllegalArgumentException("Parameter 'x' cannot be negative.");Propulsé par

• Vérifié vs. Exceptions non vérifiées: Utilisez des exceptions contrôlées pour les conditions récupérables et des exceptions non contrôlées (exceptions d'exécution) pour les erreurs de programmation.
• Exceptions personnalisées: Créez des exceptions personnalisées pour représenter des conditions d'erreur spécifiques dans votre application. Cela rend votre code plus lisible et plus facile à maintenir.
• Évitez la surutilisation: N'abusez pas des exceptions pour le flux de contrôle. Ils doivent être utilisés dans des conditions exceptionnelles, et non pour des contrôles conditionnels réguliers.
• Exceptions relatives aux documents: Documentez toujours les exceptions qu'une méthode peut lancer à l'aide de la balise Javadoc @throws.

  /**
   * @throws IllegalArgumentException if the parameter is invalid
   */
  public void someMethod(int param) {
      if (param < 0) {
          throw new IllegalArgumentException("Parameter cannot be negative.");
      }
  }Propulsé par