Java Core Interview Guide: OOP to Concurrency

// Bad: Exposed internal state
public class BankAccount {
    public double balance;  // Anyone can set this to anything
}
 
// Good: Encapsulated state with controlled access
public class BankAccount {
    private double balance;
 
    public void deposit(double amount) {
        if (amount <= 0) throw new IllegalArgumentException("Amount must be positive");
        this.balance += amount;
    }
 
    public void withdraw(double amount) {
        if (amount > balance) throw new InsufficientFundsException();
        this.balance -= amount;
    }
 
    public double getBalance() {
        return balance;  // Read-only access
    }
}

public abstract class Animal {
    protected String name;
 
    public Animal(String name) {
        this.name = name;
    }
 
    public abstract void makeSound();  // Subclasses must implement
 
    public void sleep() {  // Shared implementation
        System.out.println(name + " is sleeping");
    }
}
 
public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
 
    @Override
    public void makeSound() {
        System.out.println(name + " barks");
    }
}

public void feedAnimals(List<Animal> animals) {
    for (Animal animal : animals) {
        animal.makeSound();  // Each animal's specific implementation runs
    }
}
 
// Runtime polymorphism - actual method determined at runtime
List<Animal> animals = List.of(new Dog("Rex"), new Cat("Whiskers"));
feedAnimals(animals);  // Rex barks, Whiskers meows

// The user of this interface doesn't need to know HOW payments work
public interface PaymentProcessor {
    PaymentResult process(Payment payment);
}
 
// Could be Stripe, PayPal, or a mock for testing
// The abstraction hides the implementation details

// Abstract class: Shared state and implementation
public abstract class DatabaseConnection {
    protected String connectionString;  // State
    protected int timeout;
 
    public DatabaseConnection(String connectionString) {
        this.connectionString = connectionString;
        this.timeout = 30;
    }
 
    public abstract void connect();  // Subclasses implement
    public abstract void disconnect();
 
    public void setTimeout(int seconds) {  // Shared implementation
        this.timeout = seconds;
    }
}
 
// Interface: Capability contract
public interface Cacheable {
    String getCacheKey();
    Duration getTtl();
 
    default boolean isExpired(Instant cachedAt) {  // Default implementation
        return Instant.now().isAfter(cachedAt.plus(getTtl()));
    }
}
 
// A class can extend one abstract class AND implement multiple interfaces
public class PostgresConnection extends DatabaseConnection implements Cacheable, AutoCloseable {
    // ...
}

// Bad: Multiple responsibilities
public class UserService {
    public void createUser(User user) { /* ... */ }
    public void sendWelcomeEmail(User user) { /* ... */ }  // Email is separate concern
    public String generateReport(List<User> users) { /* ... */ }  // Reporting is separate
}
 
// Good: Single responsibility
public class UserService {
    public void createUser(User user) { /* ... */ }
}
 
public class EmailService {
    public void sendWelcomeEmail(User user) { /* ... */ }
}
 
public class UserReportGenerator {
    public String generate(List<User> users) { /* ... */ }
}

// Bad: Must modify class to add new payment types
public class PaymentProcessor {
    public void process(Payment payment) {
        if (payment.getType().equals("CREDIT_CARD")) {
            // process credit card
        } else if (payment.getType().equals("PAYPAL")) {
            // process paypal
        }
        // Adding new type requires modifying this class
    }
}
 
// Good: Extend without modifying
public interface PaymentHandler {
    boolean supports(PaymentType type);
    void process(Payment payment);
}
 
public class PaymentProcessor {
    private List<PaymentHandler> handlers;
 
    public void process(Payment payment) {
        handlers.stream()
            .filter(h -> h.supports(payment.getType()))
            .findFirst()
            .orElseThrow()
            .process(payment);
    }
}
// New payment types = new handler classes, no modification to PaymentProcessor

// Violation: Square can't properly substitute Rectangle
public class Rectangle {
    protected int width, height;
 
    public void setWidth(int w) { width = w; }
    public void setHeight(int h) { height = h; }
    public int getArea() { return width * height; }
}
 
public class Square extends Rectangle {
    @Override
    public void setWidth(int w) {
        width = w;
        height = w;  // Breaks expectations!
    }
}
 
// Code expecting Rectangle behavior breaks with Square
Rectangle r = new Square();
r.setWidth(5);
r.setHeight(10);
assert r.getArea() == 50;  // Fails! Area is 100

// Bad: Fat interface
public interface Worker {
    void work();
    void eat();
    void sleep();
}
 
public class Robot implements Worker {
    public void work() { /* ... */ }
    public void eat() { /* Robots don't eat! */ }
    public void sleep() { /* Robots don't sleep! */ }
}
 
// Good: Segregated interfaces
public interface Workable { void work(); }
public interface Eatable { void eat(); }
public interface Sleepable { void sleep(); }
 
public class Robot implements Workable {
    public void work() { /* ... */ }
}

// Bad: High-level module depends on low-level module
public class OrderService {
    private MySqlOrderRepository repository = new MySqlOrderRepository();
}
 
// Good: Both depend on abstraction
public class OrderService {
    private final OrderRepository repository;  // Interface
 
    public OrderService(OrderRepository repository) {
        this.repository = repository;  // Injected
    }
}

ArrayList<String> list = new ArrayList<>();
 
// Internal: Object[] elementData
// When full, grows by 50% (newCapacity = oldCapacity + oldCapacity >> 1)
 
list.add("a");     // O(1) amortized - may trigger resize
list.get(0);       // O(1) - direct array access
list.remove(0);    // O(n) - shifts all subsequent elements
list.contains("a"); // O(n) - linear search

LinkedList<String> list = new LinkedList<>();
 
// Internal: Node with prev, next, and element references
 
list.addFirst("a");  // O(1)
list.addLast("b");   // O(1)
list.get(50);        // O(n) - must traverse nodes
list.remove(node);   // O(1) if you have the node reference

HashSet<String> set = new HashSet<>();
 
// Internal: HashMap<E, PRESENT> where PRESENT is a dummy object
 
set.add("a");       // O(1) average
set.contains("a");  // O(1) average
set.remove("a");    // O(1) average
 
// Order is NOT guaranteed
set.add("c"); set.add("a"); set.add("b");
// Iteration order might be: b, c, a (based on hash codes)

LinkedHashSet<String> set = new LinkedHashSet<>();
set.add("c"); set.add("a"); set.add("b");
// Iteration order: c, a, b (insertion order)

TreeSet<String> set = new TreeSet<>();
set.add("c"); set.add("a"); set.add("b");
// Iteration order: a, b, c (natural ordering)
 
set.add("a");       // O(log n) - tree insertion
set.contains("a");  // O(log n) - tree search
set.first();        // O(log n) - smallest element
set.headSet("b");   // O(log n) - elements less than "b"

HashMap<String, Integer> map = new HashMap<>();
 
// Internal structure:
// - Array of Node<K,V>[] buckets (default 16)
// - Each bucket: linked list or tree (if > 8 entries)
// - Load factor: 0.75 (resize when 75% full)

// Hash collision example
class BadKey {
    @Override
    public int hashCode() { return 1; }  // All keys go to same bucket!
}
// With proper hashCode(): O(1) average
// With constant hashCode(): O(n) - degrades to linked list traversal

class Person {
    String name;
    int age;
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(name, age);  // Must use same fields as equals()
    }
}

TreeMap<String, Integer> map = new TreeMap<>();
map.put("c", 3);
map.put("a", 1);
map.put("b", 2);
 
map.keySet();        // [a, b, c] - sorted
map.firstKey();      // "a"
map.lastKey();       // "c"
map.floorKey("bb");  // "b" - greatest key <= "bb"
map.ceilingKey("bb"); // "c" - smallest key >= "bb"
 
// All operations: O(log n)

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
 
// Thread-safe operations
map.put("key", 1);
map.computeIfAbsent("key", k -> expensiveComputation(k));
map.merge("key", 1, Integer::sum);  // Atomic increment
 
// Iteration is weakly consistent - may not reflect concurrent updates

// Generic class
public class Box<T> {
    private T content;
 
    public void set(T content) { this.content = content; }
    public T get() { return content; }
}
 
Box<String> stringBox = new Box<>();
stringBox.set("hello");
String s = stringBox.get();  // No cast needed
 
// Generic method
public <T> T firstOrNull(List<T> list) {
    return list.isEmpty() ? null : list.get(0);
}

// Upper bound: T must be Number or subclass
public <T extends Number> double sum(List<T> numbers) {
    return numbers.stream()
        .mapToDouble(Number::doubleValue)
        .sum();
}
 
sum(List.of(1, 2, 3));        // Works: Integer extends Number
sum(List.of(1.5, 2.5));       // Works: Double extends Number
sum(List.of("a", "b"));       // Compile error: String doesn't extend Number
 
// Multiple bounds: T must be both Comparable AND Serializable
public <T extends Comparable<T> & Serializable> T max(T a, T b) {
    return a.compareTo(b) > 0 ? a : b;
}

// Upper bounded wildcard: ? extends T (producer - read from)
public double sumAll(List<? extends Number> numbers) {
    // Can read as Number
    double sum = 0;
    for (Number n : numbers) {
        sum += n.doubleValue();
    }
    // Can NOT add (except null) - don't know exact type
    // numbers.add(1);  // Compile error
    return sum;
}
 
// Lower bounded wildcard: ? super T (consumer - write to)
public void addNumbers(List<? super Integer> list) {
    // Can add Integer (and subclasses)
    list.add(1);
    list.add(2);
    // Can only read as Object
    Object obj = list.get(0);
    // Integer i = list.get(0);  // Compile error
}
 
// Unbounded wildcard: ? (read-only, type doesn't matter)
public void printAll(List<?> list) {
    for (Object item : list) {
        System.out.println(item);
    }
}

List<String> strings = new ArrayList<>();
List<Integer> integers = new ArrayList<>();
 
// At runtime, both are just ArrayList
strings.getClass() == integers.getClass();  // true
 
// This is why you can't do:
// if (obj instanceof List<String>)  // Compile error
// new T[]  // Compile error

List<Person> people = getPeople();
 
// Stream pipeline: source -> intermediate ops -> terminal op
List<String> adultNames = people.stream()         // Source
    .filter(p -> p.getAge() >= 18)                // Intermediate
    .map(Person::getName)                          // Intermediate
    .sorted()                                      // Intermediate
    .distinct()                                    // Intermediate
    .collect(Collectors.toList());                // Terminal
 
// Intermediate operations are lazy - nothing happens until terminal op

stream.filter(predicate)      // Keep elements matching predicate
stream.map(function)          // Transform elements
stream.flatMap(function)      // Transform to stream, then flatten
stream.sorted()               // Natural order
stream.sorted(comparator)     // Custom order
stream.distinct()             // Remove duplicates (uses equals())
stream.limit(n)               // Take first n elements
stream.skip(n)                // Skip first n elements
stream.peek(consumer)         // Debug - perform action without modifying

stream.collect(collector)     // Accumulate into collection
stream.forEach(consumer)      // Perform action on each
stream.reduce(identity, op)   // Combine all elements
stream.count()                // Count elements
stream.anyMatch(predicate)    // True if any match
stream.allMatch(predicate)    // True if all match
stream.noneMatch(predicate)   // True if none match
stream.findFirst()            // First element (Optional)
stream.findAny()              // Any element (Optional) - better for parallel

// To List
List<String> list = stream.collect(Collectors.toList());
 
// To Set
Set<String> set = stream.collect(Collectors.toSet());
 
// To Map
Map<Long, Person> byId = people.stream()
    .collect(Collectors.toMap(Person::getId, p -> p));
 
// Grouping
Map<Department, List<Person>> byDept = people.stream()
    .collect(Collectors.groupingBy(Person::getDepartment));
 
// Grouping with downstream collector
Map<Department, Long> countByDept = people.stream()
    .collect(Collectors.groupingBy(
        Person::getDepartment,
        Collectors.counting()
    ));
 
// Partitioning (special case of grouping with boolean)
Map<Boolean, List<Person>> adultsAndMinors = people.stream()
    .collect(Collectors.partitioningBy(p -> p.getAge() >= 18));
 
// Joining strings
String names = people.stream()
    .map(Person::getName)
    .collect(Collectors.joining(", "));  // "Alice, Bob, Charlie"
 
// Statistics
IntSummaryStatistics stats = people.stream()
    .collect(Collectors.summarizingInt(Person::getAge));
stats.getAverage();  // Average age
stats.getMax();      // Max age
stats.getCount();    // Count

Optional<Person> maybePerson = repository.findById(id);
 
// Bad: Defeats the purpose
if (maybePerson.isPresent()) {
    Person p = maybePerson.get();
}
 
// Good: Functional style
String name = maybePerson
    .map(Person::getName)
    .orElse("Unknown");
 
// Chain operations safely
String city = maybePerson
    .map(Person::getAddress)
    .map(Address::getCity)
    .orElseThrow(() -> new NotFoundException("Person not found"));
 
// Conditional action
maybePerson.ifPresent(p -> sendEmail(p));
 
// With alternative
Person person = maybePerson
    .orElseGet(() -> createDefaultPerson());  // Lazy evaluation

// Creating threads (basic - rarely used directly)
Thread t1 = new Thread(() -> {
    System.out.println("Running in: " + Thread.currentThread().getName());
});
t1.start();  // Don't call run() - that runs in current thread!
 
// Thread states
// NEW -> RUNNABLE -> (BLOCKED/WAITING/TIMED_WAITING) -> TERMINATED

public class Counter {
    private int count = 0;
 
    public void increment() {
        count++;  // NOT atomic! Read-modify-write
    }
}
 
// With multiple threads:
Counter counter = new Counter();
// Thread 1: reads count (0), increments, writes (1)
// Thread 2: reads count (0), increments, writes (1)
// Expected: 2, Actual: 1 - lost update!

// synchronized method
public class Counter {
    private int count = 0;
 
    public synchronized void increment() {
        count++;  // Only one thread at a time
    }
 
    public synchronized int getCount() {
        return count;
    }
}
 
// synchronized block (more granular)
public class BankAccount {
    private final Object lock = new Object();
    private double balance;
 
    public void transfer(BankAccount target, double amount) {
        synchronized (lock) {
            if (balance >= amount) {
                balance -= amount;
                target.deposit(amount);
            }
        }
    }
}

// Deadlock scenario
// Thread 1: locks A, waits for B
// Thread 2: locks B, waits for A
 
public void transfer(Account from, Account to, double amount) {
    synchronized (from) {
        synchronized (to) {
            // If another thread calls transfer(to, from, x) simultaneously...
            // DEADLOCK!
        }
    }
}
 
// Prevention: Always acquire locks in consistent order
public void transfer(Account from, Account to, double amount) {
    Account first = from.getId() < to.getId() ? from : to;
    Account second = from.getId() < to.getId() ? to : from;
 
    synchronized (first) {
        synchronized (second) {
            // Safe - consistent ordering
        }
    }
}

private AtomicInteger count = new AtomicInteger(0);
 
count.incrementAndGet();    // Atomic increment, returns new value
count.getAndIncrement();    // Atomic increment, returns old value
count.compareAndSet(5, 10); // Set to 10 only if currently 5
 
// AtomicReference for objects
AtomicReference<User> currentUser = new AtomicReference<>();
currentUser.compareAndSet(oldUser, newUser);

// Fixed thread pool
ExecutorService executor = Executors.newFixedThreadPool(4);
 
// Submit tasks
Future<String> future = executor.submit(() -> {
    return computeResult();
});
 
// Get result (blocks until complete)
String result = future.get();  // Can throw ExecutionException
 
// Shutdown properly
executor.shutdown();  // Stops accepting new tasks
executor.awaitTermination(60, TimeUnit.SECONDS);  // Wait for completion

CompletableFuture<User> userFuture = CompletableFuture
    .supplyAsync(() -> userService.findById(id))
    .thenApply(user -> enrichWithProfile(user))
    .thenApply(user -> enrichWithPreferences(user));
 
// Combine multiple futures
CompletableFuture<String> nameFuture = getNameAsync();
CompletableFuture<Integer> ageFuture = getAgeAsync();
 
CompletableFuture<String> combined = nameFuture
    .thenCombine(ageFuture, (name, age) -> name + " is " + age);
 
// Handle errors
CompletableFuture<User> withFallback = userFuture
    .exceptionally(ex -> {
        log.error("Failed to fetch user", ex);
        return defaultUser;
    });
 
// Wait for all
CompletableFuture.allOf(future1, future2, future3).join();
 
// Wait for any (first to complete)
CompletableFuture.anyOf(future1, future2, future3);

// ConcurrentHashMap - thread-safe map
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.computeIfAbsent("key", k -> expensiveComputation(k));  // Atomic
 
// CopyOnWriteArrayList - for read-heavy, write-light scenarios
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
// Writes create a new copy - expensive
// Reads never block - great for iteration during concurrent modification
 
// BlockingQueue - producer-consumer pattern
BlockingQueue<Task> queue = new LinkedBlockingQueue<>(100);
queue.put(task);     // Blocks if full
queue.take();        // Blocks if empty

public void process() {
    User user = new User();  // Reachable via stack
    user = null;             // Now unreachable - eligible for GC
}  // user goes out of scope - also makes object unreachable

// Classic leak: static collection that grows forever
public class Cache {
    private static Map<String, Object> cache = new HashMap<>();
 
    public static void put(String key, Object value) {
        cache.put(key, value);  // Never removed!
    }
}
 
// Listener leak: registered but never unregistered
button.addActionListener(listener);
// If button lives longer than expected, listener is retained
 
// Inner class leak: holds reference to outer class
public class Outer {
    private byte[] largeData = new byte[10_000_000];
 
    public Runnable getTask() {
        return new Runnable() {  // Anonymous inner class holds Outer.this
            public void run() {
                // Even if this doesn't use largeData,
                // it keeps Outer (and largeData) alive
            }
        };
    }
}
 
// Fix: use static nested class or lambda (if it doesn't capture 'this')
public Runnable getTask() {
    return () -> System.out.println("No reference to Outer");
}

# Heap size
-Xms512m        # Initial heap
-Xmx2g          # Maximum heap
 
# GC selection
-XX:+UseG1GC           # G1 (default in modern Java)
-XX:+UseZGC            # ZGC (low latency)
 
# GC logging
-Xlog:gc*:file=gc.log  # GC logs for analysis
 
# Memory analysis
-XX:+HeapDumpOnOutOfMemoryError  # Dump heap on OOM
-XX:HeapDumpPath=/tmp/heapdump.hprof

// Old way
public class Point {
    private final int x;
    private final int y;
 
    public Point(int x, int y) { this.x = x; this.y = y; }
    public int x() { return x; }
    public int y() { return y; }
    public boolean equals(Object o) { /* ... */ }
    public int hashCode() { /* ... */ }
    public String toString() { /* ... */ }
}
 
// Record
public record Point(int x, int y) { }
// Automatically generates: constructor, accessors, equals, hashCode, toString
// Records are final and immutable

public sealed class Shape permits Circle, Rectangle, Triangle {
    // Only Circle, Rectangle, Triangle can extend Shape
}
 
public final class Circle extends Shape { }  // Must be final, sealed, or non-sealed
public final class Rectangle extends Shape { }
public non-sealed class Triangle extends Shape { }  // Opens hierarchy

// Old
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}
 
// New
if (obj instanceof String s) {
    System.out.println(s.length());  // s already cast and in scope
}

// Pattern matching in switch
String describe(Object obj) {
    return switch (obj) {
        case Integer i -> "Integer: " + i;
        case String s -> "String of length " + s.length();
        case null -> "null";
        default -> "Unknown";
    };
}
 
// With sealed classes - exhaustive, no default needed
double area(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Rectangle r -> r.width() * r.height();
        case Triangle t -> 0.5 * t.base() * t.height();
    };
}

// Platform thread (OS thread) - expensive
Thread platformThread = new Thread(() -> blockingOperation());
 
// Virtual thread - cheap, millions possible
Thread virtualThread = Thread.ofVirtual().start(() -> blockingOperation());
 
// With ExecutorService
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 100_000).forEach(i -> {
        executor.submit(() -> {
            // Each task gets its own virtual thread
            // Blocking operations don't waste OS threads
            return fetchFromDatabase(i);
        });
    });
}