Java MCQ Questions – Page 143 of 200

Q: In a traditional Java `for` loop (`for (initializer; condition; update)`), which combination of the three parts can be *legally omitted* without necessarily causing a compile-time error, potentially leading to an infinite loop?

A) All three parts can be omitted, resulting in `for (;;)` which is a syntactically valid infinite loop.. All three parts of a traditional `for` loop's header are optional. Omitting all three, `for (;;) {}`, is valid syntax and creates an infinite loop because the condition defaults to `true` when absent.

Q: Consider the following Java code. What will be printed to the console?

A) JOHN DOE. The constructor initializes the 'name' field with 'john doe'. The 'getName()' method, which provides controlled access to the private field, returns the name converted to uppercase.

Q: Consider the following declarations: `String s1 = "hello";` `String s2 = new String("hello");` `String s3 = "hello";` Which statement correctly describes the outcome of `s1 == s3` and `s1 == s2`?

B) `s1 == s3` is true, `s1 == s2` is false.. String literals `s1` and `s3` refer to the same object in the String pool, so `s1 == s3` is true. `s2` is created using `new String()`, which always creates a new object on the heap, separate from the String pool, so `s1 == s2` is false.

Q: What is the result of executing this Java code snippet?

A) A ClassCastException occurs at runtime when 'stringList.get(0)' is called.. Due to type erasure, the cast `(List ) rawList` compiles with an unchecked warning. However, `rawList` (which is actually `intList`) contains an `Integer` (10) at index 0. When `stringList.get(0)` is called, it retrieves the `Integer` 10, and then the JVM attempts to implicitly cast it to `String` (because `s` is `String`), which results in a `ClassCastException`.

Q: What is the output of this code?

A) Error: Failed to process! [Code: 101]. The `processData(true)` call triggers the `ProcessingException` with a message and error code. The `catch` block successfully catches this exception and prints both the message and the custom error code using the `getErrorCode()` method.

Q: What runtime error will this Java code produce?

C) java.lang.NullPointerException. When an `Integer` object is used in an arithmetic expression with a primitive `int`, Java's autoboxing/unboxing mechanism attempts to unbox the `Integer` to an `int` primitive. If the `Integer` reference is `null`, this unboxing operation will attempt to dereference a null object, leading to a `java.lang.NullPointerException` at runtime.

Q: What error will this Java `TreeMap` code snippet generate?

D) The code runs successfully, but the map might behave unexpectedly.. The `compareTo` method violates the general contract for `Comparable` and `Comparator`, specifically the transitivity and consistency with `equals`. Returning 0 when objects are not equal can lead to a `TreeMap` treating distinct keys as identical, overwriting entries or failing to store them. While it doesn't immediately throw a runtime exception, it leads to logical errors and unexpected behavior, meaning it runs successfully but incorrectly.

Q: What is a key advantage of using immutable objects, especially in multi-threaded environments?

C) They are inherently thread-safe because their state cannot change.. Since immutable objects cannot change state after creation, they are automatically thread-safe, as there's no risk of data corruption from concurrent modifications.

Q: What is the output of this code?

C) A living being is created. A human is created.. When an instance of `Human` is created, its constructor is called. The `Human` constructor implicitly calls the superclass (`LivingBeing`) constructor first, printing the superclass message, then its own message.

Q: What is the output of this Java code snippet?

A) HelloWorld. The `flush()` method writes the buffered content to the underlying writer, but does not close the stream. Subsequent writes append to the stream, and `close()` also flushes before closing.

Q2841 hard

In a traditional Java `for` loop (`for (initializer; condition; update)`), which combination of the three parts can be *legally omitted* without necessarily causing a compile-time error, potentially leading to an infinite loop?

Q2842 easy code output

Consider the following Java code. What will be printed to the console?

java

public class Employee {
    private String name;
    private int id;

    public Employee(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public String getName() {
        return name.toUpperCase(); // Returns name in uppercase
    }

    public static void main(String[] args) {
        Employee emp = new Employee("john doe", 101);
        System.out.println(emp.getName());
    }
}

Q2843 medium

Consider the following declarations: `String s1 = "hello";` `String s2 = new String("hello");` `String s3 = "hello";` Which statement correctly describes the outcome of `s1 == s3` and `s1 == s2`?

Q2844 hard code error

What is the result of executing this Java code snippet?

java

import java.util.ArrayList;
import java.util.List;

public class GenericsCasting {
    public static void main(String[] args) {
        List<Integer> intList = new ArrayList<>();
        intList.add(10);
        
        List rawList = intList; 
        rawList.add("Hello"); 
        
        List<String> stringList = (List<String>) rawList; 
        String s = stringList.get(0); 
        System.out.println(s);
    }
}

Q2845 medium code output

What is the output of this code?

java

class ProcessingException extends RuntimeException {
    private int errorCode;
    public ProcessingException(String message, int code) {
        super(message);
        this.errorCode = code;
    }
    public int getErrorCode() {
        return errorCode;
    }
}

public class Main {
    public static void processData(boolean fail) {
        if (fail) {
            throw new ProcessingException("Failed to process!", 101);
        }
        System.out.println("Data processed successfully.");
    }

    public static void main(String[] args) {
        try {
            processData(true);
        } catch (ProcessingException e) {
            System.out.println("Error: " + e.getMessage() + " [Code: " + e.getErrorCode() + "]");
        }
    }
}

Q2846 hard code error

What runtime error will this Java code produce?

java

public class OperatorError7 {
    public static void main(String[] args) {
        Integer i = null;
        int j = 10;
        int result = i + j; // Error line
        System.out.println(result);
    }
}

Q2847 medium code error

What error will this Java `TreeMap` code snippet generate?

java

import java.util.TreeMap;

class Key implements Comparable<Key> {
    int value;
    public Key(int v) { this.value = v; }
    @Override
    public int compareTo(Key other) {
        if (this.value > other.value) return 1;
        return 0; // This is problematic
    }
}

public class Main {
    public static void main(String[] args) {
        TreeMap<Key, String> map = new TreeMap<>();
        map.put(new Key(1), "A");
        map.put(new Key(2), "B");
        map.put(new Key(3), "C"); // This might cause an issue
    }
}

Q2848 easy

What is a key advantage of using immutable objects, especially in multi-threaded environments?

Q2849 easy code output

What is the output of this code?

java

abstract class LivingBeing {
    public LivingBeing() {
        System.out.println("A living being is created.");
    }
    abstract void breath();
}

class Human extends LivingBeing {
    public Human() {
        // super() is implicitly called here
        System.out.println("A human is created.");
    }
    @Override
    void breath() {
        System.out.println("Breathing air.");
    }
}

public class Test {
    public static void main(String[] args) {
        Human h = new Human();
    }
}

Q2850 medium code output

What is the output of this Java code snippet?

java

import java.io.BufferedWriter;
import java.io.StringWriter;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        StringWriter sw = new StringWriter();
        BufferedWriter bw = new BufferedWriter(sw);
        bw.write("Hello");
        bw.flush();
        bw.write("World");
        bw.close();
        System.out.print(sw.toString());
    }
}

Q2851 medium

Which of the following is the correct way to declare and initialize a 3x4 two-dimensional integer array in Java?

Q2852 hard

Why are `break` and `continue` statements not directly applicable or typically used within the functional operations of the Java 8 Streams API (e.g., `filter`, `map`, `forEach`)?

Q2853 medium code error

What will be the compilation error in this code?

java

class Vehicle {
    public final void start() {
        System.out.println("Vehicle started.");
    }
}

class Car extends Vehicle {
    @Override
    public void start() {
        System.out.println("Car started.");
    }
}

Q2854 easy code error

What is the compilation error in the following Java code snippet?

java

public class LoopError {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println("Iteration " + i);
            i++;
        } while (i < 3)
    }
}

Q2855 hard code output

What does this code print?

java

abstract class Logger {
    public static abstract void log(String message);
}

class ConsoleLogger extends Logger {
    // Cannot override static method
    // public static void log(String message) { System.out.println("LOG: " + message); }
}

public class StaticAbstractTest {
    public static void main(String[] args) {
        // Code would be here if no error
    }
}

Q2856 hard

In Java, arrays are covariant. Which of the following statements correctly describes a potential runtime issue stemming from array covariance?

Q2857 easy code output

What is the output of this Java code?

java

public class LoopTest {
    public static void main(String[] args) {
        for (int i = 5; i > 2; i--) {
            System.out.print(i);
        }
    }
}

Q2858 easy

Which of the following classes is a common concrete implementation of the `Queue` interface in Java?

Q2859 easy code error

What is the compilation or runtime error in the following Java code?

java

public class Main {
    public static void main(String[] args) {
        String text = "Hello World";
        String sub = text.substring(0, 12);
        System.out.println(sub);
    }
}

Q2860 hard code output

What is the output of this code?

java

class ValidationException extends Exception {
    private final int errorCode;
    public ValidationException(String message, int errorCode) {
        super(message + " [Code: " + errorCode + "]");
        this.errorCode = errorCode;
    }
    public int getErrorCode() { return errorCode; }
}
public class Main {
    public static void validateInput(int value) throws ValidationException {
        if (value < 0 || value > 100) { throw new ValidationException("Input value out of range", 101); }
        System.out.println("Input valid: " + value);
    }
    public static void main(String[] args) {
        try { validateInput(150); }
        catch (ValidationException e) {
            System.out.println("Error: " + e.getMessage());
            System.out.println("Details: Code " + e.getErrorCode());
        }
    }
}

☕ Java MCQ Questions – Page 143