Java Foundations Associate Free Sample Questions

The Math class in the java.lang package consists of static methods and constants. Static members belong to the class itself, not to any specific instance. Therefore, they are called using the class name, like Math.pow(), without needing to create an object (e.g., new Math()). In fact, the Math class has a private constructor, so it cannot be instantiated.

The static keyword declares a method that belongs to the class itself rather than to a specific instance of the class. This allows the method to be called using the class name (e.g., UtilityClass.calculateArea(5.0)) without needing to create an object first. This is the standard approach for creating utility methods.

The method rand.nextInt(bound) generates a random integer from 0 (inclusive) to bound (exclusive). To get a number from 1 to 6, we need a range of 6 possible numbers (1, 2, 3, 4, 5, 6). rand.nextInt(6) generates a number from 0 to 5. Adding 1 to this result shifts the range to 1 to 6, which correctly simulates a standard six-sided die roll.

Method overloading requires that each method with the same name has a unique parameter list (either the number of parameters or the types of parameters). The method signature is defined by the method name and its parameter types. The return type and parameter names are not part of the signature. Methods 1 (process(int data)) and 4 (process(int value)) have the exact same signature: process(int). This duplicate signature will cause a compilation error. Methods 2 and 3 have unique parameter lists and are valid overloads.

A single Java source file (.java) can have at most one public class. If a public class exists, the filename must match the class name exactly (e.g., class MyClass must be in MyClass.java). A file can contain multiple non-public (package-private) classes, but only one can be declared public.

In Java, when an arithmetic operation is performed on two integers, the result is also an integer. This is known as integer division. The expression x / y (which is 5 / 2) evaluates to 2, truncating the decimal part. Only after this integer result is calculated is it assigned to the double variable z. The integer 2 is then implicitly cast to a double, becoming 2.0 for the assignment. To get 2.5, at least one of the operands would need to be a double (e.g., (double) x / y).

A switch statement is ideal when comparing a single variable against multiple discrete constant values. The logic required fits this pattern perfectly. Using a switch with case labels for 1, 2, and 3, and a default case for all other values, results in code that is cleaner, more readable, and often more efficient than a long if-else-if chain.

The break statement is used to terminate the enclosing loop (in this case, the for loop) immediately. When id is -1, the break statement will be executed, and control will transfer to the first statement after the loop. This fulfills the requirement to stop processing. continue would only skip the current iteration, and return would exit the entire method.

This design correctly implements all requirements. Using private final for username and email ensures they are set only once via the constructor and cannot be changed, fulfilling the immutability requirement. Making all fields private enforces encapsulation. The single constructor taking all required fields ensures a valid object state upon creation. Providing getters for all fields allows data to be read, while providing setters (mutators) only for displayName and biography correctly implements the business logic that only these two fields can be modified after creation.