1Z0-811 Practice Test 10 — 10 Questions

Question 1

Given: String s1 = "Hello"; String s2 = "Hello"; String s3 = new String("Hello"); Which of the following is true?

Accepted Answer

s1 == s2 is true, s1 == s3 is false. String literals in Java are interned, meaning s1 and s2 both reference the same object from the string pool, so s1 == s2 is true. However, s3 is created using the new keyword, which forces the creation of a new String object on the heap, so s1 == s3 is false because == compares object references, not content.

Answer

s1 == s2 is false, s1 == s3 is true

Answer

s1 == s2 is true, s1 == s3 is true

Answer

s1 == s2 is false, s1 == s3 is false

Question 2

Given: int a = 9; int b = 2; double c = a / b; System.out.println(c); What is the output?

Accepted Answer

4.0. The expression `a / b` performs integer division because both operands are `int`. The result of `9 / 2` is `4` (the fractional part is truncated). This integer result is then implicitly widened to `double` when assigned to `c`, producing `4.0`. Therefore, the output is `4.0`.

Answer

4.5

Answer

0.0

Answer

4

Question 3

A company requires a method that accepts an integer and returns true if the integer is even, otherwise false. Which implementation best follows Java conventions?

Accepted Answer

public boolean isEven(int num) { return num % 2 == 0; }. It defines a method with the appropriate return type `boolean`, uses a clear and conventional name `isEven`, and returns the result of the expression `num % 2 == 0` directly. This follows Java naming conventions (camelCase with a verb for boolean methods) and leverages the fact that `%` yields the remainder, which is compared to zero to produce a boolean result.

Answer

public void isEven(int num) { System.out.println(num%2==0); }

Answer

public int isEven(int num) { return num % 2; }

Answer

public boolean evenCheck(int num) { if(num%2==0) return true; else return false; }

Question 4

A social media platform processes user login requests. Each request generates a welcome message by concatenating the username with a fixed greeting using the + operator inside a loop that runs hundreds of times per second for thousands of users. The development team notices that the application suffers from high memory consumption and slow response times under load. They profile the code and discover that the method building the welcome message is a bottleneck. The team considers several options to improve performance while maintaining thread safety. Which approach should the team implement?

Accepted Answer

Replace string concatenation with StringBuilder and allocate an initial capacity large enough to hold the final message.. StringBuilder with sufficient initial capacity reduces memory reallocations and is faster than StringBuffer for single-threaded contexts. Option A (StringBuffer) is thread-safe but slower due to synchronization, not needed here since the method is not shared across threads. Option C (concat()) still creates new strings internally, similar to + operator. Option D (intern()) does not improve performance and may cause memory issues.

Answer

Replace string concatenation with StringBuffer and use an initial capacity to minimize resizing.

Answer

Keep using the + operator but call intern() on the resulting string to reuse memory.

Answer

Replace string concatenation with the concat() method called on the greeting string.

Question 5

You are developing a high-frequency trading application where performance is critical. You need to parse and concatenate trade messages. The messages are received as strings and must be combined into a single output string for logging. Each message is appended to the log string. Currently, you are using String concatenation with the '+' operator inside a loop that processes up to 10,000 messages per second. However, performance monitoring shows that the application experiences frequent garbage collection pauses, affecting throughput. Which approach should you take to reduce garbage collection overhead and improve performance?

Accepted Answer

Use StringBuilder instead of String concatenation, ensuring that the StringBuilder is created with an appropriate initial capacity.. StringBuilder is designed for efficient string concatenation without synchronization overhead. Creating it with an appropriate initial capacity further reduces reallocations. StringBuffer is thread-safe but adds unnecessary overhead in a single-threaded context. String.concat() still creates new objects. Increasing heap size only delays GC, not reduce object creation.

Answer

Use the String.concat() method for each concatenation to reduce object creation.

Answer

Use StringBuffer instead of String concatenation because it is thread-safe and efficient.

Answer

Keep using the '+' operator but increase the heap size to reduce garbage collection frequency.

Question 6

Which access modifier allows members to be accessed only by classes in the same package?

Accepted Answer

default (no modifier). In Java, the default (package-private) access modifier, which is applied when no explicit modifier is used, restricts member access to only classes within the same package. This is the only access level that provides package-level visibility without inheritance or subclass access.

Answer

protected

Answer

private

Answer

public

Question 7

A team is developing a library management system. They have a base class 'Item' with a method 'getTitle()' that returns the title. They also have a subclass 'Book' that overrides 'getTitle()'. In some places, they have a method that accepts an Item reference but actually receives a Book object. They want to call a method specific to Book, such as 'getISBN()', that is not in Item. They attempt to cast the parameter: ((Book) item).getISBN(). However, occasionally the program crashes with ClassCastException. What is the best practice to avoid this exception?

Accepted Answer

Use if (item instanceof Book) before casting.. Using `instanceof` before casting ensures the object is actually an instance of `Book`, preventing a `ClassCastException` at runtime. This is the standard Java practice for safe downcasting when the object type is not guaranteed.

Answer

Create a separate method for Book objects.

Answer

Catch ClassCastException and handle it.

Answer

Change the parameter type to Object and then cast to Book.

Question 8

A developer writes a method that reads a file and processes its contents. If the file does not exist, the method should notify the caller. Which exception should the method declare in its throws clause?

Accepted Answer

FileNotFoundException. `FileNotFoundException` is a checked exception that specifically indicates a file cannot be found at the specified path. The method must declare it in its `throws` clause to notify the caller that this condition can occur and must be handled or re-declared, as required by Java's checked exception rules.

Answer

RuntimeException

Answer

Exception

Answer

IOException

Question 9

A calculator class has two overloaded methods: add(int a, int b) and add(double a, double b). A call to add(3, 4) will invoke which method?

Accepted Answer

add(int, int). Overloaded method resolution is based on compile-time types. The literal 3 and 4 are ints, so the int version is the most specific match and is called.

Answer

add(double, double)

Answer

Runtime decision based on actual parameters

Answer

Compilation error: ambiguous

Question 10

Which TWO statements are true about the main method?

Accepted Answer

It must be declared public.. The Java Language Specification (JLS) requires the main method to be declared public so that the JVM can access it from outside the class. Option D is correct because the main method must be static, allowing the JVM to invoke it without creating an instance of the class.

Answer

It must be declared final.

Answer

It must return an int.

Answer

It cannot be overloaded.