Question 1

Java — Create an instance of a non-static member inner class from outside its outer class: class Foo  {     class Bar { } } class Test  {     public static void main (String [] args)      {         Foo f = new Foo();         /* Line 10: Missing stat…

Accepted Answer

Introduction / Context: This tests knowledge of instantiating a non-static member inner class. Such a class requires an instance of the outer class to create the inner instance, and its type name must be qualified with the outer class name. Given Data / Assumptions: Foo has a non-static inner class Bar. In Test.main, we already have Foo f = new Foo(). Concept / Approach: Syntax for member inner class instantiation is: OuterClass.InnerClass var = outerInstance.new InnerClass(); The unqualified InnerClass name is not visible at top level; you must use the qualified type. Step-by-Step Solution: Use Foo.Bar as the type on the left-hand side.Use f.new Bar() to bind the new inner instance to the existing Foo instance f.Therefore: Foo.Bar b = f.new Bar(); Verification / Alternative check: Trying new Foo.Bar() without an instance fails because Bar is not static; trying Bar b = f.new Bar() fails because Bar is not in scope without Foo qualification. Why Other Options Are Wrong: new Foo.Bar() requires Bar to be static; it is not. Bar b = ... uses an unqualified type name that is not visible. new f.Bar() is invalid syntax; f is a variable, not a type. Common Pitfalls: Forgetting the outer instance requirement and the qualified type name for non-static inner classes. Final Answer: Foo.Bar b = f.new Bar();

Question 2

Java — Identify which statements actually construct an anonymous inner class instance (Runnable example)

Accepted Answer

Introduction / Context: This checks syntax for anonymous inner classes that implement an interface. For interfaces, you must provide implementations of all abstract methods in the anonymous body. Given Data / Assumptions: Runnable has a single abstract method run(). Anonymous class syntax is new InterfaceName() { /* implement methods */ }. Concept / Approach: Anonymous inner class creation expressions both instantiate and define a subclass or an implementation on the spot. If the target type is an interface, the body must implement all abstract methods. Step-by-Step Solution: Option D uses new Runnable() { public void run() { } } which correctly implements run() and constructs an instance; passing it to println is fine.Option A omits run(); an anonymous class implementing Runnable without run() will not compile.Option B uses illegal syntax (method header in the parentheses).Option C misses parentheses after Runnable and has formatting issues; also invalid syntax. Verification / Alternative check: Assign the expression in D to a variable: Runnable r = new Runnable() { public void run() {} }; This compiles and constructs an anonymous class. Why Other Options Are Wrong: They violate required syntax or omit the mandatory run() implementation. Common Pitfalls: Forgetting parentheses after the type name and forgetting to implement abstract methods in the anonymous body. Final Answer: System.out.println(new Runnable() {public void run() { }});

Question 3

Java — Create an anonymous inner class instance within a subclass method: class Boo  {     Boo(String s) { }     Boo() { } } class Bar extends Boo  {     Bar() { }     Bar(String s) { super(s); }     void zoo()      {         // insert code here    …

Accepted Answer

Introduction / Context: This question focuses on valid anonymous inner class creation expressions and constructor usage in inheritance hierarchies. Given Data / Assumptions: Boo has two constructors: Boo() and Boo(String). Bar extends Boo and has Bar() and Bar(String) calling super(s). We are inside Bar.zoo(). Concept / Approach: An anonymous inner class can extend a concrete class or implement an interface. The syntax is new Type(args) { /* body */ }. The constructor arguments must match an existing constructor. The resulting instance type is an anonymous subclass of the specified type. Step-by-Step Solution: Option B constructs an anonymous subclass of Bar using the no-arg Bar() constructor. The variable type Boo is acceptable because Bar extends Boo.Option A is invalid because Boo(24) does not match any constructor (int vs String/no-arg).Option C and D use illegal anonymous class syntax (you cannot write parameter types in the type position nor qualify Boo.Bar as though it were a member class). Verification / Alternative check: Also valid would be Boo f = new Boo() { }; using Boo's no-arg constructor, but that option is not provided exactly as such. Why Other Options Are Wrong: They either use non-existent constructors or incorrect syntax for anonymous classes. Common Pitfalls: Supplying wrong constructor arguments for the chosen type, and confusing anonymous subclassing with named nested classes. Final Answer: Boo f = new Bar() { };

Question 4

Java — Truths about anonymous inner classes (capabilities and limitations)

Accepted Answer

Introduction / Context: This conceptual question checks the constraints on Java anonymous inner classes: how many super types they can specify and whether they can both extend and implement simultaneously. Given Data / Assumptions: Anonymous class syntax: new SuperType(...) { ... }. SuperType may be a class or an interface. Concept / Approach: An anonymous class must either extend one concrete/abstract class or implement one interface, not both, and not multiple interfaces at once. There is only one type name in the creation expression. Step-by-Step Explanation: If SuperType is a class, the anonymous class implicitly extends it; it cannot list interfaces there.If SuperType is an interface, the anonymous class implicitly implements that interface; it cannot list additional interfaces or a separate superclass. Verification / Alternative check: Try writing new A() implements B { } or new A() extends B { } — such constructs are not legal in Java for anonymous classes. Why Other Options Are Wrong: Options A, B, and D incorrectly allow both extending and implementing or multiple interfaces. Common Pitfalls: Confusing anonymous inner classes with named classes where you could implement multiple interfaces. Final Answer: It can extend exactly one class or implement exactly one interface.

Question 5

Java — Properties of a method-local inner class (what modifiers are allowed?)

Accepted Answer

Introduction / Context: This question verifies which modifiers are legal for a class declared within a method (a method-local inner class). These rules differ from those for member and top-level classes. Given Data / Assumptions: A method-local inner class is declared inside a method body. It is implicitly associated with the enclosing instance at runtime. Concept / Approach: Method-local inner classes cannot use access modifiers (public, private, protected) or static. They are implicitly non-static. However, they may be declared abstract or final (depending on design). The important takeaway: abstract is allowed; public and static are not. Step-by-Step Reasoning: public/private/protected: not permitted at method scope for class declarations.static: not permitted for a class declared inside a non-static context; method-local classes are inherently non-static.abstract: permitted; you can declare a method-local inner class abstract and subclass it anonymously or with another local class. Verification / Alternative check: Try compiling examples with each modifier to see which are accepted by the Java compiler. Why Other Options Are Wrong: "Must be marked final" is false; final is optional. "public" and "static" are illegal for method-local classes. Common Pitfalls: Assuming all inner classes can be static or use access modifiers; the rules depend on where the class is declared. Final Answer: It can be marked abstract.

Question 6

In Java, consider the following nested type: public class MyOuter { public static class MyInner { public static void foo() { } } } Which statement, when written from some other class (not MyOuter or MyInner), correctly instantiates the static nested…

Accepted Answer

Introduction / Context: This question tests your understanding of Java static nested classes (also called static member classes) versus inner classes. Knowing when you need an enclosing instance and how to fully qualify the nested type name is essential for compilation and readability. Given Data / Assumptions: Class MyOuter contains a static nested class MyInner. Code that instantiates MyInner is written in some other class (i.e., outside MyOuter). We must choose the statement that compiles and creates an instance correctly. Concept / Approach: A static nested class does not require an instance of the enclosing class. It behaves similarly to a top-level class that is scoped within the outer class's namespace. Therefore, you instantiate it with the fully qualified name and the usual new expression, without using an enclosing object reference. Step-by-Step Solution: Identify nested type: MyOuter.MyInner is static.Static nested class instantiation syntax: new MyOuter.MyInner().No enclosing instance is needed (unlike non-static inner classes which use outerInstance.new Inner()).Thus the correct statement is: MyOuter.MyInner m = new MyOuter.MyInner(); Verification / Alternative check: If MyInner were non-static, you would need an instance of MyOuter and the syntax would be: MyOuter outer = new MyOuter(); MyOuter.MyInner mi = outer.new MyInner(); Why Other Options Are Wrong: Option B and D omit the outer qualifier for the constructor or type; Option C incorrectly tries to use m.new MyOuter.MyInner(), which is for non-static inner classes; Option E is unqualified and invalid outside the package context without import and still wrong for a nested class. Common Pitfalls: Confusing static nested with inner classes and attempting to use the outer.new Inner() syntax when the nested class is static. Final Answer: MyOuter.MyInner m = new MyOuter.MyInner();

Question 7

In Java, which statement about a static nested class is correct?

Accepted Answer

Introduction / Context: Static nested classes in Java are often confused with inner classes. The key differences revolve around access to members of the enclosing class and whether an enclosing instance is required. Given Data / Assumptions: The nested type in question is declared static inside an outer class. We must select a true statement describing capabilities and constraints. Concept / Approach: A static nested class is associated with its outer class's type, not with any specific outer instance. It can access outer class static members directly but cannot access instance (nonstatic) members without an explicit outer object reference. Unlike inner (non-static) classes, no implicit reference to the enclosing instance is captured. Step-by-Step Solution: Recognize that static removes the implicit outer-instance binding.Conclude it cannot access nonstatic members unless you pass an outer instance explicitly and use it like any other object.Therefore, the correct choice is that it does not have access to nonstatic members of the enclosing class. Verification / Alternative check: Try referencing an instance field from a static nested class without an outer reference; the compiler will report an error. Accessing a static outer field compiles. Why Other Options Are Wrong: Option A applies to nonstatic inner classes, not static nested classes. Option C is incorrect: a static nested class can contain instance members. Option D is false: no inheritance requirement. Option E is the opposite of the rule; only static members are directly accessible. Common Pitfalls: Assuming all nested classes behave like inner classes; forgetting the difference in member access and instantiation. Final Answer: It does not have access to nonstatic members of the enclosing class.

Inner Classes Questions