Questions d'entretien sur les exceptions Java (+ réponses)

Cet article fait partie d'une série: • Questions d'entretien sur les collections Java

• Questions d’entretien sur Java Type System

• Questions d’entretien sur Java Concurrency (+ réponses)

• Questions d'entretien sur la structure des classes Java et l'initialisation

• Questions d'entrevue Java 8 (+ réponses)

• Questions d’entrevue sur la gestion de la mémoire dans Java (+ réponses)

• Questions d'entrevue Java Generics (+ réponses)

• Questions d’entretien sur le contrôle de flux Java (+ réponses)

• Questions d'entretien sur les exceptions Java (+ réponses) (article actuel) • Questions d'entretien sur les annotations Java (+ réponses)

• Principales questions d'entrevue Spring Framework

1. Vue d'ensemble

Les exceptions sont un sujet essentiel que tout développeur Java doit connaître. Cet article fournit des réponses à certaines des questions qui peuvent surgir lors d'un entretien.

2. Questions

Q1. Qu'est-ce qu'une exception?

Une exception est un événement anormal qui se produit pendant l'exécution d'un programme et perturbe le flux normal des instructions du programme.

Q2. Quel est le but des mots-clés Throw and Throws?

Le throws mot - clé permet de spécifier qu'une méthode peut soulever une exception lors de son exécution. Il applique la gestion explicite des exceptions lors de l'appel d'une méthode:

public void simpleMethod() throws Exception { // ... }

Le mot-clé throw nous permet de lancer un objet d'exception pour interrompre le déroulement normal du programme. Ceci est le plus couramment utilisé lorsqu'un programme ne parvient pas à satisfaire une condition donnée:

if (task.isTooComplicated()) { throw new TooComplicatedException("The task is too complicated"); }

Q3. Comment gérer une exception?

En utilisant une instruction try-catch-finally :

try { // ... } catch (ExceptionType1 ex) { // ... } catch (ExceptionType2 ex) { // ... } finally { // ... }

Le bloc de code dans lequel une exception peut se produire est inclus dans un bloc try . Ce bloc est également appelé code «protégé» ou «gardé».

Si une exception se produit, le bloc catch qui correspond à l'exception levée est exécuté, sinon, tous les blocs catch sont ignorés.

Le bloc finally est toujours exécuté après la sortie du bloc try , qu'une exception ait été levée ou non à l'intérieur.

Q4. Comment pouvez-vous attraper plusieurs exceptions?

Il existe trois façons de gérer plusieurs exceptions dans un bloc de code.

La première consiste à utiliser un bloc catch qui peut gérer tous les types d'exceptions levés:

try { // ... } catch (Exception ex) { // ... }

Vous devez garder à l'esprit que la pratique recommandée consiste à utiliser des gestionnaires d'exceptions aussi précis que possible.

Les gestionnaires d'exceptions trop larges peuvent rendre votre code plus sujet aux erreurs, intercepter les exceptions qui n'étaient pas prévues et provoquer un comportement inattendu dans votre programme.

La deuxième méthode consiste à implémenter plusieurs blocs catch:

try { // ... } catch (FileNotFoundException ex) { // ... } catch (EOFException ex) { // ... }

Notez que, si les exceptions ont une relation d'héritage; le type enfant doit venir en premier et le type parent plus tard. Si nous ne le faisons pas, cela entraînera une erreur de compilation.

Le troisième est d'utiliser un bloc multi-catch:

try { // ... } catch (FileNotFoundException | EOFException ex) { // ... }

Cette fonctionnalité, introduite pour la première fois dans Java 7; réduit la duplication du code et facilite sa maintenance.

Q5. Quelle est la différence entre une exception cochée et une exception non cochée?

Une exception contrôlée doit être traitée dans un try-catch bloc ou déclaré dans une throws clause; alors qu'une exception non vérifiée ne doit pas être gérée ni déclarée.

Les exceptions cochées et non cochées sont également appelées respectivement exceptions à la compilation et à l'exécution.

Toutes les exceptions sont des exceptions vérifiées, à l'exception de celles indiquées par Error , RuntimeException et leurs sous-classes.

Q6. Quelle est la différence entre une exception et une erreur?

Une exception est un événement qui représente une condition à partir de laquelle il est possible de récupérer, alors qu'une erreur représente une situation externe généralement impossible à récupérer.

Toutes les erreurs générées par la JVM sont des instances d' Erreur ou l'une de ses sous-classes, les plus courantes incluent mais ne sont pas limitées à:

  • OutOfMemoryError - renvoyé lorsque la JVM ne peut pas allouer plus d'objets car il manque de mémoire et que le garbage collector n'a pas pu en rendre plus disponible
  • StackOverflowError - se produit lorsque l'espace de pile pour un thread est épuisé, généralement parce qu'une application récursent trop profondément
  • ExceptionInInitializerError - signale qu'une exception inattendue s'est produite lors de l'évaluation d'un initialiseur statique
  • NoClassDefFoundError – is thrown when the classloader tries to load the definition of a class and couldn't find it, usually because the required class files were not found in the classpath
  • UnsupportedClassVersionError – occurs when the JVM attempts to read a class file and determines that the version in the file is not supported, normally because the file was generated with a newer version of Java

Although an error can be handled with a try statement, this is not a recommended practice since there is no guarantee that the program will be able to do anything reliably after the error was thrown.

Q7. What Exception Will Be Thrown Executing the Following Code Block?

Integer[][] ints = { { 1, 2, 3 }, { null }, { 7, 8, 9 } }; System.out.println("value = " + ints[1][1].intValue());

It throws an ArrayIndexOutOfBoundsException since we're trying to access a position greater than the length of the array.

Q8. What Is Exception Chaining?

Occurs when an exception is thrown in response to another exception. This allows us to discover the complete history of our raised problem:

try { task.readConfigFile(); } catch (FileNotFoundException ex) { throw new TaskException("Could not perform task", ex); }

Q9. What Is a Stacktrace and How Does It Relate to an Exception?

A stack trace provides the names of the classes and methods that were called, from the start of the application to the point an exception occurred.

It's a very useful debugging tool since it enables us to determine exactly where the exception was thrown in the application and the original causes that led to it.

Q10. Why Would You Want to Subclass an Exception?

If the exception type isn't represented by those that already exist in the Java platform, or if you need to provide more information to client code to treat it in a more precise manner, then you should create a custom exception.

Deciding whether a custom exception should be checked or unchecked depends entirely on the business case. However, as a rule of thumb; if the code using your exception can be expected to recover from it, then create a checked exception otherwise make it unchecked.

Also, you should inherit from the most specific Exception subclass that closely relates to the one you want to throw. If there is no such class, then choose Exception as the parent.

Q11. What Are Some Advantages of Exceptions?

Traditional error detection and handling techniques often lead to spaghetti code hard to maintain and difficult to read. However, exceptions enable us to separate the core logic of our application from the details of what to do when something unexpected happens.

Also, since the JVM searches backward through the call stack to find any methods interested in handling a particular exception; we gain the ability to propagate an error up in the call stack without writing additional code.

Also, because all exceptions thrown in a program are objects, they can be grouped or categorized based on its class hierarchy. This allows us to catch a group of exceptions in a single exception handler by specifying the exception's superclass in the catch block.

Q12. Can You Throw Any Exception Inside a Lambda Expression's Body?

When using a standard functional interface already provided by Java, you can only throw unchecked exceptions because standard functional interfaces do not have a “throws” clause in method signatures:

List integers = Arrays.asList(3, 9, 7, 0, 10, 20); integers.forEach(i -> { if (i == 0) { throw new IllegalArgumentException("Zero not allowed"); } System.out.println(Math.PI / i); });

However, if you are using a custom functional interface, throwing checked exceptions is possible:

@FunctionalInterface public static interface CheckedFunction { void apply(T t) throws Exception; }
public void processTasks( List taks, CheckedFunction checkedFunction) { for (Task task : taks) { try { checkedFunction.apply(task); } catch (Exception e) { // ... } } } processTasks(taskList, t -> { // ... throw new Exception("Something happened"); });

Q13. What Are the Rules We Need to Follow When Overriding a Method That Throws an Exception?

Several rules dictate how exceptions must be declared in the context of inheritance.

When the parent class method doesn't throw any exceptions, the child class method can't throw any checked exception, but it may throw any unchecked.

Here's an example code to demonstrate this:

class Parent { void doSomething() { // ... } } class Child extends Parent { void doSomething() throws IllegalArgumentException { // ... } }

The next example will fail to compile since the overriding method throws a checked exception not declared in the overridden method:

class Parent { void doSomething() { // ... } } class Child extends Parent { void doSomething() throws IOException { // Compilation error } }

When the parent class method throws one or more checked exceptions, the child class method can throw any unchecked exception; all, none or a subset of the declared checked exceptions, and even a greater number of these as long as they have the same scope or narrower.

Here's an example code that successfully follows the previous rule:

class Parent { void doSomething() throws IOException, ParseException { // ... } void doSomethingElse() throws IOException { // ... } } class Child extends Parent { void doSomething() throws IOException { // ... } void doSomethingElse() throws FileNotFoundException, EOFException { // ... } }

Note that both methods respect the rule. The first throws fewer exceptions than the overridden method, and the second, even though it throws more; they're narrower in scope.

However, if we try to throw a checked exception that the parent class method doesn't declare or we throw one with a broader scope; we'll get a compilation error:

class Parent { void doSomething() throws FileNotFoundException { // ... } } class Child extends Parent { void doSomething() throws IOException { // Compilation error } }

When the parent class method has a throws clause with an unchecked exception, the child class method can throw none or any number of unchecked exceptions, even though they are not related.

Here's an example that honors the rule:

class Parent { void doSomething() throws IllegalArgumentException { // ... } } class Child extends Parent { void doSomething() throws ArithmeticException, BufferOverflowException { // ... } }

Q14. Will the Following Code Compile?

void doSomething() { // ... throw new RuntimeException(new Exception("Chained Exception")); }

Yes. When chaining exceptions, the compiler only cares about the first one in the chain and, because it detects an unchecked exception, we don't need to add a throws clause.

Q15. Is There Any Way of Throwing a Checked Exception from a Method That Does Not Have a Throws Clause?

Yes. We can take advantage of the type erasure performed by the compiler and make it think we are throwing an unchecked exception, when, in fact; we're throwing a checked exception:

public  T sneakyThrow(Throwable ex) throws T { throw (T) ex; } public void methodWithoutThrows() { this.sneakyThrow(new Exception("Checked Exception")); }

3. Conclusion

Dans cet article, nous avons exploré certaines des questions susceptibles d'apparaître dans les entretiens techniques pour les développeurs Java, concernant les exceptions. Cette liste n'est pas exhaustive et ne doit être considérée que comme le début de recherches ultérieures.

Chez Baeldung, nous vous souhaitons beaucoup de succès dans vos prochaines interviews.

Suivant » Questions d'entrevue Java Annotations (+ réponses) « Précédent Questions d'entretien Java Flow Control (+ réponses)