Exception Handling

Question 1
class A {
public static void main (String[] args) {
Error error = new Error();
Exception exception = new Exception();
System.out.print((exception instanceof Throwable) + ",");
System.out.print(error instanceof Throwable);
}}

What is the result of attempting to compile and run the program?

a.  Prints: false,false

b.  Prints: false,true
c.  Prints: true,false
d.  Prints: true,true
e.  Compile-time error
f.  Run-time error
g.  None of the above

ANSWER
1 d  Prints: true,true  Both Error and Exception are subclasses of Throwable.  

Question 2
class A {A() throws Exception {}} // 1
class B extends A {B() throws Exception {}} // 2
class C extends A {C() {}} // 3

Which of the following statements are true?

a.  class A extends Object.

b.  Compile-time error at 1.
c.  Compile-time error at 2.
d.  Compile-time error at 3.

ANSWER
2 a  class A extends The constructors for class B and class C both invoke the
d  Object.  constructor for A. The constructor for class A declares
 Exception in the throws clause. Since the constructors for B and
C invoke the constructor for A, it is necessary to declare
Compile-time
Exception in the throws clauses of B and C. A compile-time
error at 3. 
error is generated at marker 3, because the constructor does not
declare Exception in the throws clause.  

Question 3
class A {
public static void main (String[] args) {
Object error = new Error();
Object runtimeException = new RuntimeException();
System.out.print((error instanceof Exception) + ",");
System.out.print(runtimeException instanceof Exception);
}}

What is the result of attempting to compile and run the program?

a.  Prints: false,false

b.  Prints: false,true
c.  Prints: true,false
d.  Prints: true,true
e.  Compile-time error
f.  Run-time error
g.  None of the above

ANSWER
Prints: Error is a direct subclass of Throwable. RuntimeException is a
3 b 
false,true  direct subclass of Exception.  

Question 4
class Level1Exception extends Exception {}
class Level2Exception extends Level1Exception {}
class Level3Exception extends Level2Exception {}
class Purple {
public static void main(String args[]) {
int a,b,c,d,f,g,x;
a = b = c = d = f = g = 0;
x = 1;
try {
try {
switch (x) {
case 1: throw new Level1Exception();
case 2: throw new Level2Exception();
 case 3: throw new Level3Exception();
} a++; }
catch (Level2Exception e) {b++;}
finally {c++;}
}
catch (Level1Exception e) { d++;}
catch (Exception e) {f++;}
finally {g++;}
System.out.print(a+","+b+","+c+","+d+","+f+","+g);
}}

What is the result of attempting to compile and run the program?

a.  Prints: 0,0,0,1,0,0

b.  Prints: 0,0,1,1,0,1
c.  Prints: 0,1,1,1,0,1
d.  Prints: 1,0,1,1,0,1
e.  Prints: 1,1,1,1,0,1
f.  Compile-time error
g.  Run-time error
h.  None of the above

ANSWER
The nested catch clause is able to catch a Level2Exception or any
subclass of it. The switch statement throws a Level1Exception that
Prints: can not be caught by the nested catch clause; so the nested finally
4 b 
0,0,1,1,0,1  block is executed as control passes to the first of the two outer catch
clauses. The outer finally block is executed as control passes out of
the try statement.  

Question 5
class Level1Exception extends Exception {}
class Level2Exception extends Level1Exception {}
class Level3Exception extends Level2Exception {}
class Purple {
public static void main(String args[]) {
int a,b,c,d,f,g,x;
a = b = c = d = f = g = 0;
x = 2;
try {
try {
switch (x) {
case 1: throw new Level1Exception();
case 2: throw new Level2Exception();
case 3: throw new Level3Exception();
} a++; }
catch (Level2Exception e) {b++;}
 finally {c++;}
}
catch (Level1Exception e) { d++;}
catch (Exception e) {f++;}
finally {g++;}
System.out.print(a+","+b+","+c+","+d+","+f+","+g);
}}

What is the result of attempting to compile and run the program?

a.  Prints: 0,0,1,0,0,1

b.  Prints: 0,1,0,0,0,0
c.  Prints: 0,1,1,0,0,1
d.  Prints: 0,1,0,0,0,1
e.  Prints: 1,1,1,0,0,1
f.  Compile-time error
g.  Run-time error
h.  None of the above

ANSWER
The nested catch block is able to catch a Level2Exception or any
Prints:
5 c  subclass of it causing b to be incremented. Both of the finally
0,1,1,0,0,1 
blocks are then executed.  

Question 6
class Level1Exception extends Exception {}
class Level2Exception extends Level1Exception {}
class Level3Exception extends Level2Exception {}
class Purple {
public static void main(String args[]) {
int a,b,c,d,f,g,x;
a = b = c = d = f = g = 0;
x = 3;
try {
try {
switch (x) {
case 1: throw new Level1Exception();
case 2: throw new Level2Exception();
case 3: throw new Level3Exception();
} a++; }
catch (Level2Exception e) {b++;}
finally {c++;}
}
catch (Level1Exception e) { d++;}
catch (Exception e) {f++;}
finally {g++;}
System.out.print(a+","+b+","+c+","+d+","+f+","+g);
}}

What is the result of attempting to compile and run the program?

a.  Prints: 1,1,1,0,0,1

b.  Prints: 0,1,1,0,0,1
c.  Prints: 0,1,0,0,0,0
d.  Prints: 0,1,0,0,0,1
e.  Prints: 0,0,1,0,0,1
f.  Compile-time error
g.  Run-time error
h.  None of the above

ANSWER
The nested catch block is able to catch a Level2Exception or any
Prints:
6 b  subclass of it causing b to be incremented. Both of the finally
0,1,1,0,0,1 
blocks are then executed.  

Question 7
class Level1Exception extends Exception {}
class Level2Exception extends Level1Exception {}
class Level3Exception extends Level2Exception {}
class Purple {
public static void main(String args[]) {
int a,b,c,d,f,g,x;
a = b = c = d = f = g = 0;
x = 4;
try {
try {
switch (x) {
case 1: throw new Level1Exception();
case 2: throw new Level2Exception();
case 3: throw new Level3Exception();
case 4: throw new Exception();
} a++; }
catch (Level2Exception e) {b++;}
finally{c++;}
}
catch (Level1Exception e) { d++;}
catch (Exception e) {f++;}
finally {g++;}
System.out.print(a+","+b+","+c+","+d+","+f+","+g);
}}

What is the result of attempting to compile and run the program?

a.  Prints: 0,0,0,0,0,1

b.  Prints: 0,0,0,0,1,0
c.  Prints: 0,0,1,0,0,1
d.  Prints: 0,0,1,0,1,1
e.  Prints: 0,1,1,1,1,1
f.  Prints: 1,1,1,1,1,1
g.  Compile-time error
h.  Run-time error
i.  None of the above

ANSWER
The nested catch clause is able to catch a Level2Exception or any
subclass of it. The switch statement throws an Exception that can
Prints: not be caught by the nested catch clause; so the nested finally block
7 d 
0,0,1,0,1,1  is executed as control passes to the second of the two outer catch
clauses. The outer finally block is executed as control passes out of
the try statement.  

Question 8
class Level1Exception extends Exception {}
class Level2Exception extends Level1Exception {}
class Level3Exception extends Level2Exception {}
class Purple {
public static void main(String args[]) {
int a,b,c,d,f,g,x;
a = b = c = d = f = g = 0;
x = 5;
try {
try {
switch (x) {
case 1: throw new Level1Exception();
case 2: throw new Level2Exception();
case 3: throw new Level3Exception();
case 4: throw new Exception();
} a++; }
catch (Level2Exception e) {b++;}
finally {c++;}
}
catch (Level1Exception e) { d++;}
catch (Exception e) {f++;}
finally {g++;}
System.out.print(a+","+b+","+c+","+d+","+f+","+g);
}}

What is the result of attempting to compile and run the program?

a.  Prints: 1,0,0,0,0,0

b.  Prints: 1,0,1,0,0,1
c.  Prints: 0,0,1,0,0,1
d.  Prints: 1,1,1,1,1,1
e.  Compile-time error
f.  Run-time error
g.  None of the above

ANSWER
The switch statement does not throw an exception; so the switch
Prints: completes normally. The subsequent statement increments the
8 b 
1,0,1,0,0,1  variable, a; and the try block completes normally. Both of the
finally blocks are then executed.  

Question 9
class ColorException extends Exception {}
class WhiteException extends ColorException {}
class White {
void m1() throws ColorException {throw new WhiteException();}
void m2() throws WhiteException {}
public static void main (String[] args) {
White white = new White();
int a,b,d,f; a = b = d = f = 0;
try {white.m1(); a++;} catch (ColorException e) {b++;}
try {white.m2(); d++;} catch (WhiteException e) {f++;}
System.out.print(a+","+b+","+d+","+f);
}}

What is the result of attempting to compile and run the program?

a.  Prints: 0,1,0,0

b.  Prints: 1,1,0,0
c.  Prints: 0,1,1,0
d.  Prints: 1,1,1,0
e.  Prints: 1,1,1,1
f.  Compile-time error
g.  Run-time error
h.  None of the above

ANSWER
9 c  Prints: The first try block contains two statements. The first invokes method
0,1,1,0  m1, and the subsequent statement contains a post increment expression
with the variable, a, as the operand. Method m1 throws a
WhiteException exception, so variable a is not incremented as control
passes to the catch block where b is incremented. The throws clause of
m1 declares a ColorException, so the body may throw a
 ColorException or any subclass of ColorException. The second try
block also contains two statements. The first invokes method m2, and
the subsequent statement contains a post increment expression with the
variable, d, as the operand. Method m2 does not throw an exception, so
d is incremented, and the try block completes normally. Although the
throws clause of m2 declares a WhiteException, there is no requirement
to throw any exception.  

Question 10
class ColorException extends Exception {}
class WhiteException extends ColorException {}
class White {
void m1() throws ColorException {throw new ColorException();}
void m2() throws WhiteException {throw new ColorException();}
public static void main (String[] args) {
White white = new White();
int a,b,d,f; a = b = d = f = 0;
try {white.m1(); a++;} catch (ColorException e) {b++;}
try {white.m2(); d++;} catch (WhiteException e) {f++;}
System.out.print(a+","+b+","+d+","+f);
}}

What is the result of attempting to compile and run the program?

a.  Prints: 0,1,0,0

b.  Prints: 1,1,0,1
c.  Prints: 0,1,0,1
d.  Prints: 0,1,1,1
e.  Prints: 1,1,1,1
f.  Compile-time error
g.  Run-time error
h.  None of the above

ANSWER
The throws clause of White.m2 declares a WhiteException, so the
Compile- body of m2 may throw a WhiteException or any subclass of
10 f 
time error  WhiteException. Instead, the body of m2 throws a superclass of
WhiteException. The result is a compile-time error.  

Question 11
class ColorException extends Exception {}
class WhiteException extends ColorException {}
class White {
void m1() throws ColorException {throw new ColorException();}
void m2() throws WhiteException {throw new WhiteException();}
public static void main (String[] args) {
White white = new White();
int a,b,d,f; a = b = d = f = 0;
try {white.m1(); a++;} catch (WhiteException e) {b++;}
try {white.m2(); d++;} catch (WhiteException e) {f++;}
System.out.print(a+","+b+","+d+","+f);
}}

What is the result of attempting to compile and run the program?

a.  Prints: 0,1,0,0

b.  Prints: 1,1,0,1
c.  Prints: 0,1,0,1
d.  Prints: 0,1,1,1
e.  Prints: 1,1,1,1
f.  Compile-time error
g.  Run-time error
h.  None of the above

ANSWER
The throws clause of White.m1 declares a ColorException, but the
Compile-
11 f  catch clause in the main method catches only a subclass of
time error 
ColorException. The result is a compile-time error.  

Question 12
class Level1Exception extends Exception {}
class Level2Exception extends Level1Exception {}
class Level3Exception extends Level2Exception {}
class Brown {
public static void main(String args[]) {
int a, b, c, d, f; a = b = c = d = f = 0;
int x = 1;
try {
switch (x) {
case 1: throw new Level1Exception();
case 2: throw new Level2Exception();
case 3: throw new Level3Exception();
} a++; }
catch (Level3Exception e) {b++;}
catch (Level2Exception e) {c++;}
catch (Level1Exception e) {d++;}
finally {f++;}
System.out.print(a+","+b+","+c+","+d+","+f);
}}
What is the result of attempting to compile and run the program?

a.  Prints: 0,0,0,1,1

b.  Prints: 0,0,1,1,1
c.  Prints: 0,1,1,1,1
d.  Prints: 1,1,1,1,1
e.  Prints: 0,0,1,0,1
f.  Prints: 0,1,0,0,1
g.  Prints: 1,0,0,0,1
h.  Compile-time error
i.  Run-time error
j.  None of the above

ANSWER
The first catch clause has a parameter e of type Level3Exception, so
the first catch clause is able to catch any exception type that is
assignable to type Level3Exception. Since Level2Exception is the
superclass of Level3Exception, an instance of Level2Exception is
not assignable to a catch clause parameter of type Level3Exception.
Similarly, Level1Exception is also a superclass of Level3Exception,
so an instance of Level1Exception is not assignable to a catch clause
parameter of type Level3Exception. The only exception type that can
be caught by the first catch clause is a Level3Exception. The second
catch clause has a parameter e of type Level2Exception, so the
second catch clause is able to catch a Level2Exception. The
Level1Exception is the superclass of Level2Exception. An instance
of Level1Exception is not assignable to a catch clause parameter of
Prints: type Level2Exception, so the second catch clause can not catch a
12 a 
0,0,0,1,1  Level1Exception. Since a Level3Exception is a subclass of
Level2Exception an exception of type Level3Exception is assignable
to a catch clause parameter type Level2Exception. All exceptions of
type Level3Exception will be caught by the first catch clause, so the
second catch clause in this program will not have an opportunity to
catch a Level3Exception. The third catch clause has a parameter e of
type Level1Exception, so the third catch clause is able to catch a
Level1Exception. The exceptions of type Level2Exception and
Level3Exception are assignable to the catch clause parameter of the
third catch clause, but the exceptions of those subclass types will be
caught by the first two catch clauses. The switch statement throws a
Level1Exception. The try block completes abruptly as control passes
to the third catch block where d is incremented. The finally block is
also executed, so f is incremented.  
Question 13
class Level1Exception extends Exception {}
class Level2Exception extends Level1Exception {}
class Level3Exception extends Level2Exception {}
class Brown {
public static void main(String args[]) {
int a, b, c, d, f; a = b = c = d = f = 0;
int x = 2;
try {
switch (x) {
case 1: throw new Level1Exception();
case 2: throw new Level2Exception();
case 3: throw new Level3Exception();
} a++; }
catch (Level3Exception e) {b++;}
catch (Level2Exception e) {c++;}
catch (Level1Exception e) {d++;}
finally {f++;}
System.out.print(a+","+b+","+c+","+d+","+f);
}}

What is the result of attempting to compile and run the program?

a.  Prints: 0,0,0,1,1

b.  Prints: 0,0,1,1,1
c.  Prints: 0,1,1,1,1
d.  Prints: 1,1,1,1,1
e.  Prints: 0,0,1,0,1
f.  Prints: 0,1,0,0,1
g.  Prints: 1,0,0,0,1
h.  Compile-time error
i.  Run-time error
j.  None of the above

ANSWER
The first catch block is able to catch a Level3Exception or any
subclass of Level3Exception. The second catch block is able to catch
Prints: a Level2Exception or any subclass of Level2Exception. The switch
13 e 
0,0,1,0,1  statement throws a Level2Exception. The try block completes
abruptly as control passes to the second catch block where c is
incremented. The finally block is also executed, so f is incremented.

Question 14
class Level1Exception extends Exception {}
class Level2Exception extends Level1Exception {}
class Level3Exception extends Level2Exception {}
class Brown {
public static void main(String args[]) {
int a, b, c, d, f; a = b = c = d = f = 0;
int x = 4;
try {
switch (x) {
case 1: throw new Level1Exception();
case 2: throw new Level2Exception();
case 3: throw new Level3Exception();
} a++; }
catch (Level3Exception e) {b++;}
catch (Level2Exception e) {c++;}
catch (Level1Exception e) {d++;}
finally {f++;}
System.out.print(a+","+b+","+c+","+d+","+f);
}}

What is the result of attempting to compile and run the program?

a.  Prints: 0,0,0,1,1

b.  Prints: 0,0,1,1,1
c.  Prints: 0,1,1,1,1
d.  Prints: 1,1,1,1,1
e.  Prints: 0,0,1,0,1
f.  Prints: 0,1,0,0,1
g.  Prints: 1,0,0,0,1
h.  Compile-time error
i.  Run-time error
j.  None of the above

ANSWER
The switch statement does not throw an exception; so the switch
Prints: completes normally. The subsequent statement increments the
14 g 
1,0,0,0,1  variable, a; and the try block completes normally. The finally block
is also executed, so f is incremented.  

Question 15
class ColorException extends Exception {}
class WhiteException extends ColorException {}
abstract class Color {
abstract void m1() throws ColorException;
}
class White extends Color {
void m1() throws WhiteException {throw new WhiteException();}
public static void main (String[] args) {
 White white = new White();
int a,b,c; a = b = c = 0;
try {white.m1(); a++;}
catch (WhiteException e) {b++;}
finally {c++;}
System.out.print(a+","+b+","+c);
}}

What is the result of attempting to compile and run the program?

a.  Prints: 0,0,0

b.  Prints: 0,0,1
c.  Prints: 0,1,0
d.  Prints: 0,1,1
e.  Prints: 1,0,0
f.  Prints: 1,0,1
g.  Prints: 1,1,0
h.  Prints: 1,1,1
i.  Compile-time error
j.  Run-time error
k.  None of the above

ANSWER
The try block contains two statements. The first invokes method m1,
and the subsequent statement contains a post increment expression with
the variable, a, as the operand. Method m1 throws a WhiteException
Prints: exception, so variable a is not incremented as control passes to the
15 d 
0,1,1  catch block where b is incremented. Although Color.m1 declares a
ColorException in the throws clause, a subclass of Color is free to
declare only a subclass of ColorException in the throws clause of the
overriding method.  

Question 16
class RedException extends Exception {}
class BlueException extends Exception {}
class White {
void m1() throws RedException {throw new RedException();}
public static void main (String[] args) {
White white = new White();
int a,b,c,d; a = b = c = d = 0;
try {white.m1(); a++;}
catch (RedException e) {b++;}
catch (BlueException e) {c++;}
finally {d++;}
System.out.print(a+","+b+","+c+","+d);
}}
What is the result of attempting to compile and run the program?

a.  Prints: 0,1,0,0

b.  Prints: 1,1,0,1
c.  Prints: 0,1,0,1
d.  Prints: 0,1,1,1
e.  Prints: 1,1,1,1
f.  Compile-time error
g.  Run-time error
h.  None of the above

ANSWER
A compile-time error is generated, because the second catch
Compile-time
16 f  clause attempts to catch an exception that is never thrown in the
error 
try block.  

Question 17
class Level1Exception extends Exception {}
class Level2Exception extends Level1Exception {}
class Level3Exception extends Level2Exception {}
class Purple {
public static void main(String args[]) {
int a,b,c,d,f,g,x;
a = b = c = d = f = g = 0;
x = 1;
try {
throw new Level1Exception();
try {
switch (x) {
case 1: throw new Level1Exception();
case 2: throw new Level2Exception();
case 3: throw new Level3Exception();
} a++; }
catch (Level2Exception e) {b++;}
finally {c++;}
}
catch (Level1Exception e) { d++;}
catch (Exception e) {f++;}
finally {g++;}
System.out.print(a+","+b+","+c+","+d+","+f+","+g);
}}

What is the result of attempting to compile and run the program?

a.  Prints: 1,1,1,0,0,1

b.  Prints: 0,1,1,0,0,1
c.  Prints: 0,1,0,0,0,0
d.  Prints: 0,1,0,0,0,1
e.  Prints: 0,0,1,0,0,1
f.  Compile-time error
g.  Run-time error
h.  None of the above

ANSWER
A throw statement is the first statement in the outer try block. A
throw statement appearing in a try block causes control to pass out
Compile- of the block. Consequently, statements can not be reached if they
17 f 
time error  appear in the block after the throw statement. The switch statement
that appears after the throw statement is unreachable and results in a
compile-time error.