Java Java Core Interview Questions

Checked exceptions must be caught or declared (IOException), while unchecked exceptions extend RuntimeException and represent programming errors that don't require declaration.

try {
  int x = Integer.parseInt("abc");
}
catch (NumberFormatException e) {
}
try {
  Thread.sleep(1000);
}
catch (InterruptedException e) {
}

Key Object methods: equals(), hashCode(), toString(), clone(), wait(), notify(), notifyAll(), getClass(), finalize().

Object obj = new Object();
obj.hashCode();
obj.equals(new Object());
obj.getClass();
obj.toString();
obj.clone();

Throwable → Exception/Error; Exception → CheckedException/RuntimeException; RuntimeException → NullPointerException, IllegalArgumentException, etc.

try {
  throw new RuntimeException("unchecked");
}
catch (Exception e) {
}
try {
  throw new IOException("checked");
}
catch (IOException e) {
}

Interfaces define contracts with abstract methods, supporting multiple inheritance; abstract classes provide partial implementation and state with single inheritance.

interface Drawable {
  void draw();
}
abstract class Shape {
  abstract void draw();
}
class Circle extends Shape implements Drawable {
  @Override public void draw() {
  }
}

hashCode() and equals() must be consistent: equal objects have same hashCode; used together in hashing structures like HashMap to determine bucket placement and collision resolution.

class Person {
  @Override public int hashCode() {
    return id;
  }
  @Override public boolean equals(Object o) {
    return this.id == ((Person)o).id;
  }
  int id;
}

Primitives (int, boolean) store values directly on stack; reference types (objects) store memory address on stack, actual data on heap.

int primitive = 5;
Integer reference = new Integer(5);
int[] arr = {
  1, 2, 3
}
;
String str = "hello";
primitive = 10;
reference = null;

Object is superclass of all Java classes; provides equals(), hashCode(), toString(), clone(), wait(), notify() methods; all classes inherit from Object.

class Demo extends Object {
  public String toString() {
    return "Demo";
  }
  public boolean equals(Object o) {
    return super.equals(o);
  }
  public int hashCode() {
    return super.hashCode();
  }
}

hashCode() and equals() must maintain: if two objects are equal (equals() returns true), they must have the same hashCode(); equals() must be reflexive, symmetric, transitive, and consistent; if you override equals(), always override hashCode().

class User {
  int id;
  String name;
  public int hashCode() {
    return id;
  }
  public boolean equals(Object o) {
    return o instanceof User && this.id == ((User)o).id;
  }
}

final makes variables immutable, finally is a block that always executes regardless of exceptions, finalize() is a deprecated Object method called before garbage collection.

final int x = 5;
try {
}
finally {
  System.out.println("always runs");
}
protected void finalize() {
  System.out.println("gc cleanup");
}

Java primitives are: byte, short, int, long, float, double, boolean, and char,stored on the stack with fixed memory sizes.

byte b = 1;
short s = 2;
int i = 3;
long l = 4L;
float f = 5.0f;
double d = 6.0;
boolean bool = true;
char c = 'a';

JVM memory areas: Stack (local variables, method calls), Heap (objects, garbage collected), Method Area (class structures, constants), Program Counter, and Native Method Stack.

Object obj = new Object();
Thread t = new Thread(() -> {
}
);
int[] arr = new int[10];
String s = new String();

Object class is the root of Java's class hierarchy, providing essential methods like equals(), hashCode(), toString(), clone(), and wait()/notify() for all objects.

class Parent {
}
class Child extends Parent {
}
Parent p = new Child();
Object o = new String();
((Object) p).equals(o);

JDK (Java Development Kit) includes compiler, libraries, and tools for development; JRE (Java Runtime Environment) contains only the JVM and libraries needed to run Java applications. JDK is a superset of JRE.

class JDKvsJRE {
  public static void main(String[] args) {
    System.out.println(System.getProperty("java.version"));
    System.out.println(System.getProperty("java.home"));
  }
}

Hashcode is an integer value generated by the hashCode() method representing an object's memory address or custom logic. It's used for hash-based collections to determine bucket placement; objects considered equal must return the same hashcode.

class HashCodeEx {
  public static void main(String[] args) {
    String s = "hello";
    System.out.println(s.hashCode());
    System.out.println("hello".hashCode());
  }
}

String pool is a memory region storing unique string literals in Java heap. When a string literal is created, JVM checks the pool first; if it exists, the reference is returned instead of creating a new object, saving memory.

class StringPoolEx {
  String s1 = "hello";
  String s2 = "hello";
  String s3 = new String("hello");
  System.out.println(s1 == s2);
  System.out.println(s1 == s3);
}

Iterator is an interface for traversing collections sequentially using hasNext() and next(). It's needed to provide a uniform way to access elements regardless of underlying collection type and enables safe removal during iteration.

class IteratorEx {
  List<String> list = Arrays.asList("a", "b");
  Iterator<String> it = list.iterator();
  while(it.hasNext()) System.out.println(it.next());
}

map() transforms each element to one output element maintaining 1:1 mapping; flatMap() transforms each element to a stream and flattens all streams into a single stream. Use flatMap when transformation produces multiple elements per input.

List<List<Integer>> nested = Arrays.asList(Arrays.asList(1,2), Arrays.asList(3,4));
List<Integer> mapped = nested.stream().map(List::size).collect(Collectors.toList());
List<Integer> flatMapped = nested.stream().flatMap(List::stream).collect(Collectors.toList());

Java has 8 primitive types: byte, short, int, long, float, double, boolean, char. All others are reference types (objects) stored on heap, while primitives are stored on stack.

byte b = 10;
short s = 20;
int i = 30;
long l = 40L;
float f = 5.5f;
double d = 6.6;
boolean bool = true;
char c = 'A';

Encapsulation bundles data (state) and methods (behavior) together while hiding internal details behind access modifiers. It provides data protection, maintainability, and allows controlled access through getters/setters.

class BankAccount {
  private double balance;
  public void deposit(double amount) {
    balance += amount;
  }
  public double getBalance() {
    return balance;
  }
}

equals() method checks logical equality of object content; hashCode() returns integer representation. Contract: equal objects must have same hashcode, but not vice versa. Both override defaults for proper behavior in hash-based collections and comparisons.

class Person {
  private String name;
  public boolean equals(Object o) {
    return this.name.equals(((Person)o).name);
  }
  public int hashCode() {
    return name.hashCode();
  }
}

Access modifiers control visibility: public (everywhere), protected (same package + subclasses), package-private/default (same package only), private (same class only). They enforce encapsulation and API boundaries.

class AccessModifiers {
  public int pub = 1;
  private int priv = 2;
  protected int prot = 3;
  int packagePrivate = 4;
}

String is an immutable, final class representing sequences of characters stored in the string pool. Immutability ensures thread-safety and allows reuse; String concatenation creates new objects; use StringBuilder for mutable operations.

String s = "hello";
String s2 = new String("hello");
System.out.println(s == s2);
System.out.println(s.equals(s2));
s = s + " world";

Exception is a checked or unchecked event that disrupts normal program flow. Checked exceptions (IOException, SQLException) must be caught/declared; unchecked exceptions (RuntimeException, NullPointerException) are not mandatory to handle.

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

Final on classes prevents inheritance, on methods prevents overriding, on variables makes them immutable after initialization.

final String constant = "immutable";
final class FinalClass {
}
final void finalMethod() {
}
int[] arr = {
  1, 2, 3
}
;
final int[] finalArr = arr;
finalArr[0] = 99;

Finalize is a deprecated method called by garbage collector before object destruction; it's unreliable and should be replaced with try-with-resources or AutoCloseable.

class Parent {
  protected void finalize() throws Throwable {
    System.out.println("Cleanup");
    super.finalize();
  }
}
Parent p = new Parent();
p = null;
System.gc();

No, static methods cannot be overridden; they can be redefined in subclasses (method hiding) but not truly overridden due to compile-time binding.

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

Transient marks fields to be excluded from serialization; when an object is deserialized, transient fields receive default values.

class User implements Serializable {
  transient String password;
  public static void main(String[] args) throws IOException {
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.bin"));
    oos.writeObject(new User());
  }
}

Consumer accepts a value and returns void (side effects); Supplier takes no arguments and returns a value; opposite functional interfaces for data flow.

Supplier<String> supplier = () -> "Hello";
Consumer<String> consumer = s -> System.out.println(s);
consumer.accept(supplier.get());

Polymorphism allows objects of different types to be treated through a common interface; enables runtime method resolution and flexible, extensible code design.

class Animal {
  void sound() {
  }
}
class Dog extends Animal {
  @Override void sound() {
    System.out.println("Woof");
  }
}
Animal a = new Dog();
a.sound();

Clone() creates a shallow copy of an object; requires implementing Cloneable and overriding the method; deep copy requires manual field cloning.

class Person implements Cloneable {
  String name;
  public Object clone() throws CloneNotSupportedException {
    return super.clone();
  }
  Person p = (Person) new Person().clone();
}

Stream API provides functional-style operations (map, filter, reduce) on collections with lazy evaluation, enabling concise, composable data transformations.

List<Integer> list = Arrays.asList(1,2,3,4,5);
list.stream().filter(n -> n > 2).map(n -> n * 2).forEach(System.out::println);

Use multiple interface implementation (classes can implement multiple interfaces) or composition; Java doesn't support true multiple inheritance to avoid the diamond problem.

interface A {
  void methodA();
}
interface B {
  void methodB();
}
class C implements A, B {
  public void methodA() {
  }
  public void methodB() {
  }
}

Garbage Collector manages heap memory by identifying and removing unreferenced objects, using algorithms like mark-sweep or generational collection to free unused memory automatically.

Object obj = new String("test");
obj = null;
System.gc();
obj = new Integer(42);

A line in Java refers to a single statement or instruction terminated by a semicolon; it's the basic executable unit of code.

String line = new BufferedReader(new InputStreamReader(System.in)).readLine();

Try-with-resources automatically closes resources implementing AutoCloseable in the try declaration, eliminating manual finally blocks and preventing resource leaks.

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
  String line = br.readLine();
}
catch (IOException e) {
  e.printStackTrace();
}

No, primitive data types are stored on the stack, not the heap (HIP); only objects are allocated on the heap.

Integer num = 128;
Integer num2 = 128;
System.out.println(num == num2);

Interfaces contain abstract methods, default methods (Java 8+), static methods, and constants; all methods define contracts for implementing classes.

Equals and hashCode must be consistent: if two objects are equal via equals(), they must return the same hashCode to function correctly in hash-based collections.

StringBuilder is unsynchronized and faster for single-threaded use; StringBuffer is synchronized and thread-safe but slower, suited for concurrent environments.

A functional interface has exactly one abstract method and enables lambda expressions and method references; marked with @FunctionalInterface annotation since Java 8.

The '==' operator compares references (memory addresses), not object content; use equals() to compare actual object values.

Java has 8 primitive types (byte, short, int, long, float, double, boolean, char) and reference types (classes, interfaces, arrays).

Encapsulation bundles data and methods together while hiding internal details through access modifiers, protecting state and enforcing controlled access.

Encapsulation (same as incapsulation) restricts direct access to object internals via private fields with public getter/setter methods, maintaining data integrity.

String Pool is a memory optimization that stores unique String literals in a dedicated pool, avoiding duplicate objects and reducing heap consumption.

Parallel Stream processes elements concurrently across multiple threads using fork-join framework, improving performance for large datasets on multi-core systems.

String Pool is a special memory region in the heap that caches immutable String objects, reusing references when identical strings are created.

JVM is the runtime engine executing bytecode, JDK includes compiler and development tools, JRE contains only the runtime to execute compiled code.

A thread in Java is the smallest unit of execution within a process; it's created from Thread class or Runnable interface and executes code concurrently.

Polymorphism allows objects of different types to be treated uniformly through a common interface, enabling method overriding and overloading for flexible code design.

No, static methods cannot be overridden; they are resolved at compile-time based on reference type, not runtime type like instance methods.

Java doesn't support multiple inheritance directly, but you can achieve it using interfaces where a class implements multiple interfaces.

Interfaces contain abstract methods (pre-Java 8), default methods, static methods, and constants; Java 8+ allows default and static method implementations.

Stream API provides a functional approach to process collections using lazy evaluation and method chaining (map, filter, reduce) for concise, readable code.

Finalize is a deprecated method called by garbage collector before object deletion; it's unreliable and should be avoided,use try-with-resources instead.

Equals and hashCode contract states: if equals() returns true, hashCode() must return same value; violation breaks HashMap/HashSet functionality.

Encapsulation hides internal implementation details behind public methods, controlling access through access modifiers (private, public, protected) for security and maintainability.

StringBuilder is non-synchronized and faster for single-threaded use; StringBuffer is synchronized (thread-safe) but slower, appropriate for multi-threaded environments.

JVM (Java Virtual Machine) executes bytecode platform-independently; JDK (Java Development Kit) includes compiler, JVM, and tools for development; JRE (Java Runtime Environment) contains JVM and libraries for running applications.

Java has primitive types (byte, short, int, long, float, double, boolean, char) and reference types (objects, arrays, strings).

Yes, primitive types can be stored in the heap when boxed as wrapper objects (Integer, Double, etc.) or used within objects, though they're naturally stack-allocated.

Transient is a modifier that excludes fields from serialization; marked fields are not included in the serialized object stream.

String Pool is a memory region that stores unique string literals; when a string is created, it's checked against the pool to reuse existing instances and save memory.

Encapsulation bundles data and methods together while hiding internal details through access modifiers, controlling how data is accessed and modified.

"==" compares object references (memory addresses), not content; use .equals() for content comparison or implement it to define equality logic.

String Pool saves memory by avoiding duplicate string instances; identical literals reference the same object, reducing heap consumption in memory-constrained environments.

Try-with-resources automatically closes resources implementing AutoCloseable; the resource is declared in parentheses after 'try' and closed in reverse order of creation.

Functional interfaces have single abstract method, enabling lambda expressions and method references; common examples are Runnable, Callable, Comparator, and Function.

Parallel Stream processes data in parallel using multiple threads; it divides the stream into chunks, processes them concurrently via ForkJoinPool, then combines results.

Garbage Collector works with heap memory, tracking objects and reclaiming unreachable instances; it uses algorithms like mark-sweep, generational collection, and G1GC.

JVM loads the class file, performs bytecode verification, initializes static variables and blocks, executes main() method, and manages memory via garbage collection during execution.

JAR manifest (META-INF/MANIFEST.MF) contains metadata like Main-Class entry point, Class-Path dependencies, version info, and custom attributes for the application.

JVM memory includes heap (shared, GC-managed objects), stack (thread-local, method frames), metaspace (class metadata), and code cache (compiled JIT code); GC removes unreachable objects via mark-and-sweep or generational strategies.

JVM determines reachability via GC root references; cyclic references are collected if not reachable from root objects, as GC uses reachability analysis, not reference counting.

Besides stack and heap: metaspace (class metadata), code cache (JIT compiled code), and off-heap memory (direct buffers).

String pool security risks include denial-of-service via hash collisions and accidental string sharing between untrusted domains; mitigate with -XX:StringTableSize tuning and input validation.

String pool is not empty at JVM start; JVM initializes it with commonly used strings and bootstrap class strings for optimization.

Lambda expressions compile to synthetic methods using invokedynamic bytecode instruction; javac generates a private static method and bootstrap method handles runtime method handle linkage.

Lambda expressions are used for functional interfaces, stream operations (map, filter), event handling, and callbacks to reduce boilerplate compared to anonymous classes.

One lambda expression body can contain multiple statements if wrapped in braces {}, but single expressions are preferred; use semicolons to separate statements and return keyword if needed.

Equals and Hashcode come from the Object class, which is the root of Java's class hierarchy; all objects inherit these methods.

Multiple objects can have the same hashCode because hashCode only provides a bucket location; equals() determines actual equality.

Java Memory Model ensures visibility and ordering of shared variable access across threads through happens-before relationships and synchronization guarantees.

Streams execute lazily; execution begins when a terminal operation (like collect(), forEach(), or reduce()) is invoked on the stream.

Default equals() and hashCode() are public methods inherited from Object class; equals uses reference comparison, hashCode uses object memory address.

Stack stores primitive values and references (LIFO, thread-local, automatically freed); Heap stores objects (shared, garbage-collected, slower access).

Main issues: collision handling, mutable objects causing hash changes, inconsistent implementation between equals() and hashCode(), and poor hash distribution.

Type erasure removes generic type information at compile-time to maintain backward compatibility; generics exist only during compilation.

A class can directly inherit from only one class; however, it can implement multiple interfaces to achieve multiple inheritance of type.

Create custom annotations using @interface keyword, define optional methods with default values, and apply meta-annotations like @Retention and @Target.

No classes are excluded from inheriting Object; all classes (except Object itself) inherit from Object, including interfaces in object context.

Type grinding (erasure) removes generic type parameters at runtime; List<String> becomes List, so generics are compile-time only.

Parameters are transmitted by value in Java; for primitives, the value is copied; for objects, the reference (address) is copied, not the object itself.

Key features: object-oriented, platform-independent (bytecode), automatic garbage collection, strong type-checking, multi-threading support, and exception handling.

Java achieves OS independence through the JVM (Java Virtual Machine), which interprets bytecode; the JVM is OS-specific, bytecode is not.

Data is stored as objects on the heap with references on the stack; primitives are stored directly on the stack; memory is managed by the garbage collector.

Objects become garbage when they're unreachable from any live reference; the GC periodically identifies and frees unreferenced objects.

Developers can suggest garbage collection via System.gc() or Runtime.gc(), but cannot force it; memory parameters are controlled via JVM flags like -Xmx and -Xms.

A class is a blueprint for creating objects; it defines properties (fields), behaviors (methods), and can extend another class or implement interfaces.

A class consists of fields (state), methods (behavior), and constructors; it's the blueprint for creating objects.

Use equals() method for logical comparison of object content, or == operator to compare object references in memory.

Name the Java versions you have actually used in production and highlight what features you leveraged from each. For example: Java 8 (streams, lambdas, Optional), Java 11 (var, HttpClient), Java 17 (records, sealed classes), Java 21 (virtual threads). If you only know Java 8, that is fine, just be honest about it.

Java's platform independence (write once, run anywhere) through bytecode compilation and JVM is the most noteworthy aspect.

Garbage Collector automatically reclaims memory by removing unreachable objects, eliminating manual memory management and preventing memory leaks.

GC identifies garbage when objects become unreachable,no references point to them from the root set or live object graph.

Common GCs include G1GC (default in Java 11+), CMS, Parallel GC, Serial GC, and newer ZGC and Shenandoah for low-latency applications.

Configure GC via JVM flags like -XX:+UseG1GC, -Xms, -Xmx for heap size, or -XX:MaxGCPauseMillis for pause time targets.

Plugins/extensions for VM creation typically include profilers, debuggers, APM agents, and custom classloaders depending on the framework.

equals() compares object content semantically, while hashCode() returns an integer hash; they must be consistent,equal objects must have equal hash codes.

Overriding both is critical for using objects in hash-based collections (HashMap, HashSet); without it, lookups fail despite logical equality.

Depends on business requirements; include only fields relevant to business identity,not all fields necessarily belong in equality logic.

Java uses checked exceptions (compile-time) and unchecked exceptions (runtime); handle with try-catch-finally or try-with-resources for resource management.

Try-catch for specific handling, try-with-resources for automatic resource closing, try-catch-finally for cleanup, and throws for delegation.

Exception overwriting occurs when a new exception is thrown in finally block, masking the original exception from try block,use suppressed exceptions to preserve both.

Finally block executes regardless of exception occurrence; use it for resource cleanup (closing streams, connections) or guaranteed cleanup logic.

Byte is a signed 8-bit primitive integer type with range -128 to 127; useful for low-level I/O and memory-constrained scenarios.

Override hashCode by implementing equals() first, then ensure equal objects return same hash code using prime multiplier (31) with object fields; violating this breaks HashMaps/HashSets.

String concatenation using + operator is converted to StringBuilder by compiler; multiple concatenations in loops create new StringBuilder instances for each operation.

Use toCharArray() method on String to convert it to char array: String str = "hello"; char[] chars = str.toCharArray();

Immutability ensures thread-safety without synchronization, prevents accidental modification, enables safe caching, and allows use as HashMap keys.

A functional interface must have exactly one abstract method; it can have default/static methods; marked with @FunctionalInterface annotation for compile-time checking.

Methods accept parameters in parentheses and return values using return keyword with specified return type; void methods don't return anything.

No, JDK is required for Java development as it includes compiler (javac), runtime (JRE), and tools; JRE alone only runs compiled code.

int is 32-bit signed primitive limited to -2^31 to 2^31-1; use long for larger values or BigInteger for arbitrary precision numbers.

Reference data types (objects, arrays, strings) are stored on heap memory; the reference variable itself is stored on stack.

equals() should be overridden when comparing object content; default Object.equals() only compares references, not field values.

Abstract class can have constructors and both abstract/concrete methods; abstract method is unimplemented in abstract class; interface has no constructor and all methods were abstract (now can have default/static methods in Java 8+).

Dynamic polymorphism is runtime method resolution based on actual object type not reference type; achieved through method overriding and inheritance.

Constructor overloading allows multiple constructors with different parameter lists to provide flexible object initialization options.

Immutability provides thread-safety, enables safe caching, allows use as HashMap keys, and prevents unintended state changes in multi-threaded environments.

JVM is the virtual machine executing bytecode; JDK includes JVM, compiler (javac), and development tools; JRE includes JVM and libraries only.

Override equals() only when you need custom comparison logic; default Object.equals() (reference equality) is sufficient for many classes.

Java bytecode runs on any JVM-installed platform without recompilation; 'Write Once Run Anywhere' principle achieved through JVM abstraction layer.

Java objects are incomplete by design allowing subclasses to extend behavior; abstract classes force subclasses to implement specific contracts.

Wrapper classes (Integer, Double, Boolean) wrap primitive types as objects enabling use in collections, null values, and method parameters requiring objects.

Boxing automatically wraps primitives in wrapper objects (Integer, Double, etc.), while unboxing extracts the primitive value; both happen implicitly in Java 5+ and can cause NullPointerException if unboxing null.

Methods perform actions and can be overridden; constructors initialize objects, cannot be overridden (only overloaded), and are called once at instantiation.

Methods can be overridden in subclasses to provide specific behavior; constructors cannot be overridden but can be overloaded with different parameters.

Heterogeneous types refer to collections storing different object types (e.g., List<Object>), relying on polymorphism and requiring explicit casting to access specific type methods.

Store passwords as char[] instead of String to allow secure zeroing after use; always hash with bcrypt/PBKDF2/Argon2 before storage, never encrypt alone.

Enums are ideal for fixed sets of constants like HTTP methods, status codes, or state machines where you need type-safety and prevent invalid values.

Most commonly used: toString(), equals(), hashCode(), getClass(), clone(); understanding their contracts is essential for proper object behavior.

Yes, always override equals() when implementing value-based equality; otherwise, default reference equality may not match your business logic requirements.

Strings are stored in the String pool (heap memory) for immutable, interned literals; duplicate strings reference the same object, saving memory.

String concatenation with '+' creates new String objects for each operation, causing memory inefficiency in loops; use StringBuilder for multiple concatenations.

Append method (StringBuilder/StringBuffer) efficiently adds to the string buffer without creating intermediate objects, solving concatenation performance issues.

Exception is checked (compiler-enforced), recoverable, extends Throwable; Error is unchecked, unrecoverable, indicates JVM problems like OutOfMemoryError.

StackOverflowError occurs from infinite recursion, OutOfMemoryError from heap exhaustion, NoClassDefFoundError when JVM cannot load a required class at runtime.

Checked exceptions force verbose try-catch blocks, reduce code readability, and mix error handling with business logic; many prefer unchecked exceptions for better design.

No, checked exceptions should remain; they enforce contract clarity and prevent silent failures, though they should be used judiciously for truly recoverable errors.

Use checked exceptions for recoverable conditions: IOException for file operations, SQLException for database failures, InterruptedException for threading operations.

Yes, implement Iterable interface and provide an Iterator implementation; enables enhanced for-loop: for(MyType item : myObject) by implementing iterator() method.

clone() is most useful as it provides shallow copying; equals() and hashCode() are critical for collections; toString() aids debugging.

Package-private (default access) restricts visibility to the same package, preventing external dependencies and allowing safer internal API refactoring within the package.

Package-private enforces encapsulation by hiding implementation details from outside packages; it creates clear module boundaries and allows package-level access control without public/private extremes.

Builder pattern. StringBuilder and StringBuffer use the Builder pattern to construct strings efficiently through method chaining.

Yes, arrays can be attached to streams using Arrays.stream() which returns a Stream interface for array elements.

The toString() method is commonly considered powerful as it provides string representation, but if referring to Streams, forEach() or collect() are essential.

TargetMethod appears to be a non-standard term; if referring to reflection, Method class allows invoking target methods dynamically via invoke().

Optional is a container for null-safe value handling; it wraps potentially null values and provides functional methods like map(), filter(), orElse() to avoid NullPointerException.

No, not always. You can write executable code in interfaces (with static/default methods) or enums, but classes are the primary construct for most OOP code.

OOP's three core principles: encapsulation (data hiding), inheritance (code reuse), polymorphism (method overriding/interface implementation).

Polymorphism applies in method overriding (runtime), method overloading (compile-time), and through interfaces/abstract classes where different implementations handle the same contract differently.

Primitive types documentation is found in the Java Language Specification and Java.lang.reflect; includes byte, short, int, long, float, double, boolean, char with their size and range specs.

Reference types are objects pointing to memory addresses: classes, interfaces, arrays, and enums,passed by reference, not by value like primitives.

The Object class is the root superclass of all Java classes; every class implicitly extends it.

Object classes are inherited implicitly; all classes automatically extend Object even without explicit declaration.

Equivalence is determined by the equals() method, which by default uses reference equality (==) but can be overridden to compare object state.

State refers to the current values of an object's fields/properties at any given point in time.

StringBuilder is mutable and faster for multiple concatenations; string concatenation with + creates new String objects each time, causing memory overhead and poor performance.

Public fields expose implementation details, violate encapsulation, prevent validation control, and make refactoring dangerous if accessed externally.

Static typing in Java means variable types are checked at compile-time; type must be declared and respected, preventing type-related runtime errors.

String is immutable, stored in String Pool for memory efficiency, implements Comparable, and thread-safe; created via literals or new String().

equals() compares object content/state; default implementation checks reference equality (==), but overriding allows semantic equality comparison.

Immutable means an object's state cannot be changed after creation; examples include String, Integer, LocalDate,ensures thread-safety and can be safely shared.

Strict typing expresses itself through compile-time type checking, no implicit type conversions between incompatible types, and generic type safety preventing ClassCastException at runtime.

Heap stores objects and arrays (dynamically allocated, garbage collected); Stack stores primitives and method references (LIFO, automatically freed).

StackOverflow is a Q&A platform; in Java context, it refers to a runtime error when the call stack exceeds its memory limit, typically from infinite recursion.

Interfaces are verified at compile-time through type checking; at runtime, instanceof checks and reflection can confirm if a class implements an interface.

All exceptions inherit from Throwable; checked exceptions extend Exception (must be caught/declared), unchecked extend RuntimeException (optional handling).

Use try-catch blocks to catch exceptions, finally block for cleanup, or throws keyword to propagate; Java 7+ try-with-resources auto-closes resources.

Throw exceptions using 'throw new ExceptionType(message)' for checked exceptions in method body; must declare in method signature or handle with try-catch.

Strings are stored as char arrays in the String object; internally uses a value field containing the character sequence.

String pool is part of the Heap memory (permgen in Java 8-, metaspace in Java 9+); it's not a separate memory region.

AutoCloseable interface with close() method; try-with-resources automatically calls close() on resources, ensuring cleanup even on exceptions.

Generics provide compile-time type safety and eliminate casting; enable writing reusable code with type parameters (e.g., List<String>).

Recent Java versions include records (Java 14+), sealed classes (Java 15+), pattern matching (Java 16+), and virtual threads (Java 21+).

Override equals() by checking type, comparing field values using == or equals(); must maintain consistency with hashCode().

String is immutable, fixed-length, slower for concatenation; StringBuilder is mutable, faster for multiple concatenations, not thread-safe.

equals() contract: reflexive (x.equals(x)=true), symmetric, transitive; hashCode() must return same value for equal objects (allows consistent HashSet/HashMap use).

String is immutable, thread-safe, stored in string pool for optimization, and has built-in methods for manipulation like substring, concat, and equals.

A static class cannot be instantiated and all its members are static; in Java, only nested classes can be static, used for grouping related utility methods.

Deep copying creates a complete independent copy of an object including all nested objects, unlike shallow copy which only copies references to inner objects.

Reflection allows runtime introspection and manipulation of classes, methods, fields, and constructors, enabling dynamic instantiation, method invocation, and annotation processing.

JRE is the Java Runtime Environment containing JVM, class libraries, and tools needed to execute Java applications without compilation.

Terminal operations in streams include collect(), forEach(), reduce(), count(), anyMatch(), allMatch(), and findFirst() which produce final results or side effects.

OutOfMemoryException is resolved through garbage collection tuning, heap size configuration (-Xmx), memory leak detection, and object pooling strategies.

A constructor is a special method with the same name as the class used for object initialization; it can be overloaded and doesn't have a return type.

Assert validates assumptions during development; throws AssertionError if condition fails; disabled by default in production (-ea flag enables).

Access external class fields from inner classes through the outer class reference (OuterClass.this.field) or via public/protected accessors; private fields require getter methods.

Local classes are classes defined within method scope, non-instantiable outside that method, cannot be static, and can access final/effectively final local variables.

If finalize() takes excessive time or throws exceptions, garbage collection blocks,the thread hangs and other finalizers queue up, potentially causing memory issues or application freeze.

Anonymous classes are unnamed inner classes defined inline at instantiation; used for one-time implementations of interfaces/abstract classes in event handlers, callbacks, and functional programming.

Static nested classes don't hold outer instance reference, are true members accessible via OuterClass.InnerClass, and behave like regular classes; non-static inner classes hold implicit outer reference and access instance members.

Nested classes encapsulate related functionality, improve code organization, and provide access control; used for factory patterns, utility classes, and event handlers within a logical scope.

Java has nested classes (static, non-static), inner classes, anonymous classes, and local classes; top-level classes can only be public, package-private, or implicitly package-private.

Static fields initialize in static blocks or at class loading time; instance fields initialize in constructors, instance initializers, or at declaration; both executed in definition order.

Instance members belong to each object and accessed via 'this'; static members belong to the class itself, shared across all instances, accessed via class name.

No, a method cannot be both abstract and static,abstract requires overriding in subclasses but static prevents overriding (bound at compile time), creating a logical contradiction.

Access overridden parent methods using super.methodName() to call the parent class implementation.

Yes, you can narrow the return type in an overridden method (covariant return types); for example, a subclass method can return a subtype of the parent's return type.

No, static methods cannot be overloaded by non-static methods; overloading requires same signature, and static/non-static differ in binding mechanism (not true overloading but shadowing).

ExceptionInInitializerError is thrown when an error occurs in a static initializer block or field initialization; it wraps the underlying exception (e.g., NullPointerException).

Inner classes without names, defined inline at point of use; used for event listeners, callbacks, simple strategy implementations.

GC pauses while finalize() executes; long-running or exception-throwing finalize() delays garbage collection and degrades performance.

Assert validates assumptions during development and testing (assert condition : message); disabled in production with -ea flag.

Use getter/setter methods, package-private access, or reflection; outer class members accessible directly from inner class.

Local class defined inside method/block, scoped to that block only, can access final/effectively final variables, cannot be static or public.

Static nested class: no implicit outer reference, can access outer static members only. Inner class: holds implicit reference, accesses all outer members; inner preferred for logical grouping.

Inner classes used for logical grouping, event handlers, callbacks; anonymous classes for one-time implementations.

Concrete, abstract, final, static, inner, anonymous, local classes; organized by scope and instantiation rules.

Static fields: class definition, static blocks. Non-static fields: instance creation, constructors, instance initializers.

Instance member: separate copy per object, accessed via instance. Static member: shared across all instances, accessed via class name.

No, method cannot be both abstract and static; abstract requires overriding in subclass, static cannot be overridden.

Call parent method using super keyword: super.methodName() inside child class, allowing access to overridden parent implementation.

No, you cannot override access level or return type if original method is private; private methods are not inherited so overriding concept doesn't apply,it's method shadowing instead.

No, non-static methods cannot overload static methods; static methods are resolved at compile-time by class reference while instance methods are resolved at runtime by object reference,different resolution strategies prevent overloading.

ExceptionInInitializerError is thrown when an exception occurs in static initialization block or class variable initialization; it wraps the actual exception as cause.

If exception is thrown in constructor, object creation fails and instance is never created; the exception propagates to caller, and object reference remains uninitialized.

Static initialization blocks execute once when class is loaded, used for complex static variable initialization, logging setup, or resource initialization that cannot be done inline.

Singleton (default instance per container), Prototype (new instance per request), Request (per HTTP request), Session (per user session), and Application (per ServletContext) are main scope designs using static modifier.

Initialization order: parent static blocks → child static blocks → parent instance blocks → parent constructor → child instance blocks → child constructor. Each level completes before the next begins.

Yes, via inner classes,a private inner class can be accessed by outer class and sibling inner classes; also through reflection using setAccessible(true) on private members.

Interface has highest abstraction level, followed by abstract class, then concrete class; interfaces define contracts only, abstract classes provide partial implementation.

Interface methods cannot be final because interfaces define contracts that implementations must override; final would prevent method overriding, violating interface semantics.

Marker interfaces (like Serializable, Cloneable) contain no methods to tag classes with metadata or signal capabilities to the JVM without requiring implementations.

Use abstract classes for shared code and state between related classes; use interfaces for defining contracts across unrelated classes or multiple inheritance scenarios.

Interface fields are implicitly public static final; interface methods are implicitly public abstract (pre-Java 8; Java 8+ allows default/static methods).

Abstract modifier is used on classes (can't instantiate, defines contracts) and methods (no implementation, must override), forcing subclasses to provide concrete implementations.

Use abstract classes for shared state/code with access control, constructors, and non-public members; use interfaces for pure contracts and multiple inheritance of type.

Interface methods default to public abstract (pre-Java 8) or public (with body in Java 8+); interface fields default to public static final.

ABSTRACT modifier declares a class/method that cannot be instantiated/invoked directly; abstract classes provide partial implementations, abstract methods force subclasses to override them.

Atomic operations are indivisible, uninterruptible actions; examples: volatile reads/writes, compare-and-swap (CAS), atomic variable operations (AtomicInteger, AtomicReference).

Ternary operator syntax is condition ? valueIfTrue : valueIfFalse; returns one of two values based on a boolean condition, providing concise inline conditional assignment.

Logical operators: && (AND, short-circuit), || (OR, short-circuit), ! (NOT); bitwise operators: & (AND), | (OR), ^ (XOR), ~ (NOT) operate on bit level.

Main() is the static entry point JVM invokes to start the application; it accepts String[] args for command-line arguments and must be public static void.

Primitive types initialize to 0/0.0/false (int, long, float, double, boolean); object references initialize to null; local variables have no default and must be explicitly initialized.

Exceptions are objects representing error conditions that disrupt program flow; they're organized in a hierarchy with checked exceptions (must be caught/declared) and unchecked exceptions (RuntimeException subclasses) that don't require explicit handling.

Cloning creates shallow or deep copies of objects using clone() method or copy constructors; for arrays, use System.arraycopy() or clone(), and for 2D arrays, iterate through rows since clone() creates a shallow copy of the reference array.

Autoboxing is automatic conversion between primitive types and their wrapper classes (e.g., int to Integer); introduced in Java 5 to simplify code and allow primitives in generic collections.

An initialization block is a code block executed before constructors, with instance blocks running for each object creation and static blocks running once when the class loads; useful for complex object setup.

Anonymous classes are unnamed inner classes implementing interfaces or extending classes; used for quick single-use implementations like event listeners.

False; primitive types are stack-allocated but reference type variables (references) are on stack while objects are on heap.

Type casting: upcasting (subclass to superclass, safe, implicit) and downcasting (superclass to subclass, unsafe, requires explicit cast with runtime check).

ClassCastException is thrown when explicitly casting an object to an incompatible type that isn't assignable; for example, casting a String to Integer or a parent class reference to an unrelated child class.

Literals are fixed values written directly in code; they include numeric (42, 3.14), string ("hello"), boolean (true), character ('a'), and null literals.

String is final and immutable for security (password/token safety), performance (hash caching), and thread-safety; it allows String interning and safe sharing across threads without synchronization.

Char[] is preferable to String for passwords because String remains in memory as an immutable object and can be read from heap dumps; Char[] can be explicitly cleared (Arrays.fill) after use.

String is a popular HashMap key because it's immutable (hashCode never changes), thread-safe, and its hashCode is cached, making lookups O(1) with no unexpected collisions.

Yes, since Java 7+ you can use Strings in switch statements; the compiler converts them to hashCode comparisons, making it efficient and cleaner than if-else chains.

clone() is in Object class not Cloneable because Cloneable is a marker interface with no methods; clone() requires deep knowledge of the object's state, so Object provides the default shallow copy implementation.

A default constructor is a no-argument constructor provided by the compiler if you don't define any constructor; it initializes fields to default values (null for objects, 0 for primitives).

Default constructor initializes fields to defaults; copy constructor takes an instance and copies its fields; parameterized constructor accepts specific values to initialize fields explicitly.

Private constructors prevent instantiation from outside; used in singleton pattern (private constructor + static getInstance()), utility classes (Math, Collections), and factory methods.

ClassLoaders load Java classes into memory; JVM uses three: Bootstrap (JDK classes), Extension (optional packages), and Application (user classes); dynamic loading uses Class.forName() or ClassLoader.loadClass().

Equals() must be reflexive (x.equals(x)==true), symmetric (x.equals(y)==y.equals(x)), transitive (x.equals(y) && y.equals(z) implies x.equals(z)), and consistent across calls.

Default hashCode() returns object identity hash; default equals() compares references; override both together,objects equal by equals() must return same hashCode().

Use immutable fields (final primitives, Strings, immutable objects) for hashCode() to ensure consistency; avoid mutable fields that change after object creation, and exclude fields used in equals().

The 'throw' operator explicitly throws an exception; syntax: throw new ExceptionType("message");

The 'throws' keyword declares that a method can throw checked exceptions, delegating handling to the caller; it's part of the method signature.

Create a custom exception by extending Exception (checked) or RuntimeException (unchecked); override constructors and optionally add custom fields/methods for additional context.

Unchecked exceptions (RuntimeException subclasses) don't require explicit catching/declaring; they occur at runtime (NullPointerException, IllegalArgumentException, ArithmeticException) and are often programming errors.

Error is a serious JVM problem (OutOfMemoryError, StackOverflowError) indicating the application shouldn't catch it; errors are unchecked and typically unrecoverable.

Yes, since Java 7 you can catch multiple exceptions in one block using pipe syntax: catch (IOException | SQLException e) { }; they're treated as a single variable of their common type.

Finally block executes in almost all cases, but won't complete if JVM terminates (System.exit(), fatal error), thread is killed, or an infinite loop occurs in try/catch.

Finally block fails to complete if System.exit() is called, JVM crashes, thread is forcibly terminated, or infinite loop occurs in try/catch block.

Yes, main() can throw checked exceptions by declaring throws clause; JVM catches it and prints stack trace to System.err, then terminates.

Internationalization (i18n) is designing applications to support multiple languages and regions without code changes, using ResourceBundles and locale-aware formatting.

Localization (l10n) is the process of translating and adapting an i18n-ready application to a specific language/region with translated resources.

SoftReference is released when memory is needed; WeakReference is released during garbage collection regardless of memory pressure; SoftReference retains data longer.

Use private final fields, initialize all fields in constructor, no setters, make class final, and return defensive copies or immutable objects from getters.

Intermediate operations are lazy-evaluated methods like filter(), map(), flatMap(), distinct(), sorted(), limit(), skip() that return Stream and enable chaining.

Servlet lifecycle: init() → service() (which calls doGet/doPost/etc.) → destroy(); container manages instantiation, processing requests, and cleanup.

Default methods are concrete implementations in interfaces introduced in Java 8, allowing interfaces to provide method bodies without breaking implementing classes.

instanceof checks if an object is an instance of a class or subclass; returns boolean; used before casting to avoid ClassCastException.

No, ArrayList add() is O(1) amortized but O(n) when capacity is exceeded and array resizing occurs; capacity grows by 50% when threshold is reached.

No, generics were introduced in Java 5; before that, collections used Object type without compile-time type safety.