Discussion
Home ‣ Java Programming ‣ Inner Classes Comments
- Question
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();
- Correct Answer
- MyOuter.MyInner m = new MyOuter.MyInner();
Explanation
MyInner is a static nested class, so it must be instantiated using the fully-scoped name of MyOuter.MyInner.Option B is incorrect because it doesn't use the enclosing name in the new.
Option C is incorrect because it uses incorrect syntax. When you instantiate a nested class by invoking new on an instance of the enclosing class, you do not use the enclosing name. The difference between Option A and C is that Option C is calling new on an instance of the enclosing class rather than just new by itself.
Option D is incorrect because it doesn't use the enclosing class name in the variable declaration.
- 1. 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
- 2. 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
- 3. 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
- 4. 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
- 5. 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
- 6. 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
- 7. 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
- 8. 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
- 9. What allows the programmer to destroy an object x?
Options- A. x.delete()
- B. x.finalize()
- C. Runtime.getRuntime().gc()
- D. Only the garbage collection system can destroy an object. Discuss
- delete() - Method in class java.io.File : Deletes the file or directory denoted by this abstract pathname.
- delete(int, int) - Method in class java.lang.StringBuffer : Removes the characters in a substring of this StringBuffer.
- delete(int, int) - Method in interface javax.accessibility.AccessibleEditableText : Deletes the text between two indices
- delete(int, int) - Method in class : javax.swing.text.JTextComponent.AccessibleJTextComponent; Deletes the text between two indices
- 10. When is the Demo object eligible for garbage collection?
class Test { private Demo d; void start() { d = new Demo(); this.takeDemo(d); /* Line 7 */ } /* Line 8 */ void takeDemo(Demo demo) { demo = null; demo = new Demo(); } }
Options- A. After line 7
- B. After line 8
- C. After the start() method completes
- D. When the instance running this code is made eligible for garbage collection. Discuss
Inner Classes problems
Search Results
Correct Answer: It can be marked abstract.
Explanation:
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.
Correct Answer: It can extend exactly one class or implement exactly one interface.
Explanation:
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.
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.
Correct Answer: System.out.println(new Runnable() {public void run() { }});
Explanation:
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.
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.
Correct Answer: It does not have access to nonstatic members of the enclosing class.
Explanation:
Option A is incorrect because static nested classes do not need (and can't use) a reference to an instance of the enclosing class.
Option C is incorrect because static nested classes can declare and define nonstatic members.
Option D is wrong because it just is. There's no rule that says an inner or nested class has to extend anything.
Correct Answer: after line 14
Explanation:
Option B is correct. All references to the Bar object created on line 6 are destroyed when a new reference to a new Bar object is assigned to the variable newBar on line 14. Therefore the Bar object, created on line 6, is eligible for garbage collection after line 14.
Option A is wrong. This actually protects the object from garbage collection.
Option C is wrong. Because the reference in the doBar() method is returned on line 7 and is stored in newBar on line 12. This preserver the object created on line 6.
Option D is wrong. Not applicable because the object is eligible for garbage collection after line 14.
Correct Answer: There is no way to be absolutely certain.
Correct Answer: Only the garbage collection system can destroy an object.
Explanation:
Option A is wrong. I found 4 delete() methods in all of the Java class structure. They are:
None of these destroy the object to which they belong.
Option B is wrong. I found 19 finalize() methods. The most interesting, from this questions point of view, was the finalize() method in class java.lang.Object which is called by the garbage collector on an object when garbage collection determines that there are no more references to the object. This method does not destroy the object to which it belongs.
Option C is wrong. But it is interesting. The Runtime class has many methods, two of which are:
Correct Answer: When the instance running this code is made eligible for garbage collection.
Explanation:
Option D is correct. By a process of elimination.
Option A is wrong. The variable d is a member of the Test class and is never directly set to null.
Option B is wrong. A copy of the variable d is set to null and not the actual variable d.
Option C is wrong. The variable d exists outside the start() method (it is a class member). So, when the start() method finishes the variable d still holds a reference.
Comments
There are no comments.Programming
Copyright ©CuriousTab. All rights reserved.