Fragen zum Interview mit Java-Ausnahmen (+ Antworten)

Dieser Artikel ist Teil einer Reihe: • Fragen zum Interview mit Java Collections

• Fragen zum Java Type System-Interview

• Fragen zum Java Concurrency-Interview (+ Antworten)

• Fragen zum Java-Klassenstruktur- und Initialisierungsinterview

• Fragen zum Java 8-Interview (+ Antworten)

• Speicherverwaltung in Java Interview Fragen (+ Antworten)

• Fragen zum Java Generics-Interview (+ Antworten)

• Fragen zum Java Flow Control-Interview (+ Antworten)

• Fragen zum Interview mit Java-Ausnahmen (+ Antworten) (aktueller Artikel) • Fragen zum Interview mit Java-Anmerkungen (+ Antworten)

• Fragen zum Top Spring Framework-Interview

1. Übersicht

Ausnahmen sind ein wesentliches Thema, mit dem jeder Java-Entwickler vertraut sein sollte. Dieser Artikel enthält Antworten auf einige der Fragen, die während eines Interviews auftreten können.

2. Fragen

Q1. Was ist eine Ausnahme?

Eine Ausnahme ist ein abnormales Ereignis, das während der Ausführung eines Programms auftritt und den normalen Ablauf der Programmanweisungen stört.

Q2. Was ist der Zweck der Throw- und Throws-Schlüsselwörter?

Das wirft Schlüsselwort wird verwendet , um anzugeben , dass ein Verfahren , eine Ausnahme während der Ausführung erhöhen kann. Es erzwingt die explizite Ausnahmebehandlung beim Aufrufen einer Methode:

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

Mit dem Schlüsselwort throw können wir ein Ausnahmeobjekt auslösen, um den normalen Programmablauf zu unterbrechen. Dies wird am häufigsten verwendet, wenn ein Programm eine bestimmte Bedingung nicht erfüllt:

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

Q3. Wie können Sie mit einer Ausnahme umgehen?

Mit einer try-catch-finally- Anweisung:

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

Der Codeblock, in dem eine Ausnahme auftreten kann, ist in einem try- Block eingeschlossen. Dieser Block wird auch als "geschützter" oder "geschützter" Code bezeichnet.

Wenn eine Ausnahme auftritt, wird der catch- Block ausgeführt, der der ausgelösten Ausnahme entspricht. Andernfalls werden alle catch- Blöcke ignoriert.

Der finally- Block wird immer ausgeführt, nachdem der try- Block beendet wurde, unabhängig davon, ob eine Ausnahme darin ausgelöst wurde oder nicht.

Q4. Wie können Sie mehrere Ausnahmen abfangen?

Es gibt drei Möglichkeiten, mehrere Ausnahmen in einem Codeblock zu behandeln.

Der erste besteht darin, einen catch- Block zu verwenden, der alle ausgelösten Ausnahmetypen verarbeiten kann:

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

Beachten Sie, dass die empfohlene Vorgehensweise darin besteht, Ausnahmehandler zu verwenden, die so genau wie möglich sind.

Zu breite Ausnahmebehandlungsroutinen können Ihren Code fehleranfälliger machen, nicht erwartete Ausnahmen abfangen und unerwartetes Verhalten in Ihrem Programm verursachen.

Der zweite Weg ist die Implementierung mehrerer Fangblöcke:

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

Beachten Sie, dass, wenn die Ausnahmen eine Vererbungsbeziehung haben; Der untergeordnete Typ muss zuerst und der übergeordnete Typ später kommen. Wenn wir dies nicht tun, führt dies zu einem Kompilierungsfehler.

Der dritte besteht darin, einen Multi-Catch-Block zu verwenden:

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

Diese Funktion wurde erstmals in Java 7 eingeführt. Reduziert die Codeduplizierung und erleichtert die Wartung.

Q5. Was ist der Unterschied zwischen einer geprüften und einer ungeprüften Ausnahme?

Eine aktivierte Ausnahme muss in einem Try-Catch- Block behandelt oder in einer Throws- Klausel deklariert werden . Eine ungeprüfte Ausnahme muss weder behandelt noch deklariert werden.

Aktivierte und nicht aktivierte Ausnahmen werden auch als Ausnahmen zur Kompilierungszeit bzw. zur Laufzeit bezeichnet.

Alle Ausnahmen sind geprüfte Ausnahmen, mit Ausnahme der durch Fehler , RuntimeException und ihre Unterklassen angegebenen.

Q6. Was ist der Unterschied zwischen einer Ausnahme und einem Fehler?

Eine Ausnahme ist ein Ereignis, das eine Bedingung darstellt, von der eine Wiederherstellung möglich ist, während ein Fehler eine externe Situation darstellt, von der normalerweise keine Wiederherstellung möglich ist.

All errors thrown by the JVM are instances of Error or one of its subclasses, the more common ones include but are not limited to:

  • OutOfMemoryError – thrown when the JVM cannot allocate more objects because it is out memory, and the garbage collector was unable to make more available
  • StackOverflowError – occurs when the stack space for a thread has run out, typically because an application recurses too deeply
  • ExceptionInInitializerError – signals that an unexpected exception occurred during the evaluation of a static initializer
  • 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 diesem Artikel haben wir einige der Fragen untersucht, die in technischen Interviews für Java-Entwickler zu Ausnahmen auftreten können. Dies ist keine vollständige Liste und sollte nur als Beginn weiterer Forschungen betrachtet werden.

Wir von Baeldung wünschen Ihnen viel Erfolg bei den kommenden Interviews.

Weiter » Fragen zum Java Annotations-Interview (+ Antworten) « Vorherige Fragen zum Java Flow Control-Interview (+ Antworten)