Basic Interview Questions

• Platform independent: code compiles to bytecode that runs on any JVM ("write once, run anywhere").
• Object-oriented: everything lives in classes; supports encapsulation, inheritance, polymorphism, abstraction.
• Robust and secure: strong typing, no pointer arithmetic, automatic garbage collection, exception handling.
• Multithreaded: built-in threads and a rich concurrency library.
• High performance: the JIT compiler turns hot bytecode into native machine code.

• public: the JVM must be able to call it from outside the class.
• static: called without creating an object of the class.
• void: returns nothing to the JVM (use System.exit(code) for an exit code).
• String[] args: command-line arguments.

Everything else (String, arrays, objects) is a reference type. Defaults apply only to fields, not local variables.

Java is always pass-by-value. For objects, the value passed is a copy of the reference. So a method can change the object's fields, but reassigning the parameter does not affect the caller's variable.

public class Main {
    static void change(StringBuilder sb) {
        sb.append(" World");          // modifies the same object
        sb = new StringBuilder("New"); // only changes the local copy of the reference
    }

    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");
        change(sb);
        System.out.println(sb);
    }
}

Hello World

== compares primitive values, or for objects it checks whether two references point to the same object. equals() compares content when the class overrides it (String, Integer, records, collections do).

public class Main {
    public static void main(String[] args) {
        String a = "java";
        String b = "java";
        String c = new String("java");
        System.out.println(a == b);       // same pooled object
        System.out.println(a == c);       // different objects
        System.out.println(a.equals(c));  // same content
        System.out.println(a == c.intern());
    }
}

true
false
true
true

A static field or method belongs to the class (one copy shared by all objects, loaded with the class). An instance member belongs to each object. Static methods cannot use this or access instance members directly. Static blocks run once when the class is loaded.

Wrapper classes (Integer, Double, Boolean...) wrap primitives as objects so they can be used in collections and generics. Autoboxing converts int → Integer automatically; unboxing does the reverse. Unboxing null throws NullPointerException.

public class Main {
    public static void main(String[] args) {
        Integer a = 127, b = 127;
        Integer c = 128, d = 128;
        System.out.println(a == b);       // cached object
        System.out.println(c == d);       // two different objects
        System.out.println(c.equals(d));  // always compare with equals
    }
}

true
false
true