logo

CuriousTab

CuriousTab

Discussion


Home Java Programming Inner Classes Comments

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

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


    Inner Classes problems


    Search Results


    • 1. 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
    • 2. 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
    • 3. 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
    • 4. 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
    • Discuss
    • 5. 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
    • 6. 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
    • 7. Which statement, if placed in a class other than MyOuter or MyInner, instantiates an instance of the nested class?
      public class MyOuter 
      {
          public static class MyInner 
          {
              public static void foo() { }
          }
      }
      

    • Options
    • A. MyOuter.MyInner m = new MyOuter.MyInner();
    • B. MyOuter.MyInner mi = new MyInner();
    • C. MyOuter m = new MyOuter();

      MyOuter.MyInner mi = m.new MyOuter.MyInner();

    • D. MyInner mi = new MyOuter.MyInner();
    • Discuss
    • 8. Which statement is true about a static nested class?

    • Options
    • A. You must have a reference to an instance of the enclosing class in order to instantiate it.
    • B. It does not have access to nonstatic members of the enclosing class.
    • C. It's variables and methods must be static.
    • D. It must extend the enclosing class.
    • Discuss
    • 9. At what point is the Bar object, created on line 6, eligible for garbage collection?
      class Bar { } 
      class Test 
      {  
          Bar doBar() 
          {
              Bar b = new Bar(); /* Line 6 */
              return b; /* Line 7 */
          } 
          public static void main (String args[]) 
          { 
              Test t = new Test();  /* Line 11 */
              Bar newBar = t.doBar();  /* Line 12 */
              System.out.println("newBar"); 
              newBar = new Bar(); /* Line 14 */
              System.out.println("finishing"); /* Line 15 */
          } 
      }
      

    • Options
    • A. after line 12
    • B. after line 14
    • C. after line 7, when doBar() completes
    • D. after line 15, when main() completes
    • Discuss
    • 10. When is the B object, created in line 3, eligible for garbage collection?
      void start() {  
          A a = new A(); 
          B b = new B(); 
          a.s(b);  
          b = null; /* Line 5 */
          a = null;  /* Line 6 */
          System.out.println("start completed"); /* Line 7 */
      } 
      

    • Options
    • A. after line 5
    • B. after line 6
    • C. after line 7
    • D. There is no way to be absolutely certain.
    • Discuss


    Comments

    There are no comments.

Enter a new Comment