Java MCQ Questions – Page 131 of 200

Q: What kind of error will occur when compiling this Java code?

A) Compile-time error: unreported exception IOException; must be caught or declared to be thrown (for write method). The `write()` method of `BufferedWriter` can throw an `IOException`, which is a checked exception. In this code, the `IOException` thrown by `bw.write("Test data.")` is not caught by the `NullPointerException` catch block, nor is it declared to be thrown by the `main` method. This results in a compile-time error.

Q: Under what circumstance would a `do-while` loop in Java result in an infinite loop?

B) When the loop's condition always evaluates to `true` and there is no `break` statement.. An infinite loop occurs when the loop's termination condition is never met. For a `do-while` loop, this happens if the `while` condition consistently evaluates to `true` without any `break` statement.

Q: Which compile-time error will occur when compiling the `Child` class?

B) Compile-time error: 'Call to super must be first statement in constructor'.. In Java, a call to `super()` or `this()` must be the very first statement in a constructor. Placing any other statement before `super(10)` will result in a compile-time error.

Q: What is the most likely output of this code?

A) A value less than 2000, but greater than 1000.. `Thread.join()` ensures that a thread completes its execution before the calling thread proceeds, but it does not provide any memory synchronization for shared variables. `counter++` is a compound operation (read, increment, write) and without `synchronized` or `AtomicInteger`, it is subject to race conditions, leading to lost updates. Therefore, the final value will almost certainly be less than 2000 but more than 1000 (as each thread at least starts incrementing).

Q: What is the compile-time error in the `Human` class?

A) The `Human` class must be declared `abstract` or implement the `breath()` method.. A concrete class that extends an abstract class must implement all inherited abstract methods. Since `Human` does not implement `breath()`, it must itself be declared `abstract`, leading to a compile-time error on Line 7.

Q: What is the minimum number of times the code inside a do-while loop will execute?

A) 1. The do-while loop guarantees that the code block within the 'do' statement executes at least once before the 'while' condition is checked.

Q: You are designing an API for a critical financial system. A specific operation might fail due to an invalid input parameter provided by the *caller*, indicating a programming error in the calling code, rather than a transient system issue. Which type of custom exception is most appropriate for this scenario, and why?

B) An unchecked exception extending `RuntimeException`, indicating a fault that should typically lead to program termination or be fixed by the developer.. Unchecked exceptions (extending `RuntimeException`) are suitable for programming errors (e.g., invalid arguments) because they represent faults that usually cannot be recovered from programmatically and should be addressed by fixing the code, rather than forcing the caller to catch them.

Q: Which of the following methods must be called from within a `synchronized` block or method?

B) Object.wait(). `Object.wait()`, `notify()`, and `notifyAll()` methods can only be called by the thread that owns the monitor (lock) of the object. If called outside a `synchronized` context, they will throw an `IllegalMonitorStateException`.

Q: Which of the following methods, when called on a `Thread` object, *can* throw an `InterruptedException`?

D) `join()`. The `join()` method causes the current thread to wait for the completion of the target thread. If the current thread is interrupted while waiting, `join()` throws an `InterruptedException`.

Q: What is the primary advantage of using an `if-else if-else` ladder compared to a series of independent `if` statements (without `else`) for handling multiple mutually exclusive conditions?

B) It guarantees that only one block of code among the ladder will be executed.. An `if-else if-else` ladder ensures that once a condition is met and its corresponding block is executed, the rest of the ladder is skipped, preventing multiple blocks from executing for mutually exclusive conditions.

Q2601 easy code error

What kind of error will occur when compiling this Java code?

java

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        BufferedWriter bw = null;
        try {
            bw = new BufferedWriter(new FileWriter("output.txt"));
            // The write() method can throw IOException, but it's not caught by NullPointerException
            bw.write("Test data.");
        } catch (NullPointerException e) {
            System.err.println("Caught NPE: " + e.getMessage());
        }
    }
}

Q2602 medium

Under what circumstance would a `do-while` loop in Java result in an infinite loop?

Q2603 medium code error

Which compile-time error will occur when compiling the `Child` class?

java

class Parent {
    Parent(int x) {
        System.out.println("Parent: " + x);
    }
}

class Child extends Parent {
    Child() {
        System.out.println("Child default constructor");
        super(10); 
    }
}

public class Main {
    public static void main(String[] args) {
        new Child();
    }
}

Q2604 hard code output

What is the most likely output of this code?

java

public class JoinWithoutSyncTest {
    private int counter = 0; // Not volatile, not synchronized

    public void increment() {
        for (int i = 0; i < 1000; i++) {
            counter++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        JoinWithoutSyncTest test = new JoinWithoutSyncTest();
        Thread t1 = new Thread(test::increment);
        Thread t2 = new Thread(test::increment);

        t1.start();
        t2.start();

        t1.join(); // Main waits for t1 to finish
        t2.join(); // Main waits for t2 to finish

        System.out.println("Final counter: " + test.counter);
    }
}

Q2605 hard code error

What is the compile-time error in the `Human` class?

java

abstract class LivingBeing {
    abstract void breath();
    public void eat() {
        System.out.println("Eating...");
    }
}
class Human extends LivingBeing { // Line 7
    public void talk() {
        System.out.println("Talking...");
    }
}
public class World {
    public static void main(String[] args) {
        LivingBeing h = new Human();
        h.eat();
    }
}

Q2606 easy

What is the minimum number of times the code inside a do-while loop will execute?

Q2607 hard

You are designing an API for a critical financial system. A specific operation might fail due to an invalid input parameter provided by the *caller*, indicating a programming error in the calling code, rather than a transient system issue. Which type of custom exception is most appropriate for this scenario, and why?

Q2608 medium

Which of the following methods must be called from within a `synchronized` block or method?

Q2609 medium

Which of the following methods, when called on a `Thread` object, *can* throw an `InterruptedException`?

Q2610 medium

What is the primary advantage of using an `if-else if-else` ladder compared to a series of independent `if` statements (without `else`) for handling multiple mutually exclusive conditions?

Q2611 easy

`FileReader` is designed to read data as what type of stream?

Q2612 medium code output

What does the following Java code print?

java

import java.io.IOException;
import java.io.FileNotFoundException;

class Processor {
    void processFile() throws IOException {
        System.out.println("Processor handling generic file");
    }
}

class ImageProcessor extends Processor {
    @Override
    void processFile() throws FileNotFoundException { // Valid: FileNotFoundException is a subclass of IOException
        System.out.println("ImageProcessor handling image file");
    }
}

public class Main {
    public static void main(String[] args) {
        Processor p = new ImageProcessor();
        try {
            p.processFile();
        } catch (IOException e) {
            System.out.println("Caught exception");
        }
    }
}

Q2613 easy code output

What does this Java code print?

java

import java.io.File;
import java.io.IOException;

public class FileTest {
    public static void main(String[] args) {
        File file = new File("temp_file_q10.txt");
        try {
            file.createNewFile();
            System.out.println(file.isFile() + " " + file.isDirectory());
        } catch (IOException e) {
            System.out.println("Error");
        } finally {
            file.delete(); // Clean up
        }
    }
}

Q2614 easy code error

What is the error in this code?

java

import java.util.TreeMap;

public class Test {
    public static void main(String[] args) {
        TreeMap<Object, String> map = new TreeMap<>();
        map.put("StringKey", "Value1");
        map.put(100, "Value2"); // Integer key
        System.out.println(map.size());
    }
}

Q2615 easy

What happens if you directly call the `run()` method of an object that implements `Runnable` instead of passing it to a `Thread` and calling `start()`?

Q2616 medium code output

What is the final state of thread `t` printed in the output?

java

public class ThreadStateDemo9 {
    private static final Object monitor = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            synchronized (monitor) {
                try {
                    System.out.println("Thread is timed waiting.");
                    monitor.wait(100); // Wait for 100ms
                    System.out.println("Thread resumed after timeout.");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
        t.start();
        Thread.sleep(50); // Ensure thread enters wait()
        System.out.println("State of t (mid-wait): " + t.getState());
        Thread.sleep(100); // Allow timeout
        System.out.println("State of t (final): " + t.getState());
    }
}

Q2617 medium code output

What does this code print?

java

import java.util.LinkedList;

public class Test {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("One");
        list.add("Two");
        String[] arr = list.toArray(new String[0]);
        System.out.println(arr.length + " " + arr[0]);
    }
}

Q2618 easy code error

What kind of error will occur when compiling this Java code?

java

public class Main {
    public static void main(String[] args) {
        int score = 85;
        else {
            System.out.println("Invalid score");
        }
    }
}

Q2619 medium code output

What is the output of this code snippet regarding StringBuilder equality?

java

public class StringBuilderTest {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder("test");
        StringBuilder sb2 = new StringBuilder("test");
        String s1 = "test";
        System.out.println(sb1.equals(sb2) + ", " + sb1.toString().equals(s1));
    }
}

Q2620 easy

What is the return type of a constructor in Java?

☕ Java MCQ Questions – Page 131