☕ Java MCQ Questions – Page 189

public class MixedLocksNotify {
    private final Object lockX = new Object();
    private final Object lockY = new Object();

    public void signalEvent() {
        synchronized (lockX) {
            System.out.println("Lock X acquired.");
            lockY.notify(); // Calling notify on lockY, while holding lockX
            System.out.println("Signal sent.");
        }
    }

    public static void main(String[] args) {
        MixedLocksNotify m = new MixedLocksNotify();
        m.signalEvent();
    }
}

import java.util.HashSet;
import java.util.Set;

class MyObject {
    int id;
    MyObject(int id) { this.id = id; }
}

public class Main {
    public static void main(String[] args) {
        Set<MyObject> objects = new HashSet<>();
        objects.add(new MyObject(1));
        objects.add(new MyObject(1));
        System.out.println(objects.size());
    }
}

public class SwitchTest {
    public static void main(String[] args) {
        int dayOfWeek = 1;
        String dayName = "";
        switch (dayOfWeek) {
            case 1:
                dayName = "Monday";
            case 2:
                dayName = "Tuesday";
                break;
            case 3:
                dayName = "Wednesday";
                break;
            default:
                dayName = "Unknown";
        }
        System.out.println(dayName);
    }
}

public class ExceptionTest {
    public static void main(String[] args) {
        try {
            int x = 10;
        } finally {
            System.out.println("Value of x: " + x);
        }
    }
}

public class FirstException extends Exception {
    public FirstException(String message) { super(message); }
}

public class SecondException extends Exception {
    public SecondException(String message) { super(message); }
}

public class DualThrower {
    public void process() throws FirstException {
        try {
            System.out.println("Attempting operation.");
            throw new FirstException("Operation failed.");
        } finally {
            throw new SecondException("Cleanup failed!");
        }
    }

    public static void main(String[] args) {
        DualThrower dt = new DualThrower();
        try {
            dt.process();
        } catch (FirstException e) {
            System.out.println("Caught First: " + e.getMessage());
        } catch (SecondException e) {
            System.out.println("Caught Second: " + e.getMessage());
        }
    }
}

public class Main {
    public static void main(String[] args) {
        if (true) {
            int x = 0;
            while (x < 5) {
                x++;
                if (x == 3) {
                    continue outerLabel; // 'outerLabel' is not defined as a loop
                }
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        boolean isAdmin = true;
        if (isAdmin) {
            System.out.println("Welcome, Admin!");
        }
    }
}

public class StringBuilderTest {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Programming");
        sb.setCharAt(0, 'P'); 
        sb.setCharAt(5, 'M'); 
        System.out.println(sb);
    }
}

public class ProblematicWait implements Runnable {
    private final Object sharedLock = new Object();

    @Override
    public void run() {
        try {
            sharedLock.wait(100); // Problematic line
        } catch (InterruptedException | IllegalMonitorStateException e) {
            System.out.println("Caught: " + e.getClass().getSimpleName());
        } finally {
            System.out.println("Thread exiting.");
        }
    }

    public static void main(String[] args) {
        ProblematicWait task = new ProblematicWait();
        Thread thread = new Thread(task);
        thread.start();
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            try {
                Thread.sleep(100);
                System.out.println("Task finished.");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        };
        Thread t = new Thread(task);
        t.start();
        t.join(); // Wait for t to complete
        System.out.println("Main thread completed after join.");
    }
}

public class ConditionCheck {
    public static void main(String[] args) {
        int num = 7;
        if (num % 2 == 0)
            System.out.println("Even");
            System.out.println("Number is valid");
        else
            System.out.println("Odd");
    }
}

class Base {
    static void log() {
        System.out.println("Base log");
    }
}

class Derived extends Base {
    @Override
    static void log() { // Attempting to override static method with @Override
        System.out.println("Derived log");
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.Comparator;
import java.util.stream.Collectors;

public class StreamTest {
    public static void main(String[] args) {
        List<String> colors = Arrays.asList("red", "green", "blue", "yellow");
        String result = colors.stream()
                              .sorted(Comparator.comparing(String::length).reversed())
                              .collect(Collectors.joining(", "));
        System.out.println(result);
    }
}

import java.util.LinkedList;
import java.util.ListIterator;
import java.util.List;
import java.util.Arrays;

public class ListIteratorAddRemove {
    public static void main(String[] args) {
        List<String> list = new LinkedList<>(Arrays.asList("one", "two", "three"));
        ListIterator<String> it = list.listIterator();
        it.next(); // Passes "one"
        it.add("zero"); // Adds "zero" after "one"
        it.remove(); // Attempts to remove "zero"
    }
}

class Car {
    public Car(String type) {
        System.out.println("Car type: " + type);
    }
}

class Sedan extends Car {
    public Sedan() {
        // Missing super() call
        System.out.println("Sedan created");
    }
}

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

public enum Status {
    ACTIVE("A"), INACTIVE("I");

    private String code; // Not declared final!

    private Status(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Initial ACTIVE code: " + Status.ACTIVE.getCode());
        Status.ACTIVE.setCode("X");
        System.out.println("Modified ACTIVE code: " + Status.ACTIVE.getCode());
    }
}

class MyRunnable implements Runnable {
    // This signature is incompatible with Runnable.run()
    public void run() throws InterruptedException { 
        System.out.println("Runnable running.");
        Thread.sleep(100);
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable task = new MyRunnable();
        Thread t = new Thread(task);
        t.start();
    }
}