Model Answer: "== compares reference identity — whether two variables point to the same memory location on the heap. .equals() compares logical value equality, which is defined by the class implementation. For Strings, .equals() compares character sequences, not memory locations. Always use .equals() for value comparisons; reserve == for checking reference equality or null checks.

Model Answer: "When you pass a reference type to a method, Java copies the reference value (the memory address). The method receives a new reference pointing to the same object. This means the method can modify the object's state through that reference, but cannot reassign the caller's reference to point elsewhere. Reassigning the parameter inside the method only changes the local copy, not the original reference in the caller.

Model Answer: "For values between -128 and 127, Java uses an internal cache (IntegerCache), so == returns true because both references point to the same cached object. For values outside this range, each Integer.valueOf() creates a new object, and == returns false even if the values are equal. This is a common source of bugs — always use .equals() for Integer comparisons.

Model Answer: "The String Pool is a special memory area where Java stores literal strings for reuse. When you create a string literal ("hello"), Java checks the pool first — if the same string exists, it returns a reference to the existing object instead of creating a new one. This saves memory and enables fast reference equality for interned strings. However, strings created with new String() are always new objects on the heap, never from the pool.

Model Answer: "NullPointerException (NPE) occurs when you attempt to dereference a null reference — calling a method, accessing a field, or throwing an array element on a null reference. Prevention strategies include: 1) Null checks before use, 2) Empty collections/strings instead of null, 3) Optional<T> for potentially absent values, 4) Objects.requireNonNull() to fail fast on invalid input, 5) Defensive initialization with default values.

Model Answer: "Java has four reference strength levels: Strong (regular object references) — the GC never reclaims objects reachable via strong references. Soft (SoftReference<T>) — GC reclaims these when memory is low; useful for caches. Weak (WeakReference<T>) — GC reclaims on next GC cycle regardless of memory; useful for canonicalizing mappings. Phantom (PhantomReference<T>) — for post-mortem finalization, never returns the object. For preventing memory leaks in caches, use WeakHashMap<K, V> where keys are weak references. For in-memory caches that survive until memory pressure, use SoftReference.

Model Answer: "The GC traces reachability starting from GC roots (stack, static fields). Objects reachable via strong references are not collected. Soft references are collected when the GC determines memory is low — the JVM guarantees all soft references are cleared before throwing OutOfMemoryError. Weak references are collected on GC regardless of memory pressure. When a reference is cleared, the referent becomes eligible for collection. Reference objects themselves are enqueued in a ReferenceQueue when their referent is cleared — you can poll this queue to perform cleanup actions. This mechanism powers cleanup of cached entries, listener lists, and other weakly-held resources.

Model Answer: "Cloning creates a copy of an object. Object.clone() performs a shallow copy — fields are copied by value for primitives and by reference for objects. For reference types, this means the clone shares the same child objects as the original. To deep copy, you must either implement Cloneable and override clone to recursively clone mutable children, or use copy constructors/factories. Arrays implement clone() and return a new array with copied references (shallow). Arrays.copyOf() and Arrays.copyOfRange() also create shallow copies. For immutable objects like Strings, shallow copy is effectively safe since Strings are immutable.

Model Answer: "When you copy a reference variable (String a = new String("hello"); String b = a;), both variables point to the same object in heap memory — no actual copy is made. When you copy an array using clone(), Arrays.copyOf(), or manual element copying, you get a new array object whose elements are the same references (shallow copy). Changing clone[0] = new String("world") affects only the clone, not the original. However, if the array contains mutable objects and you modify them through the reference (clone[0].setName("X")), both arrays see the change because they share the same child object references.

Model Answer: "Java is strictly pass-by-value — even for reference types, the value being passed is the reference itself (a copy of the reference, not the object). This means: the method can modify the object's state through the reference, but cannot reassign the caller's original reference (the local parameter variable can be changed to point elsewhere, but that change doesn't affect the caller). For example: void reassign(String s) { s = new String("changed"); } — the caller's reference is unchanged. But void mutate(StringBuilder sb) { sb.append(" added"); } — the caller's StringBuilder is modified because the reference points to the same object.

Model Answer: "The equals() contract (from Object): reflexive (a.equals(a) is true), symmetric (a.equals(b) implies b.equals(a)), transitive (a.equals(b) and b.equals(c) implies a.equals(c)), consistent (multiple calls return same result if neither object changes), and null handling (a.equals(null) is false). Most reference types (String, Integer, etc.) override equals to compare values. For custom classes, you must override equals to define meaningful equality — by default (inherited from Object) it uses == which is reference identity. When overriding equals, also override hashCode to maintain the contract: equal objects must have equal hash codes.

Model Answer: "Only enum types and String (since Java 7) can be used directly as switch case labels. Arbitrary reference types cannot be switch targets — the switch expression must be assignable to the case label types. For String switch, the compiler uses String.hashCode() and equals() for matching. You cannot switch on arbitrary objects using their equals() method — you would need an if-else chain or a Map-based dispatch. For enums, the compiler generates optimized table-based switch bytecode. For objects that override equals, there's no language-level switch support — consider Map<Object, Runnable> dispatch or if-else chains.

Model Answer: "The instanceof operator checks whether an object is an instance of a given type (class, interface, enum, or array). For reference types, instanceof returns true if the object is an instance of the specified type or any subtype. It also returns true for null — null instanceof String is always false (no object to check). Use instanceof before casting to avoid ClassCastException. Example: if (obj instanceof String) { String s = (String) obj; ... }. Since Java 16, you can use pattern matching with instanceof: if (obj instanceof String s) { // s is scoped here }. This combines the type check and casting into one expression.

Model Answer: "Reference types work seamlessly with generics — List<String>, Map<String, Integer>, etc. The generic type parameter is erased at runtime (type erasure) to Object or the bound type. At runtime, List<String> and List<Integer> are the same type List. This means you cannot use primitives as type arguments — List<int> is illegal; you must use List<Integer>. Generic arrays cannot be created directly (new List<String>[5] is illegal) due to type erasure and array covariance issues. Use wildcards (?, ? extends T, ? super T) for flexible generic references.

Model Answer: "Instance fields (non-static) of reference types default to null. This is different from primitives which get type-specific defaults (0, false, etc.). Static fields of reference types also default to null. Local variables (method scope) of reference types have no default — the compiler requires initialization before use. This is why uninitialized local reference variables cause compilation errors, but uninitialized instance fields silently become null. Be aware: a null reference only causes an NPE when you attempt to dereference it — just having a null reference stored in a field is not an error itself.

Model Answer: "Autoboxing converts primitives to their wrapper equivalents (int → Integer) via valueOf(), and unboxing converts wrappers to primitives (Integer → int) via xxxValue(). This happens automatically when you pass a primitive where a wrapper is expected, or vice versa. The compiler inserts the conversion calls at the bytecode level. Autoboxing can create new objects (outside the cache range), and unboxing a null throws NPE. Collections, generics, and reflection APIs require wrapper types — autoboxing bridges the gap between primitives and the object system. See the Java Autoboxing and Unboxing article for detailed coverage.

Model Answer: "Composition ("has-a") typically means the contained object is owned and managed by the owner — when the owner is destroyed, the contained object is also destroyed. In Java, this is usually implemented with a final reference field initialized in the constructor. Reference aggregation ("uses-a") means the contained object is used but not owned — it may outlive the containing object or be shared. Aggregation is typically implemented with a non-final reference or a weak reference. Composition provides stronger encapsulation (the contained object cannot escape), while aggregation allows looser coupling but requires careful lifetime management to avoid memory leaks or dangling references.

Model Answer: "String literals created with quoted syntax ("hello") are automatically interned — stored in a JVM-managed String Pool. When you create multiple literals with the same content, they share the same object reference from the pool. This enables fast == comparisons for interned strings (e.g., comparing two literals "hello" == "hello" is true). However, strings created with new String() always create new heap objects, not from the pool. You can explicitly intern any String using str.intern() which returns the pooled reference if an equal string exists, or adds the string to the pool and returns a reference to it. This saves memory when you have many identical strings.

Model Answer: "A SoftReference<T> holds a reference that the GC may collect when memory is low. The JVM guarantees to clear all soft references before throwing OutOfMemoryError, making them ideal for memory-sensitive caches. Example: SoftReference<CacheEntry> ref = new SoftReference<>(new CacheEntry(data)); — when memory pressure increases, the GC may clear the soft reference. Check with ref.get() (returns null if cleared) and recreate if needed. Use soft references for caching images, large data structures, or computed results that are expensive to recreate. The advantage over weak references is that soft references survive until absolutely needed.

Model Answer: "ThreadLocal<T> provides thread-scoped storage — each thread gets its own independent value of type T (a reference type). The ThreadLocal holds a map from thread to value, and thread identity determines which value is retrieved. Reference types stored in ThreadLocal are subject to the same GC behavior as any reference — when no other references exist, the GC can collect the object. ThreadLocal values are not automatically cleared when a thread dies — they persist until the ThreadLocal itself is cleared or the thread is collected. This can cause memory leaks if you store large objects in ThreadLocal and the thread pool reuses threads. Always call threadLocal.remove() in cleanup code.