OOPs (Design-Focused)

Encapsulation, abstraction, inheritance and polymorphism. Java realises them through access modifiers, interfaces/abstract classes, extends/implements, and virtual method dispatch.

• Encapsulation: private state plus controlled methods so invariants are enforced in one place.
• Abstraction: expose what an object does, hide how (interfaces, abstract classes).
• Inheritance: reuse and specialise via extends (single class inheritance only).
• Polymorphism: compile-time (overloading) and runtime (overriding, decided by the object's actual class).

Abstraction is a design-level decision about what to show (the contract); encapsulation is the implementation mechanism of hiding state and enforcing invariants behind that contract.

• A PaymentGateway interface is abstraction; its private HTTP client and retry state are encapsulation.

Use an interface to define a capability or contract that unrelated classes can implement; use an abstract class when subclasses share state, constructors or a partially implemented template.

default (Java 8) gives an inheritable implementation so interfaces can evolve without breaking implementors; static (Java 8) holds utility methods called via the interface name; private (Java 9) holds shared code for default/static methods.

interface Validator<T> {
    boolean validate(T t);
    default Validator<T> and(Validator<T> o) { return x -> validate(x) && o.validate(x); }
    static <T> Validator<T> notNull() { return x -> x != null; }
    private void log(String m) { System.out.println(m); }
}

Rules in order: a class method (own or inherited) wins over any interface default; a more specific interface wins over a less specific one; otherwise the class must override and may choose with A.super.m().

interface A { default String hi() { return "A"; } }
interface B { default String hi() { return "B"; } }
class C implements A, B {
    public String hi() { return A.super.hi() + B.super.hi(); }
}

To avoid ambiguity over inherited state and method implementations (the diamond problem) and to keep construction and layout simple. Multiple inheritance of type is allowed through interfaces; of behaviour through defaults with explicit conflict resolution.

sealed (final in Java 17) restricts which classes may extend or implement a type through permits. It gives a closed hierarchy that the compiler knows, enabling exhaustive switch without default.

sealed interface Payment permits Card, Upi, Wallet {}
record Card(String last4) implements Payment {}
record Upi(String vpa) implements Payment {}
final class Wallet implements Payment {}

• Each permitted subtype must be final, sealed or non-sealed.

A record is a transparent, shallowly immutable data carrier. The compiler generates a canonical constructor, private final fields, accessors (name(), not getName()), and equals, hashCode, toString.

record Money(long cents, String currency) {
    Money {  // compact constructor
        if (cents < 0) throw new IllegalArgumentException();
    }
}

Good for DTOs, API request/response models, value objects, projections and map keys. Poor for JPA entities (need a no-arg constructor, mutable state, proxies) and for types with identity-based equality or lifecycle.

Same name and parameter types; return type same or covariant; access not narrower; no broader checked exceptions; cannot override private, static or final methods. Use @Override so the compiler checks it.

A static method in a subclass with the same signature hides the parent's. Resolution is by the declared (compile-time) type, not the runtime object. Fields are also hidden, never overridden.

At compile time the compiler picks by the static argument types in three phases: exact/widening primitive and subtyping, then boxing/unboxing, then varargs. The most specific applicable method wins.

An overriding method may return a subtype of the parent's return type. The compiler adds a synthetic bridge method with the original signature that delegates to the new one.

class Animal { Animal self() { return this; } }
class Dog extends Animal { @Override Dog self() { return this; } }

this(...) calls another constructor of the same class; super(...) calls a parent constructor. Either must be the first statement (before Java 22 preview relaxations), and if neither is written the compiler inserts super().

Class loading (first use): parent static init, then child static init. Per new: parent instance initialisers and field initialisers (textual order), parent constructor body, then child field initialisers and instance blocks, then child constructor body.

equals must be reflexive, symmetric, transitive, consistent and x.equals(null) is false. If a.equals(b) then a.hashCode() == b.hashCode(). Unequal objects may share a hash code, but collisions hurt performance.

getClass() comparison preserves symmetry across subclasses but violates Liskov (a subclass instance never equals a parent). instanceof allows substitutability but breaks symmetry or transitivity once subclasses add state. Safest: make the class final or use composition.

No. If a key's hash changes after insertion into a HashMap/HashSet, the entry sits in the wrong bucket and becomes unreachable via get/contains/remove.

Make the class final (or constructors private), all fields private final, no setters, defensively copy mutable inputs in the constructor and outputs in getters, and don't leak this during construction.

public final class Order {
    private final List<String> items;
    public Order(List<String> items) { this.items = List.copyOf(items); }
    public List<String> items() { return items; }
}

Thread safety without locks, safe sharing and caching, safe use as map keys, simpler reasoning and failure atomicity. Cost: object allocation per change; mitigate with builders or withX copies.

Prefer composition ("has-a") because inheritance couples a subclass to the parent's implementation (fragile base class) and exposes all inherited methods. Use inheritance only for true is-a relationships designed for extension.

• S: a UserService should not also send emails and render PDFs; split into collaborators.
• O: add a new discount rule by adding a DiscountStrategy bean, not by editing an if chain.
• L: a ReadOnlyRepository subclass that throws on save violates substitutability.
• I: split a fat OrderOperations interface so a reporting client doesn't depend on cancel().
• D: services depend on PaymentGateway interface, injected by Spring, not on StripeClient.

Subtypes must be usable wherever the parent is expected without breaking correctness. Violations: strengthening preconditions, weakening postconditions, throwing unexpected exceptions, or ignoring the contract (e.g. Square extends Rectangle with coupled setters).

Static nested (no outer instance), inner (non-static; holds an implicit outer reference), local (declared in a method), anonymous (unnamed, declared inline). Local and anonymous classes capture effectively final variables.

A non-static inner or anonymous class holds a hidden reference to its enclosing instance. If the inner object outlives the outer (stored in a cache, listener list, or thread), the outer and everything it references can't be collected. Prefer static nested classes or lambdas that don't capture this.

An anonymous class is a new class (own .class file) with its own this, can implement any interface or extend a class, and can have state. A lambda needs a functional interface, this refers to the enclosing instance, and it compiles via invokedynamic.

Enums are classes with a fixed set of singleton instances. They can have fields, constructors (implicitly private), methods, implement interfaces, and have constant-specific bodies. They provide values(), valueOf, ordinal(), name(), and work in switch, EnumMap, EnumSet.

enum Status {
    ACTIVE("A"), BLOCKED("B");
    private final String code;
    Status(String code) { this.code = code; }
    String code() { return code; }
}

The JVM guarantees one instance per constant, thread-safe initialisation, and the serialisation and reflection attacks that break class-based singletons are blocked (Enum serialises by name; reflective newInstance throws).

equals, hashCode, toString, getClass, clone (protected), finalize (deprecated for removal), wait (3 overloads), notify, notifyAll.

equals is reference identity (this == o); hashCode is an implementation-specific identity hash, typically derived from the object header, not the memory address as such.

Object.clone() is protected, requires implementing the marker interface Cloneable, does a shallow field copy without calling constructors, and throws a checked CloneNotSupportedException. Prefer copy constructors, static factories or records with withX methods.

Calling super.clone() throws CloneNotSupportedException at runtime, because Object.clone checks for the Cloneable marker.

Generics add compile-time type parameters to classes and methods, removing casts and catching type errors at compile time instead of ClassCastException at runtime.

The compiler removes type arguments after checking, replacing type variables with their bound (or Object) and inserting casts. Hence List<String> and List<Integer> are the same class at runtime.

• No new T(), new T[], instanceof List<String>, or generic static fields of type T.
• Overloads differing only in type arguments clash (m(List<String>) vs m(List<Integer>)).

Producer Extends, Consumer Super. List<? extends Number> can be read as Number but not added to (except null); List<? super Integer> can accept Integer but reads only yield Object.

static double sum(List<? extends Number> src) { double s = 0; for (Number n : src) s += n.doubleValue(); return s; }
static void fill(List<? super Integer> dst) { dst.add(42); }

Arrays are reified and checked at runtime (ArrayStoreException), so covariance is allowed historically. Generics are erased, so covariance would allow heap pollution with no runtime check; invariance keeps compile-time safety.

<T extends Comparable<T>> restricts T so you can call bound methods. Multiple bounds use & with the class first: <T extends Number & Comparable<T>>.

Heap pollution is when a variable of a parameterised type refers to an object that isn't of that type, typically via raw types or generic varargs (T... creates a T[] that erases to Object[]). @SafeVarargs asserts the method doesn't misuse the array; it is allowed on static, final, private methods and constructors.

In a named module, a public type is accessible outside only if its package is exportsed (and reflectively only if opens). This enables strong encapsulation of internals, which is why --add-opens is needed for old frameworks on Java 17.

final class cannot be extended; final method cannot be overridden; final variable cannot be reassigned (a final reference can still point to a mutable object).

Static members belong to the class (one copy, no this, no polymorphic dispatch); instance members belong to each object. Static methods can't be overridden or mocked easily, so heavy use hurts testability.

== compares references; equals compares logical equality as defined by the class. For enums == is correct and null-safe, as Enum.equals is final and identity-based.

toString gives a diagnostic representation used in logs and debuggers. In JPA entities, including lazy associations triggers extra queries or LazyInitializationException, and bidirectional relations cause infinite recursion. Also never include secrets.

compareTo must be antisymmetric, transitive and consistent; it is "consistent with equals" when compareTo == 0 iff equals is true. Inconsistency makes TreeSet treat distinct-by-equals items as duplicates.

Comparable defines a class's single natural order (compareTo); Comparator is an external, pluggable ordering (Comparator.comparing(...).thenComparing(...)), allowing multiple orders without modifying the class.

A final method in an abstract base defines the algorithm skeleton, calling abstract/hook methods that subclasses implement. Example: Spring's JdbcTemplate and AbstractRoutingDataSource; many are now callback/strategy based.

Both delegate to an interchangeable object. Strategy is chosen by the client and objects don't know each other (e.g. PricingStrategy). State is driven by the context's internal transitions and states usually trigger the next state (e.g. order lifecycle).

Objects receive collaborators from outside rather than constructing them, which supports DIP, loose coupling and test doubles. Prefer constructor injection: dependencies are explicit, can be final, and the object is never half-built.

if (o instanceof Circle c) tests and binds in one step, removing a manual cast. Binding scope is flow-sensitive. With sealed types and Java 21 pattern switch it replaces visitor-like code.

double area(Shape s) {
    return switch (s) {
        case Circle c -> Math.PI * c.r() * c.r();
        case Square q -> q.side() * q.side();
    };
}

An interface with no methods (Serializable, Cloneable, RandomAccess) that tags a type; it can be used as a parameter type for compile-time checking. Annotations carry metadata and parameters but are not part of the type system.

abstract cannot combine with final, private, or static on a method (nothing could implement or dispatch it); a class with an abstract method must be declared abstract. A constructor can't be abstract.

C.init x=0
x=5

The parent constructor calls the overridden init before C's field initialisers run, so x is still 0. Never call overridable methods from constructors.

A-s
B-s
A-i
A-c
B-i
B-c
A-i
A-c
B-i
B-c

Static blocks run once at class initialisation (parent first); instance blocks and constructors run per object, parent first.

Compile error: reference to m is ambiguous, since String and Integer are both more specific than Object and neither is more specific than the other. Removing one overload makes the call resolve to the remaining specific one.

A.Object. B.f(String) is an overload, not an override. The compiler picks f(Object) from A's methods (static type), and the runtime finds no override of it in B.

P P C. Fields are resolved by the static type, never polymorphically. get() is defined in P, so it sees P.name.

Prints hi. The compiler resolves a static method by the declared type and ignores the reference value, so no NPE. It is poor style and flagged by linters.

Almost always null. The two equal keys use identity hash codes, so they land in different buckets and equals is never consulted. It may print a by rare collision, which makes the bug intermittent.

false 1. The element is stored in the bucket for hash 1; contains looks in the bucket for hash 2. The element is lost to lookups and can't be removed (a memory leak in long-lived sets).

No. point.equals(colorPoint) is true but colorPoint.equals(point) is false, breaking symmetry. It also ignores y in Point, possibly a bug. Fixes: make the classes final, use composition (ColorPoint has a Point), or use getClass() in both (losing LSP).

false true true. new String creates a separate heap object; intern() returns the pooled instance, which is the literal a.

Compile error: attempting to assign weaker access privileges. An override must be the same or more visible, otherwise P p = new C(); p.run() would violate the parent contract.

Compile error. An override may throw the same, narrower or no checked exceptions, never broader. Unchecked exceptions are always allowed.

P. Private methods are not inherited and so can't be overridden; C.who is an unrelated method. call() binds to P.who at compile time.

Spring's class-based (CGLIB) proxy cannot subclass a final class or override final methods, so Spring Boot either fails at startup (final class) or the transaction advice is silently skipped for final methods (calls run the target directly). Use interface-based proxies or remove final. Kotlin's default-final classes need the allopen plugin for the same reason.

No transaction starts for audit() when called from place(). The call goes through this, bypassing the Spring proxy. Move audit to another bean, or inject self, or use TransactionTemplate.

Compute inline in the super(...) call, using a static helper: Child(int n) { super(format(n)); } with private static String format(int n). Instance methods can't be called before super returns.

Throws IllegalArgumentException from the compact canonical constructor. Compact constructors run validation/normalisation before fields are assigned automatically at the end; assigning to this.lo inside is an error, assign to the parameter instead.

Prints [a, b]. Records are only shallowly immutable. Fix with a compact constructor: members = List.copyOf(members);.

Instance fields outside the header are not allowed: compile error. Add a derived method instead, or a static factory. If you need extra mutable state, use a class.

record Person(String first, String last) {
    String full() { return first + " " + last; }
}

Every exhaustive switch without default stops compiling until Triangle is handled, which is the point: the compiler finds all places affected. If code is compiled separately and not rebuilt, the runtime throws MatchException (IncompatibleClassChangeError in older preview forms).

No: compile error, because Updated isn't listed in permits. Add it to the list or declare it nested/in the same file without permits.

Use a sealed interface with record implementations and pattern-matching switch for operations that vary by type; this makes the type set closed and compiler-checked. If new types come from plug-ins, use an open interface with Strategy beans instead. Trade-off: sealed favours adding operations, open interfaces favour adding types.

Compile error: C inherits unrelated defaults for go(). Override go() in C and delegate with A.super.go() if desired.

base. The "class wins" rule: a method inherited from a superclass beats an interface default.

B. Dispatch is on the runtime type; the static type A only determines which signature compiles. Through bridge method A make() the call lands in B.make().

Compiles with unchecked warnings; raw.add(42) succeeds due to erasure, and strs.get(0) throws ClassCastException at the compiler-inserted cast, far from the real bug (heap pollution).

Line 1 fails (invariance). Line 2 compiles. Line 3 fails: the compiler can't know the exact element type, so only null can be added. Use ? super Integer for writing.

T is erased, so the JVM can't instantiate it. Pass a Supplier<T> or Class<T> token: Box(Supplier<T> s) then s.get().

Compile error: name clash, same erasure save(List). Rename them or differentiate by another parameter.

entity.equals(proxy) returns false because the proxy's class is a generated subclass, so entities may appear missing from Sets or fail contains. Use instanceof (or Hibernate.getClass) and compare a business key or non-null id; keep hashCode stable (for example a constant class hash or business key) across persist.

Date is mutable, so callers can do getCreated().setTime(0) and corrupt the object's state. Return a copy or use immutable Instant/LocalDateTime from java.time.

Another thread may receive the half-constructed object and read v as 0. The JMM's final-field guarantee requires that this not escape before the constructor ends. Use a static factory that registers after construction.

[a, b] [a]. The wrapper is a read-only view of the live list; copyOf is a true immutable snapshot.

Delhi. The clone shares the same Addr instance. Fix by cloning addr in clone(), or use a copy constructor.

A final mutable field copied by super.clone() can't be reassigned in clone() to deep-copy it (outside reflection), so cloneable designs conflict with final. This is another reason to prefer copy constructors or factories.

It exposes add(index, e), remove, and get which break stack semantics, and ties the API to ArrayList forever. Use composition: a Stack class with a private Deque<E> and only push, pop, peek. (This is the very mistake made in java.util.Stack extends Vector.)

6, not 3. HashSet.addAll (from AbstractCollection) calls add for each element, so each is counted twice. Fix with composition and a forwarding class.

Open/Closed: every new customer type edits this method. Refactor to a PricingStrategy interface with one implementation per type, or put a discount() on the enum, and select by map lookup. Trade-off: more classes; for 3 stable types an enum with a method is enough.

Single Responsibility: three reasons to change (data query, format, delivery). Split into ReportRepository, CsvFormatter, Mailer, and keep ReportService as orchestration. Each part can be unit-tested and replaced independently.

Interface Segregation: the client is forced to implement save/delete (throwing UnsupportedOperationException), which also violates LSP. Split into ReadRepository and WriteRepository and compose them where both are needed (Spring Data does this with Repository, CrudRepository and ListCrudRepository).

Define PaymentGateway in the domain, make StripeGateway implements PaymentGateway, and inject via constructor. Tests then use a fake; switching providers touches only configuration.

@Service
class CheckoutService {
    private final PaymentGateway gateway;
    CheckoutService(PaymentGateway gateway) { this.gateway = gateway; }
}

No. For a Square, setHeight(5) also changes width, so area is 25. The subtype changes behaviour callers rely on (postconditions). Model both as immutable shapes implementing a Shape interface with area().

7. Inner keeps a hidden Outer.this, so the Outer instance stays reachable while i lives. Declare Inner as static and pass what it needs if the lifetimes differ.

Compile error: local variables referenced from a lambda (or local/anonymous class) must be final or effectively final. Use AtomicInteger, or a one-element array only if single-threaded and justified.

a.run() prints anon, l.run() prints outer. In a lambda this is the enclosing instance; in an anonymous class it is the anonymous instance.

Existing rows keep integers (1) that now map to different constants: silent data corruption (PAID rows become SHIPPED). Use @Enumerated(EnumType.STRING) or an AttributeConverter with stable codes, and never reorder or delete constants for ORDINAL mappings.

5 class Op$2 class Op. Constants with bodies are anonymous subclasses, so getClass() differs from getDeclaringClass(); use the latter for EnumMap-style logic.

No to both. Constructors are implicitly private and the enum is implicitly final (or sealed when a constant has a body). Reflection Constructor.newInstance throws IllegalArgumentException: Cannot reflectively create enum objects.

Throws IllegalArgumentException: No enum constant Status.paid; it is case-sensitive, and null yields NPE. For user input, write a lookup with Optional or a static map.

Something like Plain@1b6d3586: class name, @, and hex hashCode(). Never parse or rely on the value; it differs between runs.

1. TreeSet uses compareTo, not equals, so versions 1.0 and 1.5 are duplicates. Compare all significant fields: Comparator.comparingInt((Ver v) -> v.major).thenComparingInt(v -> v.minor).

NullPointerException: register() runs from the Handler constructor before Mail's field initialiser has created sinks. Do registration in an explicit init() after construction or via a factory.

The assignment is a compile error: interface fields are implicitly public static final. Using the constant interface anti-pattern pollutes implementors' namespace; place constants in a final utility class or an enum.

other.touch() fails to compile; s.touch() and touch() work. Outside the package, protected access is only allowed through a reference of the subclass type (or its subtypes), not through a parent-typed reference.

All implementors in other codebases stop compiling and fail at runtime with AbstractMethodError when binary-compatible code calls it. Add it as a default method with a safe implementation (how Collection.removeIf, List.sort and Map.getOrDefault were added in Java 8). Trade-off: defaults can't use instance state, so choose a sensible behaviour.

The old bytecode's exhaustive switch has no branch for the new subtype, so it throws MatchException at runtime (Java 21; earlier previews threw IncompatibleClassChangeError). Rebuild dependents when you change a sealed hierarchy, or keep a defensive default at module boundaries.

Compile error: Optional<Dog> is not a subtype of Optional<Animal> due to invariance, so it's not a valid covariant return. Declare the parent as Optional<? extends Animal> and the child as Optional<Dog>.

Compile error: Timestamp implements Comparable<java.util.Date>, not Comparable<Timestamp>, so T fails the bound. The fix is <T extends Comparable<? super T>>, the idiom used by Collections.max.