Domande di intervista sulle eccezioni Java (+ risposte)

Questo articolo fa parte di una serie: • Domande di intervista sulle raccolte Java

• Domande di intervista sul sistema di tipo Java

• Domande di intervista sulla concorrenza Java (+ risposte)

• Struttura delle classi Java e domande di colloquio sull'inizializzazione

• Domande di intervista Java 8 (+ risposte)

• Gestione della memoria in Java Intervista Domande (+ risposte)

• Domande di intervista su Java Generics (+ risposte)

• Domande di intervista sul controllo del flusso Java (+ risposte)

• Java Exceptions Interview Questions (+ Answers) (articolo corrente) • Java Annotations Interview Questions (+ Answers)

• Domande principali per l'intervista su Spring Framework

1. Panoramica

Le eccezioni sono un argomento essenziale che ogni sviluppatore Java dovrebbe conoscere. Questo articolo fornisce risposte ad alcune delle domande che potrebbero apparire durante un'intervista.

2. Domande

Q1. Cos'è un'eccezione?

Un'eccezione è un evento anormale che si verifica durante l'esecuzione di un programma e interrompe il normale flusso delle istruzioni del programma.

Q2. Qual è lo scopo delle parole chiave Throw and Throw?

La parola chiave throws viene utilizzata per specificare che un metodo può sollevare un'eccezione durante la sua esecuzione. Impone la gestione esplicita delle eccezioni quando si chiama un metodo:

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

La parola chiave throw ci permette di lanciare un oggetto eccezione per interrompere il normale flusso del programma. Questo è più comunemente usato quando un programma non riesce a soddisfare una determinata condizione:

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

Q3. Come puoi gestire un'eccezione?

Usando un'istruzione try-catch- latest:

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

Il blocco di codice in cui può verificarsi un'eccezione è racchiuso in un blocco try . Questo blocco è anche chiamato codice "protetto" o "sorvegliato".

Se si verifica un'eccezione, viene eseguito il blocco catch che corrisponde all'eccezione lanciata, altrimenti tutti i blocchi catch vengono ignorati.

Il blocco finalmente viene sempre eseguito dopo che il blocco try è terminato , indipendentemente dal fatto che sia stata lanciata o meno un'eccezione al suo interno.

Q4. Come si possono rilevare più eccezioni?

Esistono tre modi per gestire più eccezioni in un blocco di codice.

Il primo è usare un blocco catch in grado di gestire tutti i tipi di eccezione lanciati:

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

È necessario tenere presente che la pratica consigliata consiste nell'utilizzare gestori di eccezioni il più precisi possibile.

I gestori di eccezioni troppo ampi possono rendere il codice più soggetto a errori, rilevare eccezioni non previste e causare comportamenti imprevisti nel programma.

Il secondo modo consiste nell'implementare più blocchi catch:

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

Notare che, se le eccezioni hanno una relazione di eredità; il tipo figlio deve venire prima e il tipo genitore dopo. Se non riusciamo a farlo, si verificherà un errore di compilazione.

Il terzo è usare un blocco multi-catch:

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

Questa funzione, introdotta per la prima volta in Java 7; riduce la duplicazione del codice e ne semplifica la manutenzione.

Q5. Qual è la differenza tra un'eccezione selezionata e un'eccezione non selezionata?

Un'eccezione verificata deve essere gestita all'interno di un blocco try-catch o dichiarata in una clausola throws ; mentre un'eccezione non controllata non deve essere gestita né dichiarata.

Le eccezioni selezionate e non selezionate sono note rispettivamente anche come eccezioni in fase di compilazione e di runtime.

Tutte le eccezioni sono eccezioni controllate, ad eccezione di quelle indicate da Error , RuntimeException e dalle loro sottoclassi.

Q6. Qual è la differenza tra un'eccezione ed un errore?

Un'eccezione è un evento che rappresenta una condizione da cui è possibile recuperare, mentre l'errore rappresenta una situazione esterna solitamente impossibile da recuperare.

Tutti gli errori lanciati dalla JVM sono istanze di Error o una delle sue sottoclassi, quelli più comuni includono ma non sono limitati a:

  • OutOfMemoryError : generato quando la JVM non può allocare più oggetti perché ha esaurito la memoria e il garbage collector non è stato in grado di renderne più disponibili
  • StackOverflowError : si verifica quando lo spazio dello stack per un thread è esaurito, in genere perché un'applicazione ricorre troppo in profondità
  • ExceptionInInitializerError : segnala che si è verificata un'eccezione imprevista durante la valutazione di un inizializzatore statico
  • 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

In questo articolo, abbiamo esaminato alcune delle domande che potrebbero apparire nelle interviste tecniche per gli sviluppatori Java, riguardo alle eccezioni. Questo non è un elenco esaustivo e dovrebbe essere considerato solo come l'inizio di ulteriori ricerche.

Noi di Baeldung vi auguriamo successo in tutte le prossime interviste.

Successivo » Domande di colloquio con annotazioni Java (+ risposte) « Precedente Domande di intervista sul controllo del flusso Java (+ risposte)