Interview Questions and Answers

class Example {
    private Object obj;
}

class Example {
    private int value;
    public Example(int val) {
        this.value = val;
    }
}

class Example {
    private int value;
}

    Example obj1 = new Example(); // calls the default constructor
    Example obj2 = new Example(5); // calls the constructor with one int argument
    Example obj3 = new Example(5, 10); // calls the constructor with two int arguments

    class Example {
        private int value;
        public Example(int val) {
          this.value = val;
        }
        public Example(Example obj) {
          this.value = obj.value;
        }
    }

    Example obj1 = new Example(5);
    Example obj2 = new Example(obj1); // calls the copy constructor

    class Example {
        public static int value;
      }

    Example.value = 5;
    System.out.println(Example.value);

    class Example {
        public static void printValue() {
           System.out.println("Hello World");
        }
     }

    Example.printValue();

    public static void main(String[] args) {
        // code here
     }

class Example {
   static {
      // code here
   }
}

    class Example {
        private int value;
        public Example(int value) {
          this.value = value;
        }
        public void setValue(int value) {
          this.value = value;
        }
    }

    class Example {
        private int value;
        public Example(int value) {
          this = new Example();   // Compilation error, you cannot assign a value to this
        }
    }

    class Shape {
        public void draw() {
          System.out.println("Drawing a shape");
        }
      }
      class Circle extends Shape {
        public void draw() {
          System.out.println("Drawing a circle");
        }
    }

    class Engine {
        // Engine code here
     }
     
     class Car {
        Engine engine;
     }

    super.field; // to access a field of the parent class
    super.method(); // to call a method of the parent class
    super(args); // to call a constructor of the parent class

    class Calculator {
        int add(int a, int b) {
            return a + b;
        }
        double add(double a, double b) {
            return a + b;
        }
    }

    class Calculator {
        static int add(int a, int b) {
            return a + b;
        }
        static double add(double a, double b) {
            return a + b;
        }
    }

    class Shape {
        void draw() {
            System.out.println("Drawing a shape");
        }
    }
    
    class Circle extends Shape {
        @Override
        void draw() {
            System.out.println("Drawing a circle");
        }
    }

    class Parent {
        static void print() {
            System.out.println("Parent");
        }
    }
    class Child extends Parent {
        static void print() {
            System.out.println("Child");
        }
    }

    class MyClass {
        final int x = 10; // final instance variable
        final static int y = 20; // final static variable
    }

    class Parent {
        final void print() {
            System.out.println("Parent");
        }
    }
    
    class Child extends Parent {
        // cannot override the print() method
    }

    final class MyFinalClass {
        // class members
    }
    
    class MySubClass extends MyFinalClass {
        // This will give an error because MyFinalClass is final
    }

    class A {
        void print() {
            System.out.println("A");
        }
    }
    
    class B extends A {
        void print() {
            System.out.println("B");
        }
    }
    
    A a = new B();
    a.print();

class Shape {
    void draw() {
        System.out.println("Drawing a shape");
    }
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a circle");
    }
}

object instanceof class

Shape shape = new Circle();
if (shape instanceof Circle) {
    System.out.println("shape is an instance of Circle");
}

abstract class Shape {
    abstract void draw();
}
class Circle extends Shape {
    void draw() {
        System.out.println("Drawing a circle");
    }
}

abstract class Shape {
    abstract void draw();
    void fill(){
        System.out.println("Filling the shape");
    }
}

interface Shape {
    void draw();
    void fill();
}

class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing a circle");
    }
    public void fill() {
        System.out.println("Filling the circle");
    }
}

class MyClass implements Serializable {
    // class members
}

package com.example.mypackage;
public class MyClass {
    // class code
}

try {
    int a = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Error: " + e);
}

try {
    int a = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Error: " + e);
} finally {
    System.out.println("Cleaning up resources.");
}

    try {
        // some code that might throw an exception
     } finally {
        // code that needs to be executed regardless of exception
     }

    public void divide(int x, int y) {
        if (y == 0) {
            throw new ArithmeticException("Cannot divide by zero");
        }
        int result = x / y;
    }

    public void divide(int x, int y) throws ArithmeticException {
        if (y == 0) {
            throw new ArithmeticException("Cannot divide by zero");
        }
        int result = x / y;
    }

    String str1 = "Hello";
    String str2 = "Hello";
    System.out.println(str1 == str2); // true

    String str1 = new String("Hello");
    String str2 = new String("Hello");
    
    System.out.println(str1 == str2); // false
  

    String str = "Hello";
    str = str + " World";

    final class ImmutableExample {
        private final int id;
        private final String name;
    
        public ImmutableExample(int id, String name) {
            this.id = id;
            this.name = name;
        }
    
        public int getId() {
            return id;
        }
    
        public String getName() {
            return name;
        }
    }

    Object obj = new Object();
    System.out.println(obj.toString()); // Output: java.lang.Object@hashcode

    class MyClass {
        private int id;
        private String name;
     
        public MyClass(int id, String name) {
           this.id = id;
           this.name = name;
        }
     
        public String toString() {
           return "MyClass [id=" + id + ", name=" + name + "]";
        }
     }

    class OuterClass {
        // ...
        class InnerClass {
            // ...
        }
    }

    Object obj1 = new Object();
    Object obj2 = obj1;
    obj1 = new Object();  // obj2 references the original object, obj1 is unreferenced

    public void method() {
        Object obj = new Object();
    }  // obj goes out of scope and becomes unreferenced

    Object obj = new Object();
    obj = null;  // obj is unreferenced

    List<"Object> list = new ArrayList<>();
    Object obj = new Object();
    list.add(obj);
    list.remove(obj); // obj is unreferenced

    class MyClass {
        private FileInputStream in;
        public MyClass(File f) throws FileNotFoundException {
            in = new FileInputStream(f);
        }
        protected void finalize() throws IOException {
            in.close();
        }
    }

    public class MySerializableObject implements Serializable {
        private int id;
        private String name;
        // constructor and getters/setters
    }
    
    MySerializableObject obj = new MySerializableObject(1, "name");
    FileOutputStream fos = new FileOutputStream("object.ser");
    ObjectOutputStream oos = new ObjectOutputStream(fos);
    oos.writeObject(obj);
    oos.close();

    FileInputStream fis = new FileInputStream("object.ser");
    ObjectInputStream ois = new ObjectInputStream(fis);
    MySerializableObject obj = (MySerializableObject) ois.readObject();
    ois.close();

    FileInputStream fis = new FileInputStream("object.ser");
    ObjectInputStream ois = new ObjectInputStream(fis);
    MySerializableObject obj = (MySerializableObject) ois.readObject();
    ois.close();

    class MyTask implements Runnable {
        public void run() {
            // task logic
        }
    }
    Thread t = new Thread(new MyTask());
    t.start();

    class MyThread extends Thread {
        public void run() {
            // task logic
        }
    }
    
    MyThread t = new MyThread();
    t.start();

    class Data {
        private int value;
        public synchronized void setValue(int value) {
            this.value = value;
            notify();
        }
        public synchronized int getValue() {
            while (value == 0) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return value;
        }
    }
    
    class Producer extends Thread {
        private Data data;
        public Producer(Data data) {
            this.data = data;
        }
        public void run() {
            for (int i = 1; i <= 10; i++) {
                data.setValue(i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    class Consumer extends Thread {
        private Data data;
        public Consumer(Data data) {
            this.data = data;
        }
        public void run() {
            for (int i = 1; i <= 10; i++) {
                int value = data.getValue();
                System.out.println("Consumer: " + value);
            }
        }
    }
    
    Data data = new Data();
    Producer p = new Producer(data);
    Consumer c = new Consumer(data);
    p.start();
    c.start();

    class Data {
        private int value;
        public synchronized void setValue(int value) {
            this.value = value;
            notify();
        }
        public synchronized int getValue() {
            while (value == 0) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return value;
        }
    }

    class Data {
        private int value;
        public synchronized void setValue(int value) {
            this.value = value;
            notify();
        }
        public synchronized int getValue() {
            while (value == 0) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return value;
        }
    }

    class MyThread extends Thread {
        public void run() {
            // code to be executed in the new thread
        }
    }
    
    MyThread myThread = new MyThread();
    myThread.start();

    class MyRunnable implements Runnable {
        public void run() {
            // code to be executed in the new thread
        }
    }
    
    MyRunnable myRunnable = new MyRunnable();
    Thread thread = new Thread(myRunnable);
    thread.start();

    Thread t1 = new Thread(new MyRunnable());
    t1.start();
    t1.join();

    Thread.sleep(1000);  // sleep for 1 second

    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        // handle the exception
    }

    Thread t = new Thread(new MyRunnable());
    t.setDaemon(true);
    t.start();

    public synchronized void method() {
        // critical section
    }

    Lock lock = new ReentrantLock();
    lock.lock();
    try {
        // critical section
    } finally {
        lock.unlock();
    }

    public void method() {
        // non-synchronized code
        synchronized (this) {
            // critical section
        }
        // non-synchronized code
    }

    public static synchronized void method() {
        // critical section
    }

    static {
        synchronized(MyClass.class) {
            // critical section
        }
    }

    synchronized (obj) {
        // critical section
        obj.notify();
    }

    synchronized (obj) {
        // critical section
        obj.notifyAll();
    }

    Thread 1:
    synchronized (obj1) {
        // critical section
        synchronized (obj2) {
            // critical section
        }
    }
    
    Thread 2:
    synchronized (obj2) {
        // critical section
        synchronized (obj1) {
            // critical section
        }
    }