Java OOPS for Interviews

Master the full range of Java constructor behavior — from overloading and chaining to execution order and private constructors.

• Default constructor — provided by Java automatically when no constructor is explicitly defined

• Constructor overloading — multiple constructors with different parameter types or counts

• Constructor chaining — calling one constructor from another using this() within the same class

• super() positioning — parent constructor call must be the first statement in a child constructor

• Constructor execution order in inheritance — parent constructor always executes before child

• Private constructors — used in Singleton pattern and utility classes to restrict instantiation

• Constructor vs method — no return type, same name as class, called only at object creation

• Copy constructor — creating a new object as a copy of an existing object of the same class

Understand how Java models IS-A relationships through inheritance — including its hierarchy types, restrictions, and the diamond problem.

• Single inheritance — one class extending another, Java's most common inheritance form

• Multilevel inheritance — chain of inheritance across three or more levels (A → B → C)

• Hierarchical inheritance — multiple classes extending a single parent class

• Multiple inheritance restriction — Java does not allow a class to extend more than one class

• Diamond problem — ambiguity when multiple parents share a common ancestor, avoided by Java with classes

• super keyword — accessing parent class members, methods, and constructor from child class

• Method overriding in inheritance — child class redefines parent method with same signature

• Abstract class inheritance — extending abstract classes requires implementing all abstract methods

Master both forms of Java polymorphism — compile-time through overloading and runtime through overriding and dynamic method dispatch.

• Method overloading — same name with different parameter types, count, or order, resolved at compile time

• Method overriding — same signature in parent and child class, resolved at runtime based on object type

• Dynamic method dispatch — JVM decides which overridden method to call based on actual object type at runtime

• Upcasting — assigning child object to parent reference, implicit and always safe

• Downcasting — casting parent reference back to child type, explicit and requires instanceof check

• Covariant return types — overriding method can return a subclass of the original return type (Java 5+)

• Static method hiding — static methods cannot be overridden, same name in child is method hiding

• Private methods — not visible to subclasses, cannot be overridden, same name in child is a new method

Design systems that hide complexity and expose only essential behavior using abstract classes and interfaces effectively.

• Abstract class — declared with abstract keyword, can contain both abstract and concrete methods

• Abstract method — no body, declared with abstract keyword, must be implemented by concrete subclass

• Abstract class instantiation — cannot use new directly, but constructor runs when subclass object is created

• Abstract class with no abstract methods — valid syntax, used purely to prevent direct instantiation

• Abstract class vs interface — use abstract class for IS-A with shared state, interface for capability contracts

• Partial implementation — abstract class can implement some methods, leaving others for subclasses

• Why abstract class has constructor — to initialize common state needed by all subclass objects

• 0-100% abstraction — abstract class allows any level, interface enforces 100% (pre-Java 8)

Protect object state by controlling data access — and understand how encapsulation improves maintainability, security, and flexibility.

• Data hiding — declaring instance variables private to prevent direct external access

• Getter methods — public accessor methods that expose private data in a controlled way

• Setter methods — public mutator methods that validate input before assigning to private fields

• Read-only property — providing only a getter with no corresponding setter

• Write-only property — providing only a setter with no corresponding getter

• Validation in setters — checking input validity before modification to maintain object integrity

• Encapsulation vs abstraction — encapsulation hides data, abstraction hides implementation complexity

• Tight encapsulation — all instance variables private, all access goes through public methods only

Define behavioral contracts using Java interfaces — from classic abstract method declarations to Java 8+ default, static, and functional interfaces.

• Interface variables — public static final by default, effectively constants

• Interface methods — public abstract by default before Java 8

• Default methods (Java 8) — methods with body in interface using the default keyword

• Static methods in interface (Java 8) — interface-level utility methods not inherited by implementing classes

• Private methods in interface (Java 9) — helper methods reusable within the interface itself

• Multiple interface implementation — a class can implement multiple interfaces, enabling multiple type relationships

• Functional interface — interface with exactly one abstract method, used as lambda expression target

• Interface inheritance — one interface can extend another using the extends keyword

• Marker interfaces — empty interfaces like Serializable and Cloneable that convey metadata

• Conflicting default methods — implementing class must override when two interfaces provide same default method

Organize Java code effectively using packages and understand how they control access, prevent naming conflicts, and structure large applications.

• Package declaration — must be the first statement in a Java file: package com.example;

• Import statements — bring classes from other packages into scope, avoiding fully qualified names

• Default (package-private) access — class members with no modifier are accessible only within same package

• Fully qualified class name — accessing a class without import using complete path: com.example.ClassName

• Built-in packages — java.lang (auto-imported), java.util, java.io, java.sql

• Naming conventions — lowercase, reverse domain name format: com.company.project.module

• Sub-packages — packages within packages, no inheritance relationship between parent and sub-package

• Benefits — namespace management, access control, logical code organization for large projects

Apply the final keyword correctly across variables, methods, and classes — and understand its distinct role from finally and finalize.

• Final variable — acts as a constant, must be initialized once, cannot be reassigned

• Blank final variable — declared without initialization, must be assigned in the constructor

• Final reference type — the reference cannot change, but the object's internal state can still be modified

• Static final variable — class-level constant, conventionally named in UPPERCASE_WITH_UNDERSCORES

• Final method — cannot be overridden by any subclass, used to prevent behavior modification

• Final class — cannot be extended, prevents inheritance entirely (e.g., String class)

• Why String is final — security, caching, and thread-safety of the string pool depend on immutability

• Final vs finally vs finalize — keyword for constants, exception cleanup block, and deprecated GC method respectively

Understand Java's root class and master the contracts for overriding its core methods correctly — especially equals and hashCode.

• Object class — root of the Java class hierarchy, every class implicitly extends Object

• toString() — default returns classname@hashcode, override to provide meaningful string representation

• equals() — default is reference comparison (==), override for value-based equality comparison

• hashCode() — must be overridden when equals() is overridden to maintain the equals-hashCode contract

• equals-hashCode contract — equal objects must produce the same hashCode, required for HashMap and HashSet

• Contract violation consequence — overriding equals() without hashCode() breaks hash-based collections silently

• clone() — creates a copy of the object, requires implementing the Cloneable marker interface

• wait(), notify(), notifyAll() — thread synchronization methods inherited from Object class

• Method overriding rules — same signature, compatible (covariant) return type, cannot reduce access visibility

Build a solid foundation in how Java classes are structured and how objects behave at runtime — including static members, this keyword, and the object lifecycle.

• Class as blueprint — defines structure and behavior shared by all objects of that type

• Object creation — using the new keyword invokes the constructor and allocates heap memory

• Instance variables — belong to individual objects, each object has its own copy

• Static members — belong to the class itself, shared across all instances

• this keyword — refers to the current object, used to resolve ambiguity and chain constructors

• Null reference — object variable declared but not pointing to any object in memory

• NullPointerException — thrown when a method or field is accessed on a null reference

• Object lifecycle — creation with new, usage through references, garbage collection when unreachable