Java · Beginner interview

The JVM (Java Virtual Machine) executes Java bytecode and provides platform independence — 'write once, run anywhere'. The JRE (Runtime Environment) is the JVM plus the standard libraries needed to run Java programs. The JDK (Development Kit) is the JRE plus development tools like the compiler (javac) and debugger. You develop with the JDK; the JVM runs the compiled bytecode.

Primitives (int, double, boolean) hold values directly and are fast; wrapper classes (Integer, Double, Boolean) are objects that can be null and used in generics/collections. Autoboxing automatically converts between them (int ↔ Integer). It's convenient but has costs — unexpected NullPointerExceptions when unboxing a null, and Integer caching making == unreliable for boxed values.

== compares references for objects (whether they're the same instance) and values for primitives. equals() compares logical equality as defined by the class — String.equals compares characters, for example. So two different String objects with the same text are == false but equals true. You almost always use equals() for objects and reserve == for primitives and null checks.

Encapsulation: bundling data with methods and hiding internal state behind a public interface. Inheritance: a subclass reusing and extending a superclass. Polymorphism: one interface, many implementations — a call resolves to the actual object's method at runtime. Abstraction: exposing essential behaviour while hiding implementation detail. Together they organize code for reuse and flexibility.

An interface declares a contract — methods a class must implement — and a class can implement many interfaces (multiple inheritance of type); since Java 8 it can also have default methods. An abstract class can have state, constructors, and concrete methods but a class extends only one. Use an interface for capability/contract across unrelated types, an abstract class to share common state and behaviour among related types.

Overloading is defining multiple methods with the same name but different parameter lists in the same class — resolved at compile time by the arguments. Overriding is a subclass providing a new implementation of a superclass method with the same signature — resolved at runtime by the object's actual type (dynamic dispatch). Overloading is compile-time polymorphism; overriding is runtime polymorphism.

A List is an ordered collection allowing duplicates, accessed by index (ArrayList, LinkedList). A Set is a collection of unique elements with no duplicates (HashSet, TreeSet). A Map stores key→value pairs with unique keys (HashMap, TreeMap). You pick by whether you need order/duplicates, uniqueness, or key lookup.

ArrayList is backed by a dynamic array: fast random access (O(1) by index) and cache-friendly, but inserting/removing in the middle shifts elements (O(n)). LinkedList is a doubly-linked list: fast insert/remove at the ends and during iteration, but O(n) random access. In practice ArrayList is the default; LinkedList is rarely faster except for specific queue-like patterns.

A HashMap stores entries in buckets indexed by the key's hashCode. To put or get, it hashes the key to find the bucket, then uses equals() to find the exact entry within it. This gives average O(1) lookup. That's why keys must implement hashCode and equals consistently, and why mutable keys are dangerous.

Checked exceptions (subclasses of Exception, not RuntimeException) must be declared or caught — the compiler enforces handling, used for recoverable conditions like IOException. Unchecked exceptions (RuntimeException and Error) don't need declaring, representing programming errors like NullPointerException or invalid arguments. The distinction is about whether the caller is expected to recover.

try holds risky code, catch handles specific exceptions, and finally always runs for cleanup (whether or not an exception occurred). try-with-resources declares resources that implement AutoCloseable and closes them automatically at the end of the block, even on exception — replacing manual finally-close boilerplate and avoiding resource leaks.

try (var in = new FileInputStream(path)) {
  // auto-closed
}

They're unrelated despite the names. final is a modifier: a final variable can't be reassigned, a final method can't be overridden, a final class can't be extended. finally is the block that always runs after try/catch. finalize was a method called before garbage collection (now deprecated and unreliable — you use try-with-resources or Cleaner instead).