Question 1

Java — Identify which class-level (non-local) variable declarations will not compile

Accepted Answer

Introduction / Context: This question tests knowledge of valid modifiers for class-level (non-local) variables in Java. Some modifiers are allowed for variables, while others are only valid for methods. Given Data / Assumptions: Scope: class-level variables, not local or method-level. Keywords in play: protected, transient, synchronized, volatile. Concept / Approach: For variables: Access modifiers (public, protected, private) are valid. transient and volatile are valid modifiers for variables. synchronized is not valid for variables; it only applies to methods or blocks. Step-by-Step Reasoning: protected int a; → Valid.transient int b = 3; → Valid for serialization behavior.private synchronized int e; → Invalid because synchronized cannot be applied to variables.volatile int d; → Valid, ensures visibility across threads. Why Other Options Are Wrong: All except synchronized are legal modifiers for variables. Common Pitfalls: Confusing synchronized with volatile; synchronized is only for methods/blocks, not variables. Final Answer: private synchronized int e;

Question 2

Java — Restrict method access to only other members of the same class

Accepted Answer

Introduction / Context: This checks understanding of access modifiers and their scope rules in Java. Concept / Approach: private → accessible only inside the same class. protected → accessible in the same package and subclasses. default (no modifier) → package-private access. public → accessible everywhere. Step-by-Step: We want strict restriction: "only the same class".private is the most restrictive and satisfies this. Why Other Options Are Wrong: final: restricts inheritance, not access. static: relates to class-level association. protected: allows subclass and package access, which is broader. volatile: applies to variables only, not methods. Final Answer: private

Question 3

Java — Which is a valid declaration within an interface?

Accepted Answer

Introduction / Context: This question checks the rules for declarations inside an interface in Java. Concept / Approach: Inside interfaces: Variables must be public, static, and final implicitly (even if not written). Methods must be abstract (before Java 8) or default/static (Java 8+). Access modifiers like protected and transient are invalid here. Step-by-Step: Option A: Legal. Interfaces can contain constants (public static final short stop = 23;).Option B: protected not allowed inside interface variables.Option C: transient is not valid for constants.Option D: final void madness(...) is invalid because interface methods cannot be final (they must be overridden unless default/static). Final Answer: public static short stop = 23;

Question 4

Java — Which code fragment allows successful compilation with inner class instantiation? public class Outer  {      public void someOuterMethod()      {         //Line 5      }      public class Inner { }           public static void main(String[] a…

Accepted Answer

Introduction / Context: This evaluates knowledge of inner class instantiation rules in Java. Concept / Approach: Non-static inner classes require an outer class instance for instantiation. Syntax is: Outer.Inner obj = outerInstance.new Inner(); Step-by-Step: At Line 5 (inside Outer): "new Inner()" is valid because we are already in the scope of Outer.At Line 10 (static context), we need an Outer instance.So "new ot.Inner()" is valid in main after creating Outer ot = new Outer(). Why Other Options Are Wrong: "new Inner()" at line 10 fails (needs outer reference). "new Outer.Inner()" is valid only if Inner is static. Final Answer: new ot.Inner(); //At line 10

Question 5

Java — Which overriding declarations are valid in a subclass of class A? class A  {       protected int method1(int a, int b)      {         return 0;      }  }

Accepted Answer

Introduction / Context: This evaluates the rules of overriding regarding access modifiers, return types, and static usage in Java. Concept / Approach: Overridden methods can increase visibility (protected → public is valid). Return type must be the same or covariant; short is not covariant with int. Overridden methods cannot be static if the original was not static. Access cannot be reduced (protected → private is invalid). Step-by-Step: Option A: Valid override (protected → public, same return type).Option B: Invalid (reduces visibility).Option C: Invalid (return type mismatch).Option D: Invalid (adds static to non-static method). Final Answer: public int method1(int a, int b) { return 0; }

Question 6

Java — Most restrictive access modifier that still allows class members in the same package to access each other

Accepted Answer

Introduction / Context: This question checks knowledge of package-private (default) access in Java. Concept / Approach: Modifiers in Java: public → visible everywhere. protected → visible in same package + subclasses in other packages. default (no modifier) → visible only within the same package. private → visible only in same class. Step-by-Step: For restricting to "same package": default access is the most restrictive that still allows package sharing. Final Answer: default access

Question 7

Java — Which of the following are legal method declarations?

Accepted Answer

Introduction / Context: This evaluates knowledge of valid method declarations and combinations of modifiers in Java. Concept / Approach: All provided combinations are syntactically legal: protected abstract → valid for abstract classes. static final → legal (cannot be overridden, final ensures this). synchronized public final → legal combination, just unusual. private native → legal; native methods are often private. Step-by-Step: All four compile correctly, though not all are meaningful in all contexts. Final Answer: All of them are legal declarations.

Question 8

Java — Which two are legal declarations for non-nested classes and interfaces?

Accepted Answer

Introduction / Context: This evaluates legal top-level class and interface declarations. Concept / Approach: A top-level class can be public or default only (not protected/private). It cannot be both final and abstract at the same time (contradiction). Interfaces cannot be static at the top level. abstract public class Test {} is legal. final public class Test {} is legal. Final Answer: final public class Test {} and abstract public class Test {}

Question 9

Java — Which three are valid method signatures in an interface?

Accepted Answer

Introduction / Context: This checks which method signatures are allowed inside interfaces. Concept / Approach: Interface methods are implicitly public and abstract (before Java 8). private is not allowed for interface methods until Java 9 (the question assumes older standard, so it is invalid). public static void main(String[] args) is not valid inside traditional interfaces (static methods in interfaces are only allowed in Java 8+). Step-by-Step: Option B: Valid abstract method.Option C: Valid abstract method (main like any method).Option E: Valid abstract method. Final Answer: 2, 3, and 5

Question 10

Java — Which three form part of correct array declarations?

Accepted Answer

Introduction / Context: This question checks the syntax for correct array declarations in Java. Concept / Approach: In Java arrays: The brackets [] must follow either the type or the variable, but not the access modifier directly. Array size cannot be given at declaration (e.g., int a[3] is invalid in Java). Step-by-Step: Option A: Valid declaration.Option B: Valid declaration.Option C: Invalid syntax.Option D: Invalid (size not allowed in declaration).Option E: Invalid (size inside brackets not allowed in declaration). Final Answer: 1, 2, and 6

Question 11

In Java, which two of the following float-array declarations cause a compiler error? Choose all that apply. float[] f = new float(3); float f2[] = new float[]; float[] f1 = new float[3]; float f3[] = new float[3]; float f5[] = {1.0f, 2.0f, 2.0f};

Accepted Answer

Introduction / Context: This problem checks your knowledge of valid Java array declarations and initializations for the primitive type float. The key ideas are using square brackets for lengths, and the rules for when size specifiers or initializer lists are required. Given Data / Assumptions: We are declaring one-dimensional arrays of type float. We must identify which lines fail to compile based on Java syntax for arrays. All code snippets are assumed to be inside a valid method or class context. Concept / Approach: In Java, array creation requires square brackets for the dimension size, for example new float[3]. When using an anonymous array initializer, you either provide the size with brackets or a brace-enclosed list, not both partially. Specifically: new float[] with no initializer is illegal; you must provide {...} or an explicit size like new float[n]. Step-by-Step Solution: Check 1: float[] f = new float(3); → invalid; must be new float[3] (parentheses are not allowed).Check 2: float f2[] = new float[]; → invalid; an empty bracket form requires an initializer list, e.g., new float[] {1f,2f}.Check 3: float[] f1 = new float[3]; → valid sized array.Check 4: float f3[] = new float[3]; → valid alternative bracket placement.Check 5: float f5[] = {1.0f, 2.0f, 2.0f}; → valid initializer list. Verification / Alternative check: Compiling a minimal class with each line confirms errors for 1 and 2 and successful compilation for 3, 4, and 5. Why Other Options Are Wrong: Options involving 3, 4, or 5 mark valid declarations as errors; those are legal. Common Pitfalls: Using parentheses instead of square brackets for array size; forgetting that new float[] must be accompanied by an initializer list. Final Answer: 1, 2

Question 12

Java access control: You want a class to access members of another class in the same package. What is the most restrictive access modifier that still allows access?

Accepted Answer

Introduction / Context: Access control in Java defines visibility across classes, packages, and inheritance hierarchies. This question asks for the most restrictive modifier that still permits access between two classes in the same package. Given Data / Assumptions: Two classes reside in the same package. We want the smallest possible visibility that still allows access. We compare public, private, protected, and default (package-private). Concept / Approach: Java provides four levels: private (class only), default/package-private (same package), protected (same package and subclasses in other packages), and public (everywhere). For same-package access, default/package-private is sufficient and more restrictive than protected or public. Step-by-Step Solution: private → only within the same class; too restrictive.default (no modifier) → accessible to any class in the same package; meets requirement.protected → also visible to subclasses in other packages; less restrictive than needed.public → visible everywhere; least restrictive. Verification / Alternative check: JLS confirms package-private visibility for members with no modifier and that it is the minimal scope for same-package access. Why Other Options Are Wrong: private blocks access; protected and public grant more access than required. Common Pitfalls: Confusing protected with package-private; protected includes package access but also adds cross-package subclass access. Final Answer: default (package-private) access

Question 13

For the empty class below, what is the exact prototype of its compiler-provided default constructor? public class Test { }

Accepted Answer

Introduction / Context: When you do not declare any constructor, the Java compiler provides a no-argument default constructor. Understanding its signature and access level is important for instantiation and subclassing. Given Data / Assumptions: An empty public class named Test. No user-declared constructor is present. Concept / Approach: The compiler synthesizes a no-arg constructor with the same access level as the class. In this case the class is public, so the generated constructor is public Test(). Java does not use void in constructor parameter lists, so signatures like Test(void) are invalid. Step-by-Step Solution: No explicit constructor detected → compiler inserts a default.Class access is public → constructor is also public.Constructor has no parameters and no return type → public Test(). Verification / Alternative check: Decompile the compiled class or use javap -p Test to confirm the generated constructor signature. Why Other Options Are Wrong: Test() misses the required public modifier; Test(void) and public Test(void) are illegal; protected Test() has the wrong access. Common Pitfalls: Thinking constructors can declare a return type or void; forgetting that visibility matches the class when synthesized. Final Answer: public Test()

Question 14

Java arrays: Which one of the following declarations causes a compiler error?

Accepted Answer

Introduction / Context: Two-dimensional array initialization in Java requires proper nesting of braces to form rows. This question focuses on identifying the malformed declaration among otherwise valid array declarations. Given Data / Assumptions: Single- and multi-dimensional arrays are being declared. Boxed types and primitive arrays are mixed to test syntax understanding. Concept / Approach: A two-dimensional array literal uses nested braces: new int[][] { {row1}, {row2} } or simply { {row1}, {row2} } when used with a declaration. Flat lists without nested braces are illegal for 2D arrays. Step-by-Step Solution: Option A creates a 1D int array with three elements → valid.Option B attempts to declare a 2D int array but uses two comma-separated flat lists instead of nested row braces → invalid syntax.Option C declares a 1D String array using a literal → valid.Option D creates a new boolean array using an initializer list → valid.Option E declares an Integer array with boxed values → valid. Verification / Alternative check: Correct form for B would be int[][] scores = { {2,7,6}, {9,3,45} }; Why Other Options Are Wrong: They all follow legal Java syntax for array declarations and initializations. Common Pitfalls: Forgetting inner braces for multi-dimensional initializers; mixing up new int[] { ... } versus size-based creation. Final Answer: int[][] scores = {2,7,6}, {9,3,45};

Question 15

Interfaces and abstract classes in Java: Given the interface below, which two class/interface fragments will compile? interface Base { boolean m1(); byte m2(short s); } Fragments:  interface Base2 implements Base {}  abstract class Class2 extends Ba…

Accepted Answer

Introduction / Context: This question evaluates understanding of how classes implement interfaces, how interfaces extend other interfaces, and how abstract classes can omit implementations of interface methods. Given Data / Assumptions: Base declares two methods: m1() and m2(short). We must determine which fragments are syntactically valid in Java. Concept / Approach: Key rules: (1) Interfaces extend interfaces; they do not implement them. (2) Classes implement interfaces (not extend) and must provide public implementations for interface methods unless the class is abstract. (3) An implementing method cannot reduce visibility. Step-by-Step Solution: Fragment 1: interface Base2 implements Base → invalid; interfaces must use extends.Fragment 2: abstract class ... extends Base → invalid; classes cannot extend an interface; also only one method provided.Fragment 3: abstract class ... implements Base with no bodies → valid; abstract class may defer implementation.Fragment 4: Provides a public body for m1() and can remain abstract because m2 is unimplemented → valid.Fragment 5: Uses protected for m1(); visibility is weaker than the interface's public contract → invalid. Verification / Alternative check: Compiling minimal classes with each fragment confirms that only 3 and 4 succeed. Why Other Options Are Wrong: They rely on incorrect keywords, inheritance relationships, or visibility modifiers. Common Pitfalls: Confusing extends vs. implements; forgetting that interface methods are implicitly public abstract. Final Answer: 3 and 4

Question 16

Java access control across packages: You want subclasses in any package to have access to a superclass member. What is the most restrictive modifier that satisfies this?

Accepted Answer

Introduction / Context: Java's protected access is designed for inheritance, allowing subclass access across package boundaries while remaining more restrictive than public. Given Data / Assumptions: We need member visibility in subclasses regardless of package. We prefer the most restrictive modifier that still works. Concept / Approach: protected provides access to subclasses in any package (and also to all classes in the same package). default does not cross package boundaries. private is class-only. public is more open than required. Step-by-Step Solution: private → too restrictive.default → package-only; fails across packages.protected → allows subclass access in any package → correct.public → works but is less restrictive than necessary. Verification / Alternative check: Create a subclass in a different package and verify access to a protected member compiles. Why Other Options Are Wrong: transient is unrelated (serialization marker); others either overexpose or underexpose. Common Pitfalls: Confusing protected with default. Final Answer: protected

Question 17

Which one of the following statements actually creates (allocates) a new array instance in Java?

Accepted Answer

Introduction / Context: Array creation in Java requires the new operator with proper brackets. This question asks you to identify which statement both declares and allocates an array. Given Data / Assumptions: We compare various array-related statements and select the one that certainly creates an array object. Concept / Approach: An array is an object. The allocation is explicit via new Type[dimension] or implicit via an initializer list like { ... } with properly nested braces. Type compatibility must also be correct. Step-by-Step Evaluation: A: int[] ia = new int[15]; → correct; allocates an int array of length 15.B: float fa = new float[20]; → invalid; left-hand side is a scalar float, not an array.C: char[] cannot be directly assigned from a String literal; requires "Some String".toCharArray().D: 2D initializer syntax is malformed; needs nested braces: int[][] ia = { {4,5,6}, {1,2,3} };.E: This line merely declares; it does not allocate any array. Verification / Alternative check: Compiling each statement in isolation confirms A as the only definitely allocating statement. Why Other Options Are Wrong: They are either syntactically incorrect or do not allocate an array object. Common Pitfalls: Mistaking declarations or malformed initializers for actual allocation; ignoring type mismatches. Final Answer: int[] ia = new int[15];

Question 18

Given the method below, what is the widest valid return type for methodA on line 3? public class ReturnIt { returnType methodA(byte x, double y) // Line 3 { return (long)x / y * 2; } }

Accepted Answer

Introduction / Context: Expression type promotion in Java determines the resulting type of arithmetic expressions. Choosing a compatible return type requires analyzing how primitives are promoted. Given Data / Assumptions: x is a byte, explicitly cast to long. y is a double. The expression is (long)x / y * 2. Concept / Approach: Division involving a double promotes the other operand to double, and the result is double. Multiplying a double by an int literal 2 yields a double. Therefore, the expression overall is of type double, and the return type must be compatible (double or wider in the sense of assignment compatibility; here the precise primitive type is double). Step-by-Step Solution: Cast: (long)x → long.Operation: long / double → double.Operation: double * 2 → double.Conclusion: method must return double. Verification / Alternative check: Changing return type to double compiles; using long or int requires an explicit cast (and loses precision). Why Other Options Are Wrong: int, byte, and long are narrower than double for this expression; Number is not a primitive and does not match the expression type without boxing and is not a valid primitive return type here. Common Pitfalls: Assuming the initial cast to long dictates the overall type; forgetting that any double operand dominates. Final Answer: double

Question 19

Java interfaces and constants: what happens when code attempts to modify an interface field inside a loop?  interface Count {  short counter = 0; // implicitly public static final  void countUp(); } public class TestCount implements Count {  public …

Accepted Answer

Introduction / Context: In Java, every field declared in an interface is implicitly public, static, and final. Attempting to change such a field at runtime violates the final constraint and should be caught at compile time. This question verifies familiarity with these interface rules and constant behavior. Given Data / Assumptions: Interface Count declares short counter = 0. Class TestCount implements Count and references counter directly. The for loop tries to execute ++counter in its update expression. Concept / Approach: Because Count.counter is a compile-time constant (final), it cannot be incremented. The statement ++counter attempts to assign a new value to a final variable, which is illegal. The compiler flags the increment as an error. Step-by-Step Solution: Recognize that interface fields are final → immutable.Loop header contains ++counter → tries to modify a final field.Compiler emits an error similar to "cannot assign a value to final variable counter".No bytecode is generated; program does not run. Verification / Alternative check: A correct approach would use a local variable, e.g., short c = counter; then modify c within the loop while comparing against a fixed boundary. Why Other Options Are Wrong: All printed sequences assume successful compilation and execution. Common Pitfalls: Forgetting the implicit modifiers on interface fields; assuming counter is an instance field that can be changed. Final Answer: Compilation fails

Question 20

Java constructors vs. methods with the class name: will a method declared as "void A()" act as a constructor?  public class A {  void A() { // not a constructor due to return type  System.out.println("Class A");  }  public static void main(String[] …

Accepted Answer

Introduction / Context: This checks whether you can distinguish a true Java constructor from a method that merely shares the class name. A constructor has no return type, not even void. If a return type is present, the member is a regular method and will not be invoked by object creation unless called explicitly. Given Data / Assumptions: Class A declares void A() { System.out.println("Class A"); }. No explicit constructor is declared. main executes new A(). Concept / Approach: Because void A() has a return type, it is not a constructor. The compiler synthesizes a default no-argument constructor A() that does nothing. Therefore, new A() calls this implicit constructor, not the method, resulting in no output. Step-by-Step Solution: Parse declarations: method named A with return type void.No user-defined constructor → default constructor is provided.new A() invokes the default constructor, which has an empty body.Program terminates without printing. Verification / Alternative check: Remove the return type: change "void A()" to "A()". Then new A() would print "Class A". Why Other Options Are Wrong: Class A: Would require the method to be a real constructor or to be called explicitly. Compilation fails / exception: The code is valid and runs. Common Pitfalls: Assuming any member with the class name is a constructor; forgetting that a return type disqualifies it as such. Final Answer: The code executes with no output.

Declarations and Access Control Questions