logo

CuriousTab

CuriousTab

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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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


    Comments

    There are no comments.

Enter a new Comment