☕ Java MCQ Questions – Page 60

import java.util.Date;

public class CustomImmutabilityIssue {
    private final Date creationDate;

    public CustomImmutabilityIssue(Date date) {
        this.creationDate = date;
    }

    public Date getCreationDate() {
        return creationDate;
    }

    public static void main(String[] args) {
        Date originalDate = new Date(100, 0, 1);
        CustomImmutabilityIssue obj = new CustomImmutabilityIssue(originalDate);
        originalDate.setYear(101);
        System.out.println(obj.getCreationDate().getYear());
    }
}

import java.io.*;

class Node implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    Node next;
    Node prev;

    public Node(String name) {
        this.name = name;
    }

    public void setNext(Node next) { this.next = next; }
    public void setPrev(Node prev) { this.prev = prev; }

    public String getConnections() {
        String nextName = (next != null) ? next.name : "null";
        String prevName = (prev != null) ? prev.name : "null";
        return name + " -> " + nextName + " <- " + prevName;
    }
}

public class SerializationTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Node nodeA = new Node("A");
        Node nodeB = new Node("B");
        
        nodeA.setNext(nodeB);
        nodeB.setPrev(nodeA);
        
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(nodeA);
        oos.close();

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        Node deserializedA = (Node) ois.readObject();
        ois.close();

        Node deserializedB = deserializedA.next;

        System.out.println("Node A connections: " + deserializedA.getConnections());
        System.out.println("Node B connections: " + deserializedB.getConnections());
        System.out.println("Are A.next and B the same object? " + (deserializedA.next == deserializedB));
        System.out.println("Are B.prev and A the same object? " + (deserializedB.prev == deserializedA));
    }
}

public class Main {
    public static void main(String[] args) {
        Thread t = null;
        t.start(); // Calling start() on a null reference
    }
}

import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet set = new TreeSet(); // Raw type
        set.add(Integer.valueOf(5));
        set.add("Hello");
        System.out.println(set.size());
    }
}

public class MyClass {
    public static void main(String[] args) {
        price = 99.99;
        System.out.println(price);
    }
}

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

public class Test {
    public static void main(String[] args) {
        List<Character> chars = new ArrayList<>();
        chars.add('X');
        chars.add('Y');
        chars.add('Z');
        Iterator<Character> it = chars.iterator();
        int count = 0;
        while (it.hasNext()) {
            it.next();
            count++;
        }
        System.out.println(count);
    }
}

public class Test {
    public static void main(String[] args) {
        Object[][] data = new Object[2][];
        data[0] = new String[]{"A", "B"};
        System.out.println(data[1][0]);
    }
}

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

public class Main {
    public static void main(String[] args) {
        try {
            // BufferedWriter requires a Writer object, not a String directly
            BufferedWriter bw = new BufferedWriter("output.txt");
            bw.write("Data");
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class SystemArrayCopyNullDest {
    public static void main(String[] args) {
        int[] source = {1, 2, 3};
        int[] destination = null;
        System.arraycopy(source, 0, destination, 0, source.length);
        System.out.println(source[0]);
    }
}

public class StringStripTest {
    public static void main(String[] args) {
        String s = "\u2005 Hello \n "; // U+2005 is a Four-Per-Em Space
        System.out.println(s.trim().length() + ", " + s.strip().length());
    }
}

public class StringInternNull {
    public static void main(String[] args) {
        String str = null;
        try {
            String interned = str.intern();
            System.out.println(interned);
        } catch (Exception e) {
            System.out.println(e.getClass().getSimpleName());
        }
    }
}

import java.util.TreeMap;

public class TreeMapReplaceValue {
    public static void main(String[] args) {
        TreeMap<String, Integer> map = new TreeMap<>();
        map.put("A", 1);
        map.put("B", 2);
        map.put("A", 3);
        System.out.println(map.get("A") + "," + map.size());
    }
}

public class Main {
    public static void main(String[] args) {
        int[][] matrix = {{1, 2, 3}, {4, 5, 6}};
        System.out.println(matrix[0][1]);
    }
}

public class NestedTryFinally {
    public static void main(String[] args) {
        try {
            System.out.println("Outer try");
            try {
                System.out.println("Inner try");
                throw new Exception("Inner Exception");
            } finally {
                System.out.println("Inner finally");
            }
        } catch (Exception e) {
            System.out.println("Outer catch: " + e.getMessage());
        } finally {
            System.out.println("Outer finally");
        }
    }
}

public class ThrowNull {
    public static void causeError() {
        Throwable t = null;
        throw t;
    }

    public static void main(String[] args) {
        causeError();
    }
}