☕ Java MCQ Questions – Page 8

public class Main {
    public static void main(String[] args) {
        try {
            break;
        } catch (Exception e) {
            System.out.println("Caught exception");
        }
    }
}

class SimpleCounter {
    private int count = 0;
    public synchronized void increment() {
        count++;
        System.out.print(count);
    }
}

public class MyProgram {
    public static void main(String[] args) throws InterruptedException {
        SimpleCounter sc = new SimpleCounter();
        Thread t1 = new Thread(() -> sc.increment());
        Thread t2 = new Thread(() -> sc.increment());
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

public class LabeledNonLoopContinue {
    public static void main(String[] args) {
        int count = 0;
        outerBlock: { 
            for (int i = 0; i < 3; i++) {
                if (i == 1) {
                    continue outerBlock;
                }
                count++;
            }
        }
        System.out.println("Count: " + count);
    }
}

import java.io.BufferedReader;
import java.io.StringReader;
import java.io.IOException;

public class MyClass {
    public static void main(String[] args) {
        BufferedReader br = new BufferedReader(new StringReader("hello"));
        try {
            String line = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        br.close();
    }
}

import java.io.FileReader;
import java.io.IOException;
import java.io.File;
import java.io.FileWriter;

public class FileReaderIssue {
    public static void main(String[] args) throws IOException {
        File tempFile = File.createTempFile("test", ".txt");
        FileWriter writer = new FileWriter(tempFile);
        writer.write("Hello");
        writer.close();
        
        FileReader reader = new FileReader(tempFile);
        char[] buffer = null; // Null buffer
        reader.read(buffer); // Attempt to read into null buffer
        reader.close();
        tempFile.deleteOnExit();
    }
}

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Double> prices = new ArrayList<>();
        prices.add(19.99);
        prices.add(25.50);
        prices.clear();
        System.out.println(prices.isEmpty());
    }
}

import java.io.*;

public class FileWriterError7 {
    public static void main(String[] args) {
        File file = new File("readonly.txt");
        try {
            // Create and close the file first to ensure it exists
            new FileWriter(file).close(); 
            file.setReadOnly(); // Set the file to read-only
            
            // Attempt to write to the read-only file in overwrite mode
            FileWriter fw = new FileWriter(file, false); 
            fw.write("New data");
            fw.close();
        } catch (IOException e) {
            System.out.println("Error: " + e.getClass().getSimpleName() + " - " + e.getMessage());
        } finally {
            file.setWritable(true); // Make writable to ensure deletion
            file.delete(); // Clean up
        }
    }
}

class Parent {
    public void display() {
        System.out.println("Parent's display");
    }
}

class Child extends Parent {
    @Override
    protected void display() {
        System.out.println("Child's display");
    }
}

import java.util.TreeMap;

public class Main {
    public static void main(String[] args) {
        TreeMap<Character, Double> treeMap = new TreeMap<>();
        treeMap.put('X', 10.0);
        treeMap.put('Y', 20.0);
        treeMap.put('X', 30.0); // Overwrites the previous value
        System.out.println(treeMap.get('X'));
    }
}

class Printer {
    public void printDocument() {
        System.out.println("Printing document...");
    }
}

public class Main {
    public static void main(String[] args) {
        Printer printer = new Printer();
        Runnable runnablePrinter = printer; // Attempt to assign non-Runnable to Runnable
        new Thread(runnablePrinter).start();
    }
}

class MyClass {
    MyClass() {
        this(); // Recursive constructor invocation
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
    }
}

interface ServiceA {
    void performA();
}

interface ServiceB {
    void performB();
}

@FunctionalInterface
interface CombinedService extends ServiceA, ServiceB {
    // This interface itself has no abstract methods, but inherits two from parents.
}

public class Main {
    public static void main(String[] args) {
        // Attempt to use CombinedService
    }
}

public class CharArrayMutability {
    public static void main(String[] args) {
        char[] charArray = {'a', 'b', 'c'};
        charArray[1] = 'x';
        System.out.println(charArray);
    }
}

interface Processor {
    void process();
}

public class LambdaError {
    static int data = 100;

    public static void executeProcessor(Processor p) {
        p.process();
    }

    public static void main(String[] args) {
        int localData = 50;
        executeProcessor(() -> {
            data = data + localData; // Modifying static field using effectively final local variable
        });
        System.out.println(data);
    }
}

public class LambdaThread {
    public static void main(String[] args) {
        Thread myThread = new Thread(() -> {
            System.out.println("Lambda thread says hi from " + Thread.currentThread().getName());
        });
        myThread.start();
    }
}

public class Test {
    public static void main(String[] args) {
        int[] values = new int[4];
        values[0] = 5;
        values[2] = 15;
        System.out.println(values[0] + values[1]);
    }
}