Discussion
Home ‣ Java Programming ‣ Exceptions Comments
- Question
What will be the output of the program?
public class X { public static void main(String [] args) { try { badMethod(); /* Line 7 */ System.out.print("A"); } catch (Exception ex) /* Line 10 */ { System.out.print("B"); /* Line 12 */ } finally /* Line 14 */ { System.out.print("C"); /* Line 16 */ } System.out.print("D"); /* Line 18 */ } public static void badMethod() { throw new RuntimeException(); } }
Options- A. AB
- B. BC
- C. ABC
- D. BCD
- Correct Answer
- BCD
Explanation(1) A RuntimeException is thrown, this is a subclass of exception.(2) The exception causes the try to complete abruptly (line 7) therefore line 8 is never executed.
(3) The exception is caught (line 10) and "B" is output (line 12)
(4) The finally block (line 14) is always executed and "C" is output (line 16).
(5) The exception was caught, so the program continues with line 18 and outputs "D".
Exceptions problems
Search Results
- 1. What will be the output of the program?
class Exc0 extends Exception { } class Exc1 extends Exc0 { } /* Line 2 */ public class Test { public static void main(String args[]) { try { throw new Exc1(); /* Line 9 */ } catch (Exc0 e0) /* Line 11 */ { System.out.println("Ex0 caught"); } catch (Exception e) { System.out.println("exception caught"); } } }
Options- A. Ex0 caught
- B. exception caught
- C. Compilation fails because of an error at line 2.
- D. Compilation fails because of an error at line 9. Discuss
Correct Answer: Ex0 caught
Explanation:
An exception Exc1 is thrown and is caught by the catch statement on line 11. The code is executed in this block. There is no finally block of code to execute.- 2. What will be the output of the program?
try { int x = 0; int y = 5 / x; } catch (Exception e) { System.out.println("Exception"); } catch (ArithmeticException ae) { System.out.println(" Arithmetic Exception"); } System.out.println("finished");
Options- A. finished
- B. Exception
- C. Compilation fails.
- D. Arithmetic Exception Discuss
Correct Answer: Compilation fails.
Explanation:
Compilation fails because ArithmeticException has already been caught. ArithmeticException is a subclass of java.lang.Exception, by time the ArithmeticException has been specified it has already been caught by the Exception class.If ArithmeticException appears before Exception, then the file will compile. When catching exceptions the more specific exceptions must be listed before the more general (the subclasses must be caught before the superclasses).
- 3. What will be the output of the program?
public class X { public static void main(String [] args) { try { badMethod(); System.out.print("A"); } catch (RuntimeException ex) /* Line 10 */ { System.out.print("B"); } catch (Exception ex1) { System.out.print("C"); } finally { System.out.print("D"); } System.out.print("E"); } public static void badMethod() { throw new RuntimeException(); } }
Options- A. BD
- B. BCD
- C. BDE
- D. BCDE Discuss
Correct Answer: BDE
Explanation:
A Run time exception is thrown and caught in the catch statement on line 10. All the code after the finally statement is run because the exception has been caught.- 4. What will be the output of the program?
public class Test { public static void aMethod() throws Exception { try /* Line 5 */ { throw new Exception(); /* Line 7 */ } finally /* Line 9 */ { System.out.print("finally "); /* Line 11 */ } } public static void main(String args[]) { try { aMethod(); } catch (Exception e) /* Line 20 */ { System.out.print("exception "); } System.out.print("finished"); /* Line 24 */ } }
Options- A. finally
- B. exception finished
- C. finally exception finished
- D. Compilation fails Discuss
Correct Answer: finally exception finished
Explanation:
This is what happens:(1) The execution of the try block (line 5) completes abruptly because of the throw statement (line 7).
(2) The exception cannot be assigned to the parameter of any catch clause of the try statement therefore the finally block is executed (line 9) and "finally" is output (line 11).
(3) The finally block completes normally, and then the try statement completes abruptly because of the throw statement (line 7).
(4) The exception is propagated up the call stack and is caught by the catch in the main method (line 20). This prints "exception".
(5) Lastly program execution continues, because the exception has been caught, and "finished" is output (line 24).
- 5. What will be the output of the program?
public class MyProgram { public static void main(String args[]) { try { System.out.print("Hello world "); } finally { System.out.println("Finally executing "); } } }
Options- A. Nothing. The program will not compile because no exceptions are specified.
- B. Nothing. The program will not compile because no catch clauses are specified.
- C. Hello world.
- D. Hello world Finally executing Discuss
Correct Answer: Hello world Finally executing
Explanation:
Finally clauses are always executed. The program will first execute the try block, printing Hello world, and will then execute the finally block, printing Finally executing.Option A, B, and C are incorrect based on the program logic described above. Remember that either a catch or a finally statement must follow a try. Since the finally is present, the catch is not required.
- 6. Which statement, inserted at line 10, creates an instance of Bar?
class Foo { class Bar{ } } class Test { public static void main (String [] args) { Foo f = new Foo(); /* Line 10: Missing statement? */ } }
Options- A. Foo.Bar b = new Foo.Bar();
- B. Foo.Bar b = f.new Bar();
- C. Bar b = new f.Bar();
- D. Bar b = f.new Bar(); Discuss
Correct Answer: Foo.Bar b = f.new Bar();
Explanation:
Option B is correct because the syntax is correct-using both names (the enclosing class and the inner class) in the reference declaration, then using a reference to the enclosing class to invoke new on the inner class.Option A, C and D all use incorrect syntax. A is incorrect because it doesn't use a reference to the enclosing class, and also because it includes both names in the new.
C is incorrect because it doesn't use the enclosing class name in the reference variable declaration, and because the new syntax is wrong.
D is incorrect because it doesn't use the enclosing class name in the reference variable declaration.
- 7. Which constructs an anonymous inner class instance?
Options- A. Runnable r = new Runnable() { };
- B. Runnable r = new Runnable(public void run() { });
- C. Runnable r = new Runnable { public void run(){}};
- D. System.out.println(new Runnable() {public void run() { }}); Discuss
Correct Answer: System.out.println(new Runnable() {public void run() { }});
Explanation:
D is correct. It defines an anonymous inner class instance, which also means it creates an instance of that new anonymous class at the same time. The anonymous class is an implementer of the Runnable interface, so it must override the run() method of Runnable.A is incorrect because it doesn't override the run() method, so it violates the rules of interface implementation.
B and C use incorrect syntax.
- 8. Which one create an anonymous inner class from within class Bar?
class Boo { Boo(String s) { } Boo() { } } class Bar extends Boo { Bar() { } Bar(String s) {super(s);} void zoo() { // insert code here } }
Options- A. Boo f = new Boo(24) { };
- B. Boo f = new Bar() { };
- C. Bar f = new Boo(String s) { };
- D. Boo f = new Boo.Bar(String s) { }; Discuss
Correct Answer: Boo f = new Bar() { };
Explanation:
Option B is correct because anonymous inner classes are no different from any other class when it comes to polymorphism. That means you are always allowed to declare a reference variable of the superclass type and have that reference variable refer to an instance of a subclass type, which in this case is an anonymous subclass of Bar. Since Bar is a subclass of Boo, it all works.Option A is incorrect because it passes an int to the Boo constructor, and there is no matching constructor in the Boo class.
Option C is incorrect because it violates the rules of polymorphism—you cannot refer to a superclass type using a reference variable declared as the subclass type. The superclass is not guaranteed to have everything the subclass has.
Option D uses incorrect syntax.
- 9. Which is true about an anonymous inner class?
Options- A. It can extend exactly one class and implement exactly one interface.
- B. It can extend exactly one class and can implement multiple interfaces.
- C. It can extend exactly one class or implement exactly one interface.
- D. It can implement multiple interfaces regardless of whether it also extends a class. Discuss
Correct Answer: It can extend exactly one class or implement exactly one interface.
Explanation:
Option C is correct because the syntax of an anonymous inner class allows for only one named type after the new, and that type must be either a single interface (in which case the anonymous class implements that one interface) or a single class (in which case the anonymous class extends that one class).Option A, B, D, and E are all incorrect because they don't follow the syntax rules described in the response for answer Option C.
- 10. Which is true about a method-local inner class?
Options- A. It must be marked final.
- B. It can be marked abstract.
- C. It can be marked public.
- D. It can be marked static. Discuss
Correct Answer: It can be marked abstract.
Explanation:
Option B is correct because a method-local inner class can be abstract, although it means a subclass of the inner class must be created if the abstract class is to be used (so an abstract method-local inner class is probably not useful).Option A is incorrect because a method-local inner class does not have to be declared final (although it is legal to do so).
C and D are incorrect because a method-local inner class cannot be made public (remember-you cannot mark any local variables as public), or static.
Comments
There are no comments.
Programming
Copyright ©CuriousTab. All rights reserved.
- 1. What will be the output of the program?