Java 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();

Singleton (one instance application-wide), Prototype (new per injection), Request (per HTTP request), Session (per user session), Application (application scope).

A Bean in Spring is a managed object created and maintained by the Spring IoC container with lifecycle methods and dependency injection capabilities.

Collection → List (ArrayList, LinkedList), Set (HashSet, TreeSet), Queue; Map hierarchy separate (HashMap, TreeMap, ConcurrentHashMap).

Collection<Integer> col = Arrays.asList(1, 2, 3);
List<Integer> list = new ArrayList<>();
Set<Integer> set = new HashSet<>();
Map<String, Integer> map = new HashMap<>();

ArrayList uses dynamic array (fast random access, slow insertion/deletion), LinkedList uses doubly-linked nodes (slow access, fast insertion/deletion at ends).

ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
LinkedList<Integer> ll = new LinkedList<>();
ll.addFirst(1);
ll.addLast(2);

Deployment descriptor (web.xml) is an XML file that configures servlets, filters, listeners, security constraints, and other settings for a web application.

Container instantiates servlet (constructor), calls init(), then repeatedly calls service() for requests, and finally calls destroy() on shutdown.

Deadlock occurs when threads circularly wait for locks held by others; prevent via lock ordering, timeouts, tryLock(), or ReentrantReadWriteLock patterns.

Object lock1 = new Object();
Object lock2 = new Object();
new Thread(() -> {
  synchronized(lock1) {
    synchronized(lock2) {
    }
  }
}
).start();
new Thread(() -> {
  synchronized(lock2) {
    synchronized(lock1) {
    }
  }
}
).start();

ExecutorService is a thread pool that manages a pool of threads for executing submitted tasks asynchronously. It abstracts away thread creation and lifecycle management, providing methods like submit(), execute(), and shutdown().

ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(() -> System.out.println("Task 1"));
executor.submit(() -> System.out.println("Task 2"));
executor.shutdown();

Structure your answer: start with your current role and tech stack, mention 1-2 key accomplishments relevant to the position, then explain why you are interested in this role. Keep it under 2 minutes. Focus on Java-specific experience like frameworks you have used, systems you have built, and problems you have solved.

SOLID: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion principles for maintainable design.

ACID ensures reliable transactions: Atomicity (all-or-nothing), Consistency (valid state), Isolation (no interference), Durability (persistence after commit).

Database normalization organizes data into tables to reduce redundancy and dependency by applying rules like 1NF, 2NF, 3NF, ensuring data integrity and efficient queries.

Common patterns: Singleton, Factory, Strategy, Observer, Adapter, Decorator, Proxy, Builder, Template Method, and State.

class Singleton {
  private static Singleton instance = new Singleton();
  private Singleton() {
  }
  public static Singleton getInstance() {
    return instance;
  }
}
class Prototype implements Cloneable {
  public Object clone() throws CloneNotSupportedException {
    return super.clone();
  }
}

Singleton creates one instance (lazy or eager initialization, thread-safe), Prototype creates copies of existing objects; Singleton manages instance count, Prototype manages object cloning.

class Singleton {
  private static Singleton instance;
  public static synchronized Singleton getInstance() {
    if(instance == null) instance = new Singleton();
    return instance;
  }
}
Prototype p1 = new Prototype();
Prototype p2 = (Prototype) p1.clone();

Yes, proficient with SQL for queries, joins, subqueries, transactions, indexes, and optimization.

Yes, proficient with SQL for DML/DDL operations, optimization, and query design.

Stream provides lazy, functional pipeline for processing collections; chains operations (map, filter, reduce) without modifying source, enabling parallel processing.

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

Functional interface has exactly one abstract method, allowing lambda expression implementation; annotated with @FunctionalInterface (e.g., Comparator, Function).

@FunctionalInterface interface Calculator {
  int calculate(int a, int b);
}
Calculator add = (a, b) -> a + b;
System.out.println(add.calculate(5, 3));

Call connection.close() to release JDBC connection back to pool; use try-with-resources for automatic closure.

Use CallableStatement: CallableStatement cs = connection.prepareCall("{call procName(?, ?)}"); set parameters with setString(); execute with executeQuery(); retrieve results with getters.

XSLT transforms XML documents using template-based rules into other XML, HTML, or text formats.

JAXP is Java API for XML Processing: provides parsing (SAX/DOM), transformation (XSLT), and validation (XSD) through factory pattern abstraction.