![Java
Interview
Questions
–
www.JavaInterview.in
1
Exception
Handling
Explain
about
Exception
Handling
with
an
example.
Exception Handling helps us to recover from an unexpected situations – File not found or network
connection is down. The important part in exception handling is the try – catch block. Look at the example
below.
public
static
void
main(String[]
args)
{
method1();
System.out.println("Line
after
Exception
-‐
Main");
}
private
static
void
method1()
{
method2();
System.out.println("Line
after
Exception
-‐
Method
1");
}
private
static
void
method2()
{
try
{
String
str
=
null;
str.toString();
System.out.println("Line
after
Exception
-‐
Method
2");
}
catch
(Exception
e)
{
//
NOT
PRINTING
EXCEPTION
TRACE-‐
BAD
PRACTICE
System.out.println("Exception
Handled
-‐
Method
2");
}
}
Program
Output
Exception Handled - Method 2
Line after Exception - Method 1
Line after Exception - Main
When exception is handled in a method, the calling methods will not need worry about that exception.
Since Exception Handling is added in the method method2, the exception did not propogate to method1
i.e. method1 does not know about the exception in method2.
Few important things to remember from this example.
• If exception is handled, it does not propogate further.
• In a try block, the lines after the line throwing the exception are not executed.
What
is
the
use
of
finally
block
in
Exception
Handling?
When an exception happens, the code after the line throwing exception is not executed. If code for things
like closing a connection is present in these lines of code, it is not executed. This leads to connection and
other resource leaks.
Code written in finally block is executed even when there is an exception.](https://image.slidesharecdn.com/javaexceptionhandling-150426044210-conversion-gate01/85/Java-exception-handling-1-320.jpg)
![2
Java
Interview
Questions
–
www.JavaInterview.in
Consider the example below. This is code without a finally block . We have Connection class with open
and close methods. An exception happens in the main method. The connection is not closed because
there is no finally block.
class
Connection
{
void
open()
{
System.out.println("Connection
Opened");
}
void
close()
{
System.out.println("Connection
Closed");
}
}
public
class
ExceptionHandlingExample1
{
public
static
void
main(String[]
args)
{
try
{
Connection
connection
=
new
Connection();
connection.open();
//
LOGIC
String
str
=
null;
str.toString();
connection.close();
}
catch
(Exception
e)
{
//
NOT
PRINTING
EXCEPTION
TRACE-‐
BAD
PRACTICE
System.out.println("Exception
Handled
-‐
Main");
}
}
}
Output
Connection Opened
Exception Handled - Main
Connection that is opened is not closed. This results in a dangling (un-closed) connection.
Finally block is used when code needs to be executed irrespective of whether an exception is thrown. Let
us now move connection.close(); into a finally block. Also connection declaration is moved out of the try
block to make it visible in the finally block.
public
static
void
main(String[]
args)
{
Connection
connection
=
new
Connection();
connection.open();
try
{
//
LOGIC
String
str
=
null;
str.toString();
}
catch
(Exception
e)
{
//
NOT
PRINTING
EXCEPTION
TRACE
-‐
BAD
PRACTICE
System.out.println("Exception
Handled
-‐
Main");
}
finally
{
connection.close();](https://image.slidesharecdn.com/javaexceptionhandling-150426044210-conversion-gate01/85/Java-exception-handling-2-320.jpg)
![6
Java
Interview
Questions
–
www.JavaInterview.in
}
}
How
do
you
create
a
Custom
Exception
Classes?
We can create a custom exception by extending Exception class or RuntimeException class. If we extend
Exception class, it will be a checked exception class. If we extend RuntimeException class, then we
create an unchecked exception class.
Example
class
CurrenciesDoNotMatchException
extends
Exception{
}
Let’s now create some sample code to use CurrenciesDoNotMatchException. Since it is a checked
exception we need do two things a. throw
new
CurrenciesDoNotMatchException();
b.
throws
CurrenciesDoNotMatchException
(in
method
declaration).
class
AmountAdder
{
static
Amount
addAmounts(Amount
amount1,
Amount
amount2)
throws
CurrenciesDoNotMatchException
{
if
(!amount1.currency.equals(amount2.currency))
{
throw
new
CurrenciesDoNotMatchException();
}
return
new
Amount(amount1.currency,
amount1.amount
+
amount2.amount);
}
}
How
should
the
Exception
catch
blocks
be
ordered
?
Specific Exception catch blocks should be before the catch block for a Generic Exception. For example,
CurrenciesDoNotMatchException should be before Exception. Below code gives a compilation error.
public
static
void
main(String[]
args)
{
try
{
AmountAdder.addAmounts(new
Amount("RUPEE",
5),
new
Amount("DOLLAR",
5));
}
catch
(Exception
e)
{
//
COMPILER
ERROR!!
System.out.println("Handled
Exception");
}
catch
(CurrenciesDoNotMatchException
e)
{
System.out.println("Handled
CurrenciesDoNotMatchException");
}
}
Can
you
explain
some
Exception
Handling
Best
Practices?
Never Completely Hide Exceptions. At the least log them. printStactTrace method prints the entire stack
trace when an exception occurs. If you handle an exception, it is always a good practice to log the trace.
public
static
void
main(String[]
args)
{
try
{
AmountAdder.addAmounts(new
Amount("RUPEE",
5),
new
Amount("RUPEE",
5));
String
string
=
null;
string.toString();
}
catch
(CurrenciesDoNotMatchException
e)
{
System.out.println("Handled
CurrenciesDoNotMatchException");](https://image.slidesharecdn.com/javaexceptionhandling-150426044210-conversion-gate01/85/Java-exception-handling-6-320.jpg)
Java exception handling
- 1. Java Interview Questions – www.JavaInterview.in 1 Exception Handling Explain about Exception Handling with an example. Exception Handling helps us to recover from an unexpected situations – File not found or network connection is down. The important part in exception handling is the try – catch block. Look at the example below. public static void main(String[] args) { method1(); System.out.println("Line after Exception -‐ Main"); } private static void method1() { method2(); System.out.println("Line after Exception -‐ Method 1"); } private static void method2() { try { String str = null; str.toString(); System.out.println("Line after Exception -‐ Method 2"); } catch (Exception e) { // NOT PRINTING EXCEPTION TRACE-‐ BAD PRACTICE System.out.println("Exception Handled -‐ Method 2"); } } Program Output Exception Handled - Method 2 Line after Exception - Method 1 Line after Exception - Main When exception is handled in a method, the calling methods will not need worry about that exception. Since Exception Handling is added in the method method2, the exception did not propogate to method1 i.e. method1 does not know about the exception in method2. Few important things to remember from this example. • If exception is handled, it does not propogate further. • In a try block, the lines after the line throwing the exception are not executed. What is the use of finally block in Exception Handling? When an exception happens, the code after the line throwing exception is not executed. If code for things like closing a connection is present in these lines of code, it is not executed. This leads to connection and other resource leaks. Code written in finally block is executed even when there is an exception.
- 2. 2 Java Interview Questions – www.JavaInterview.in Consider the example below. This is code without a finally block . We have Connection class with open and close methods. An exception happens in the main method. The connection is not closed because there is no finally block. class Connection { void open() { System.out.println("Connection Opened"); } void close() { System.out.println("Connection Closed"); } } public class ExceptionHandlingExample1 { public static void main(String[] args) { try { Connection connection = new Connection(); connection.open(); // LOGIC String str = null; str.toString(); connection.close(); } catch (Exception e) { // NOT PRINTING EXCEPTION TRACE-‐ BAD PRACTICE System.out.println("Exception Handled -‐ Main"); } } } Output Connection Opened Exception Handled - Main Connection that is opened is not closed. This results in a dangling (un-closed) connection. Finally block is used when code needs to be executed irrespective of whether an exception is thrown. Let us now move connection.close(); into a finally block. Also connection declaration is moved out of the try block to make it visible in the finally block. public static void main(String[] args) { Connection connection = new Connection(); connection.open(); try { // LOGIC String str = null; str.toString(); } catch (Exception e) { // NOT PRINTING EXCEPTION TRACE -‐ BAD PRACTICE System.out.println("Exception Handled -‐ Main"); } finally { connection.close();
- 3. Java Interview Questions – www.JavaInterview.in 3 } } Output Connection Opened Exception Handled - Main Connection Closed Connection is closed even when exception is thrown. This is because connection.close() is called in the finally block. Finally block is always executed (even when an exception is thrown). So, if we want some code to be always executed we can move it to finally block. Java Interview Questions – www.JavaInterview.in At http://www.JavaInterview.in, we want you to clear java interview with ease. So, in addition to focussing on Core and Advanced Java we also focus on topics like Code Reviews, Performance, Design Patterns, Spring and Struts. We have created more than 20 videos to help you understand these topics and become an expert at them. Visit our website http://www.JavaInterview.in for complete list of videos. Other than the videos, we answer the top 200 frequently asked interview questions on our website. With more 900K video views (Apr 2015), we are the most popular channel on Java Interview Questions on YouTube. Register here for more updates : https://feedburner.google.com/fb/a/mailverify?uri=RithusTutorials Java Interview : A Freshers Guide -‐ Part 1: https://www.youtube.com/watch?v=njZ48YVkei0 Java Interview : A Freshers Guide -‐ Part 2: https://www.youtube.com/watch?v=xyXuo0y-xoU In what kind of scenarios, a finally block is not executed? Code in finally is NOT executed only in two situations. 1. If exception is thrown in finally. 2. If JVM Crashes in between (for example, System.exit()). Is a finally block executed even when there is a return statement in the try block? private static void method2() { Connection connection = new Connection(); connection.open(); try { // LOGIC
- 4. 4 Java Interview Questions – www.JavaInterview.in String str = null; str.toString(); return; } catch (Exception e) { // NOT PRINTING EXCEPTION TRACE -‐ BAD PRACTICE System.out.println("Exception Handled -‐ Method 2"); return; } finally { connection.close(); } } Is a try block without corresponding catch block allowed? Yes. try without a catch is allowed. Example below. private static void method2() { Connection connection = new Connection(); connection.open(); try { // LOGIC String str = null; str.toString(); } finally { connection.close(); } } However a try block without both catch and finally is NOT allowed. Below method would give a Compilation Error!! (End of try block) private static void method2() { Connection connection = new Connection(); connection.open(); try { // LOGIC String str = null; str.toString(); }//COMPILER ERROR!! } Explain the hierarchy of Exception related classes in Java? Throwable is the highest level of Error Handling classes. Below class definitions show the pre-defined exception hierarchy in Java. //Pre-‐defined Java Classes class Error extends Throwable{} class Exception extends Throwable{} class RuntimeException extends Exception{} Below class definitions show creation of a programmer defined exception in Java. //Programmer defined classes class CheckedException1 extends Exception{}
- 5. Java Interview Questions – www.JavaInterview.in 5 class CheckedException2 extends CheckedException1{} class UnCheckedException extends RuntimeException{} class UnCheckedException2 extends UnCheckedException{} What is difference between an Error and an Exception? Error is used in situations when there is nothing a programmer can do about an error. Ex: StackOverflowError, OutOfMemoryError. Exception is used when a programmer can handle the exception. What is the difference between a Checked Exception and an Un-‐Checked Exception? RuntimeException and classes that extend RuntimeException are called unchecked exceptions. For Example: RuntimeException,UnCheckedException,UnCheckedException2 are unchecked or RunTime Exceptions. There are subclasses of RuntimeException (which means they are subclasses of Exception also.) Other Exception Classes (which don’t fit the earlier definition). These are also called Checked Exceptions. Exception, CheckedException1,CheckedException2 are checked exceptions. They are subclasses of Exception which are not subclasses of RuntimeException. How do you throw a Checked Exception from a Method? Consider the example below. The method addAmounts throws a new Exception. However, it gives us a compilation error because Exception is a Checked Exception. All classes that are not RuntimeException or subclasses of RuntimeException but extend Exception are called CheckedExceptions. The rule for CheckedExceptions is that they should be handled or thrown. Handled means it should be completed handled - i.e. not throw out of the method. Thrown means the method should declare that it throws the exception Example without throws: Does NOT compile class AmountAdder { static Amount addAmounts(Amount amount1, Amount amount2) { if (!amount1.currency.equals(amount2.currency)) { throw new Exception("Currencies don't match");// COMPILER ERROR! // Unhandled exception type Exception } return new Amount(amount1.currency, amount1.amount + amount2.amount); } } Example with throws definition Let's look at how to declare throwing an exception from a method. Look at the line "static Amount addAmounts(Amount amount1, Amount amount2) throws Exception". This is how we declare that a method throws Exception. class AmountAdder { static Amount addAmounts(Amount amount1, Amount amount2) throws Exception { if (!amount1.currency.equals(amount2.currency)) { throw new Exception("Currencies don't match"); } return new Amount(amount1.currency, amount1.amount + amount2.amount);
- 6. 6 Java Interview Questions – www.JavaInterview.in } } How do you create a Custom Exception Classes? We can create a custom exception by extending Exception class or RuntimeException class. If we extend Exception class, it will be a checked exception class. If we extend RuntimeException class, then we create an unchecked exception class. Example class CurrenciesDoNotMatchException extends Exception{ } Let’s now create some sample code to use CurrenciesDoNotMatchException. Since it is a checked exception we need do two things a. throw new CurrenciesDoNotMatchException(); b. throws CurrenciesDoNotMatchException (in method declaration). class AmountAdder { static Amount addAmounts(Amount amount1, Amount amount2) throws CurrenciesDoNotMatchException { if (!amount1.currency.equals(amount2.currency)) { throw new CurrenciesDoNotMatchException(); } return new Amount(amount1.currency, amount1.amount + amount2.amount); } } How should the Exception catch blocks be ordered ? Specific Exception catch blocks should be before the catch block for a Generic Exception. For example, CurrenciesDoNotMatchException should be before Exception. Below code gives a compilation error. public static void main(String[] args) { try { AmountAdder.addAmounts(new Amount("RUPEE", 5), new Amount("DOLLAR", 5)); } catch (Exception e) { // COMPILER ERROR!! System.out.println("Handled Exception"); } catch (CurrenciesDoNotMatchException e) { System.out.println("Handled CurrenciesDoNotMatchException"); } } Can you explain some Exception Handling Best Practices? Never Completely Hide Exceptions. At the least log them. printStactTrace method prints the entire stack trace when an exception occurs. If you handle an exception, it is always a good practice to log the trace. public static void main(String[] args) { try { AmountAdder.addAmounts(new Amount("RUPEE", 5), new Amount("RUPEE", 5)); String string = null; string.toString(); } catch (CurrenciesDoNotMatchException e) { System.out.println("Handled CurrenciesDoNotMatchException");
- 7. Java Interview Questions – www.JavaInterview.in 7 e.printStackTrace(); } } Videos We have created more than 20 videos to help you understand these topics and become an expert at them. You can watch these videos for free on YouTube. Visit our website http://www.JavaInterview.in for complete list of videos. We answer the top 200 frequently asked interview questions on the website. Register here for more updates : https://feedburner.google.com/fb/a/mailverify?uri=RithusTutorials Java Interview : A Freshers Guide -‐ Part 1: https://www.youtube.com/watch?v=njZ48YVkei0 Java Interview : A Freshers Guide -‐ Part 2: https://www.youtube.com/watch?v=xyXuo0y-xoU Java Interview : A Guide for Experienced: https://www.youtube.com/watch?v=0xcgzUdTO5M Collections Interview Questions 1: https://www.youtube.com/watch?v=GnR4hCvEIJQ Collections Interview Questions 2: https://www.youtube.com/watch?v=6dKGpOKAQqs Collections Interview Questions 3: https://www.youtube.com/watch?v=_JTIYhnLemA Collections Interview Questions 4: https://www.youtube.com/watch?v=ZNhT_Z8_q9s Collections Interview Questions 5: https://www.youtube.com/watch?v=W5c8uXi4qTw