Java Practice Test - 3

The indexOf() method in Java is case-sensitive. The string str is 'Foolish boy.' with capital 'F' in 'Fool'. When we search for the lowercase substring 'fool', it doesn't match because Java considers character case. Since the substring is not found, indexOf() returns -1, which is the standard behavior indicating 'substring not present.'

In Java, 'public' is an access modifier (controls visibility), not a return type. Return types specify what data type a method returns: void (returns nothing), boolean (returns true/false), or any class type like Button. Access modifiers like public, private, protected are separate concepts that specify who can access the method, not what it returns.

The while loop continues as long as number < number2 (12). Starting from 0, number increments by 1 each iteration. After 11 iterations, number becomes 11, which is still < 12, so one more iteration occurs, setting number to 12. Now 12 < 12 is false, so the loop exits. Final value is 12.

In Java, any decimal literal like 9.6352 is by default of type double, which is a 64-bit floating-point type. The float type (32-bit) exists but requires an 'f' suffix (e.g., 9.6352f). The capitalized versions 'Float' and 'Double' refer to wrapper class objects, not primitive types. So 9.6352 is implicitly a double.

Java follows standard mathematical precedence: multiplication before addition. So 2 + 3 * 5 = 2 + (3 * 5) = 2 + 15 = 17. Since all operands are integers, the result is also an integer (int), not a byte. The '17, int' option correctly captures both the calculated value and the data type.

The while loop iterates 4 times (index 0, 1, 2, 3). Each iteration assigns 10000 to salaries[index]. After index=3 iteration, salaries[3] = 10000. The array doesn't accumulate values - each position gets exactly 10000. This is assignment, not addition. Option D is correct.

Java has exactly 6 primitive numeric data types: 4 integer types (byte, short, int, long) and 2 floating-point types (float, double). This totals 6 numeric primitives. Option A (8) is wrong - that would include non-numeric types like boolean and char. Options B (4) and C (2) are too low.

In Java, floating-point literals are double by default. To assign a float value, append 'f' or 'F' to make it a float literal. Option D (interest = 3929.92f) correctly uses the float suffix.

Java has default types for numeric literals. Integer literals (like 42) are int by default. Floating-point literals (like 3.14) are double by default. Option D correctly states both defaults.

Strings are zero-indexed. 'Java' has indices 0-3 (J=0, a=1, v=2, a=3). charAt(4) attempts to access index 4 which doesn't exist, throwing StringIndexOutOfBoundsException.

The garbage collector in Java runs as a daemon thread. Daemon threads are low-priority background threads that don't prevent JVM from exiting when user threads finish.

When a thread completes execution or is stopped, it enters the dead (terminated) state. A dead thread cannot be restarted or run again.

Hashtable extends Dictionary in Java's legacy collections framework. Note: Dictionary is deprecated and Hashtable should be Hashtable (capital T), but the inheritance relationship is correct.

HashSet extends AbstractSet in Java's collections framework. LinkedList implements List (List is an interface), AbstractSet implements Set, and WeakHashMap extends AbstractMap.

Exception extends Throwable in Java's exception hierarchy. Throwable is the base class, with Exception and Error as its two main subclasses. Checked and unchecked exceptions extend from Exception.

(2) is correct because wait() always causes the current thread to go into the object's wait pool.
(5) is correct because sleep() will always pause the currently running thread for at least the duration specified in the sleep argument (unless an interrupted exception is thrown).
(6) is correct because, assuming that the thread you're calling join() on is alive, the thread calling join() will immediately block until the thread you're calling join() on is no longer alive.
(1) is wrong, but tempting. The yield() method is not guaranteed to cause a thread to leave the running state, although if there are runnable threads of the same priority as the currently running thread, then the current thread will probably leave the running state.
(3) and (4) are incorrect because they don't cause the thread invoking them to leave the running state.
(7) is wrong because there's no such method.

The code doesn't compile because the method GetResult() in class A is final and so cannot be overridden.

Option D is correct. Garbage collection takes place after the method has returned its reference to the object. The method returns to line 6, there is no reference to store the return value. so garbage collection takes place after line 6.
Option A is wrong. Because the reference to obj1 is stored in obj2[0]. The Object obj1still exists on the heap and can be accessed by an active thread through the reference stored in obj2[0].
Option B is wrong. Because it is only one of the references to the object obj1, the other reference is maintained in obj2[0].
Option C is wrong. The garbage collector will not be called here because a reference to the object is being maintained and returned in obj2[0].

Because all of these expressions use the + operator, there is no precedence to worry about and all of the expressions will be evaluated from left to right. If either operand being evaluated is a String, the + operator will concatenate the two operands; if both operands are numeric, the + operator will add the two operands.

The reference variables b and x both refer to the same boolean array. count is incremented for each call to the set() method, and once again when the first if test istrue. Because of the && short circuit operator, count is not incremented during the second if test.