Object-Oriented Programming

Java hides an object's data by marking fields private and exposing them through public getter and setter methods. This lets the class control and validate access and change its internals later without breaking other code.

The four pillars are encapsulation, inheritance, polymorphism, and abstraction. Java uses access modifiers for encapsulation, extends and interfaces for inheritance, method overriding for polymorphism, and abstract classes and interfaces for abstraction.

When you call an overridden method, Java decides at runtime which version to run based on the object's actual type, not the variable's declared type. This is dynamic dispatch. Overloading is different: the compiler picks among same-named methods at compile time using the argument types.

Use an interface to define a pure capability that many unrelated classes can implement, since a class can implement many interfaces. Use an abstract class when you need shared state (fields) or a partial implementation, since a class can extend only one.

Allowing a class to extend only one class avoids ambiguity when two parents have conflicting code (the diamond problem), while letting a class implement many interfaces keeps flexibility. The downside is rigid hierarchies, which Java teams usually solve by favoring composition (holding objects and delegating) over deep inheritance.

A class declaration is the keyword class, a name, and a body in curly braces holding fields and methods. Optionally it has modifiers (like public) before it and an extends/implements clause. Minimal: class Dog { }.

A single .java file can have at most one public top-level class, and the file must be named exactly after that public class (plus .java). You can add more non-public (package-private) classes in the same file.

== checks if two references point to the exact same object in memory (identity). equals() checks whether two objects are logically equal in value. They can disagree: two different objects can hold equal data.

new makes a fresh object. It sets aside memory on the heap for the object, runs its constructor to set it up, and gives you back a reference (an address) you store in a variable.

A reference variable is like a label that holds the address of an object; the object is the actual data living on the heap. Many labels can point to the same object, and a label can point to nothing (null).

A method has modifiers (like public, static), a return type (the kind of value it gives back, or void for none), a name, a parameter list in parentheses, an optional throws clause, and a body in braces with the code.

Method overloading is having several methods with the same name in the same class but different parameter lists (different number or types of parameters). The compiler picks the right one based on the arguments you pass.

Java is always pass-by-value. The method gets a copy of the argument. For an object, that copy is a copy of the reference (the address), not a copy of the object itself.

Recursion is when a method calls itself to solve a smaller piece of a problem. The base case is the simple input that stops the calling, so the method does not call itself forever and eventually returns an answer.

Varargs (variable arguments) let a method accept any number of arguments of one type, written as Type... name. Inside the method, name is an array. You call it like sum(1, 2, 3) or pass an array.

The parent constructor runs before the child constructor body. So construction goes top-down: the topmost ancestor (Object) is built first, then each subclass in turn, ending with the class you actually created.

Constructor chaining means one constructor calls another so you don't repeat setup. this(...) calls another constructor in the same class; super(...) calls the parent class's constructor.

No. Constructors are not inherited. A subclass must define its own constructors. When a subclass object is built, its constructor first calls a superclass constructor (with super(...), or an implicit super() if you omit it).

A constructor is a special method that runs when you create an object with new, to set it up. If you write no constructor, Java adds a hidden no-argument one for you so you can still write new MyClass().

As soon as you write any constructor of your own — even one that takes parameters — the compiler stops adding the free no-arg one. Then new MyClass() won't compile unless you also write the no-arg constructor yourself.

A private field hides the data and lets the class control how it's read or changed through methods. That means you can add validation, compute values, or change how the data is stored later without breaking code that uses the class.

Java has four access levels: public (everywhere), private (only inside the same class), protected (same package plus subclasses), and default — written by adding no keyword — which allows access only inside the same package.

Information hiding means keeping a class's internal data private and letting outside code touch it only through public methods. In Java you mark fields private and add public getters/setters so the class controls how its state is read and changed.

private: same class only. Default (no keyword): same package. protected: same package plus subclasses anywhere. public: everyone. Each level adds one more group of allowed callers.

If a getter returns the actual internal mutable object (like a List or Date), callers can change it from outside, bypassing your class's rules. The fix is to return or store a copy (a defensive copy), or hand back an unmodifiable view, so the internal state stays under the class's control.

extends makes one class a subclass of another, so the subclass inherits the parent's fields and methods. Java allows a class to extend only one direct parent class (single inheritance).

Use super.methodName() to call the parent's version of a method that the subclass has overridden. super refers to the parent-class part of the current object.

A final class can't be extended (no subclasses). A final method can't be overridden by a subclass, though the class itself can still be subclassed. Both lock down a piece of behavior so others can't change it.

The subclass method must have the same name and same parameter list as the superclass method, and the same (or a compatible) return type. If the name or parameters differ, it is not an override - it becomes a separate or overloaded method.

super(...) calls a parent constructor and must be the first statement in a subclass constructor. If you don't write it, Java inserts a no-arg super() automatically so the parent is always initialized first.

Upcasting treats an object as one of its parent types (Dog seen as Animal); it is automatic and always safe. Downcasting treats it back as the more specific child type (Animal back to Dog); it needs an explicit cast and can fail at runtime.

Overloading means several methods share a name but take different parameters; the compiler picks one. Overriding means a subclass replaces a parent method with the same signature; Java picks it at runtime based on the real object. Overloading is compile-time polymorphism, overriding is runtime polymorphism.

Binding is how a call is matched to the actual method or variable. Static binding is decided at compile time (overloaded methods, static methods, fields). Dynamic binding is decided at run time based on the real object type, which is how overridden instance methods work.

Before casting a parent-typed reference to a child type, check it with instanceof. If the check passes, the cast is safe. Modern Java lets you do both at once: if (x instanceof Dog d) binds d so you skip the separate cast.

Each object knows its real class. When you call an overridden method through a parent-type reference, the JVM looks up the method on the object's actual class at runtime and runs that version. This runtime lookup is called dynamic method dispatch.

An abstract method is written with the abstract keyword and no body — just a signature ending in a semicolon. Any concrete (non-abstract) subclass must override it and supply a real body, or it won't compile.

An abstract class is a class marked with the abstract keyword that you cannot create objects from directly. It can mix finished methods with unfinished (abstract) methods that subclasses must complete. It can also hold normal fields and constructors.

You write interface Name { ... }. An interface lists method signatures (no bodies) that implementing classes must provide, and it can hold constants. A class uses implements Name to promise it provides those methods.

A default method is an interface method with a body, marked with the default keyword. Classes that implement the interface inherit it for free, so you can add new methods to an interface without breaking existing implementers.

A functional interface is an interface with exactly one abstract method, so it can be implemented by a lambda. @FunctionalInterface is an optional annotation that makes the compiler check that the interface really has just one abstract method.

IS-A means one type is a kind of another (a Car IS-A Vehicle) and uses inheritance (extends). HAS-A means an object holds another as a part (a Car HAS-A Engine) and uses a field. IS-A is inheritance; HAS-A is composition.

Instead of one class extending another to reuse code, the class holds another object as a field and calls its methods. It is preferred because it couples classes less tightly and is more flexible to change.

Both are HAS-A. Composition is strong ownership: the part can't live without the whole, and when the whole is destroyed, so is the part (a House HAS rooms). Aggregation is weak: the part can exist independently and may be shared (a Team HAS players who outlive the team).

Keep the other object in a private field, and write methods that simply call the matching method on that held object. Those one-line pass-through methods are the forwarding methods.

If you store a caller's mutable object directly, the caller still holds a reference and can change your object's internals behind your back. Fix it by copying the object when it comes in (constructor/setter) and when it goes out (getter), so outside code can't reach the part you own.

An inner class is a non-static class defined inside another class. Each inner-class object is tied to an object of the outer class and can use the outer object's fields and methods. A static nested class has no such tie.

A static nested class is a class declared inside another class with the static keyword. You can create and use it without first creating an object of the outer class: new Outer.Nested().

A local variable used inside a local/anonymous class must never be reassigned after it's set — that's what 'effectively final' means. Java requires this because the class captures a copy of the variable's value, so allowing reassignment would let the two copies drift apart.

A non-static inner class secretly holds a reference to the outer object that created it, so it can use the outer object's fields. A static nested class holds no such reference, so it can't reach the outer instance's fields and needs no outer object to be created.

A local class is a named class declared inside a method body. An anonymous class is a one-time, unnamed class you declare and instantiate in a single expression, usually to implement an interface or extend a class on the spot.

An enum is a special class whose instances are a fixed, named set of constants. You declare it with the enum keyword and list the constants, e.g. enum Day { MONDAY, TUESDAY }. Each constant is one shared, type-safe object.

Put the enum value in switch(value) and use the bare constant names (like MONDAY, not Day.MONDAY) in each case. The compiler knows the type, so you skip the prefix and it can warn if a case is missing.

List each constant with constructor arguments in parentheses, then declare instance fields, a constructor, and methods after a semicolon. The constructor is implicitly private because you may not create new enum instances — the JVM creates them all at load time.

values() returns an array of all constants in declaration order. valueOf("NAME") returns the constant with that exact name (throws if none). name() returns the constant's declared name as a String. ordinal() returns its zero-based position in the declaration list.

Because the JVM guarantees exactly one instance of each enum constant, and that single instance survives reflection and serialization attacks for free. So enum Singleton { INSTANCE; } gives you a thread-safe, attack-proof singleton with no boilerplate.

A record is a compact class for holding immutable data. You list its components in the header, and the compiler auto-generates a private final field plus an accessor for each, a constructor, and equals, hashCode, and toString.

The canonical constructor is a record's main constructor whose parameters match its components, one-for-one, by name and type. If you don't write one, the compiler generates it for you, and it just assigns each parameter to the matching field.

You can add instance methods, static fields, static methods, and nested types. You can also override the auto-generated accessors, equals, hashCode, and toString. You cannot declare extra instance fields beyond the ones in the record header.

Two records are equal if they are the same record type and every component is equal. hashCode is computed from all components and stays consistent with equals. toString prints the type name and each component, like Point[x=1, y=2].

A compact constructor uses the record's name with no parameter list and no field assignments. You write only validation or cleanup code; the compiler automatically assigns all the components to their fields at the very end.

A sealed class or interface restricts which other classes can extend or implement it. You list the allowed subtypes with the permits clause, so no unexpected class can join the hierarchy.

Each permitted subclass must be final (no further subclasses), sealed (continues the closed hierarchy with its own permits list), or non-sealed (reopens that branch so anyone can extend it).

A sealed type lists exactly which subtypes can exist. If your switch has a case for every permitted subtype, the compiler knows nothing else is possible and accepts it as complete (exhaustive) without a default branch.

A sealed type and all its permitted subtypes must live together: in a named module, in the same module; otherwise in the same package. Each permitted subtype must directly extend the sealed type and be accessible to it at compile time.

Leaving out default makes the compiler force you to handle every subtype. If you add a new subtype later, the switch stops compiling and shows you exactly where to update it. A default would hide that.

instanceof pattern matching lets you test a type and bind the value to a typed variable in one step: if (obj instanceof String s) gives you s already cast to String, so you skip the separate, manual cast.

Switch pattern matching lets each case test the type of the value instead of comparing it to a constant. A type pattern like case Circle c matches when the value is a Circle and binds it to c, which you can use directly in that branch.

The pattern variable is in scope only where the compiler is sure the match was true. After && the match must hold for the right side to run, so it's usable there; after || the right side runs precisely when the match failed, so it isn't.

A sealed type lists all its permitted subtypes, so the compiler knows the complete set of possibilities. If your switch has an arm for each one, it covers everything and you can skip default. Omitting default means adding a new subtype later causes a compile error, reminding you to handle it.

A record pattern matches a record and pulls its components into variables in one step. Instead of binding the whole record like 'Point p', you write 'Point(int x, int y)' to get x and y directly without calling p.x() and p.y().

Comparable defines a type's natural ordering through one method, compareTo. It returns a negative number if this object is smaller, zero if equal in order, and a positive number if larger.

By default, equals() checks whether two references point to the exact same object in memory — the same as ==. To compare by value (content), you must override equals() yourself.

First check if the other object is the same one (==). Then check it isn't null and is the right type. Then cast it and compare each field that defines equality, using Objects.equals for object fields so nulls are handled safely.

Because Java's hash-based collections (like HashMap and HashSet) first use hashCode() to find the right bucket, then equals() to compare. If equal objects return different hash codes, they land in different buckets and the collection never finds the match.

hashCode() returns an int for an object. Two rules matter: if two objects are equal (equals() is true), they must return the same hashCode; and a hashCode must stay the same across repeated calls during one run. Unequal objects may share a code.