Free 1Z0-811 sample questions

Correct answer: The `Math.pow()` method is being called correctly, as it is a static method that does not require an object instance.

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.

Correct answer: static

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.

Correct answer: rand.nextInt(6) + 1;

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.

Correct answers: 1; 4

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.

Correct answer: False

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

Correct answer: 2.0

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`).

Correct answer: A `switch` statement.

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.

Correct answer: break;

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.

Correct answers: Arrays have a fixed size determined at creation, while `ArrayLists` can dynamically resize.; The size of an array is retrieved using the `length` property, whereas the size of an `ArrayList` is retrieved using the `size()` method.

Correct answer: A class with `private final` fields for username and email, and `private` fields for displayName and biography. A constructor initializes the three required fields. Getters are provided for all fields, but setters are only provided for displayName and biography.

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.