Java OOPS interview questions

Object-Oriented Programming in Java is a way of designing programs around objects, which combine data and behavior in one unit. Instead of writing everything as separate functions, we model real concepts such as user, order, account, or employee as classes and objects.

The main goal of OOP is to make code easier to organize, reuse, test, and maintain. In interviews, a strong short summary is: Java uses classes and objects to build programs in a modular and reusable way.

A class is a blueprint that defines fields and methods, while an object is the real instance created from that class. The class describes what something should have and do, and the object is the actual runtime entity.

For example, `Car` can be a class, but `myCar` is an object of that class. In interviews, one-line clarity helps: class is design, object is the real created thing in memory.

The four main pillars of OOP are encapsulation, abstraction, inheritance, and polymorphism. These ideas help us hide complexity, reuse code, and write flexible designs.

Encapsulation means wrapping data and methods together with controlled access. Abstraction means showing only the important part. Inheritance helps one class reuse another class's features, and polymorphism lets the same interface behave differently for different objects.

OOP is useful because it helps break a large program into smaller classes with clear responsibilities. This makes code easier to understand, test, change, and reuse.

It also supports maintainability because one part of the system can change without affecting everything else when classes are designed well. In interviews, mention modularity, reusability, and maintainability as the main benefits.

Encapsulation is the idea of keeping data and the methods that work on that data inside one class and controlling direct access to that data. In Java, this is commonly done by making fields private and exposing public methods such as getters, setters, or business methods.

Encapsulation protects the internal state of an object and allows validation before data changes. A good interview summary is: encapsulation hides internal details and gives controlled access through methods.

Access modifiers decide who can see fields, methods, classes, and constructors. They help encapsulation by restricting direct access and exposing only what should be used from outside the class.

For example, `private` gives the strongest hiding inside the same class, while `public` allows access everywhere. In interviews, explain that access modifiers are the practical tool Java gives us to implement encapsulation.

Abstraction means showing only the essential behavior and hiding the internal implementation details. In Java, abstraction is mainly achieved using abstract classes and interfaces.

A user of a class should know what a method does, not always how it does it internally. In interviews, say that abstraction reduces complexity by focusing on required behavior instead of internal working.

Abstraction is about hiding unnecessary implementation details and showing only the important behavior. Encapsulation is about wrapping data and methods together and controlling access to the internal state.

A simple way to remember it is: abstraction focuses on what to show, while encapsulation focuses on how to protect. In interviews, this distinction matters because many candidates mix them up.

An abstract class is used when related classes should share common state or common implementation, while an interface is mainly used to define a contract that different classes can follow. An abstract class can have instance fields and constructors, but an interface cannot have normal instance state.

Java allows a class to extend only one class, but it can implement multiple interfaces. In interviews, a practical answer is: use abstract class for shared base behavior, and use interface for capability or contract.

Yes, an abstract class can have a constructor. Even though we cannot create an object directly from an abstract class, its constructor is called when a concrete subclass object is created.

This is useful for initializing common fields or shared setup logic in the parent class. In interviews, say clearly that abstract classes cannot be instantiated directly, but their constructors still run through subclasses.

Inheritance is a feature where one class can acquire fields and methods from another class. The existing class is the parent or superclass, and the new class is the child or subclass.

Inheritance is useful when the child truly represents a specialized version of the parent. In interviews, mention reuse and extension, but also add that inheritance should be used only when there is a real IS-A relationship.

Java supports single inheritance, multilevel inheritance, and hierarchical inheritance with classes. Java does not support multiple inheritance of classes.

However, Java does allow multiple inheritance of type through interfaces, because one class can implement more than one interface. In interviews, this is an important distinction: no multiple class inheritance, but multiple interface implementation is allowed.

Java avoids multiple inheritance of classes mainly to reduce ambiguity and complexity. If two parent classes provide methods or state with the same name, the child class can face confusion about which implementation to use.

This problem is often explained using the diamond problem. Java solves the need for multiple behavior sharing by using interfaces, which keeps design cleaner and easier to reason about.

The `super` keyword is used to refer to members of the immediate parent class. It is commonly used to call the parent constructor, access a parent field, or call a parent method that has been overridden.

It becomes especially useful when parent and child members have the same name. In interviews, remember the three common uses: parent constructor, parent variable, and parent method.

The `this` keyword refers to the current object. It is used to access current object fields and methods, remove naming confusion, and call another constructor in the same class using `this()`.

A common example is when a constructor parameter name matches a field name, such as `this.name = name`. In interviews, say that `this` represents the current object's reference.

`this()` is used to call another constructor from the same class, while `super()` is used to call a constructor from the parent class. Both are constructor calls and must appear as the first statement inside a constructor.

You cannot use both in the same constructor because each one must come first. In interviews, this is often asked as a rule-based question, so answer directly and clearly.

A constructor is a special block used to initialize an object when it is created. The common types are default constructor, no-argument constructor, and parameterized constructor.

A constructor has the same name as the class and does not have a return type. In interviews, also mention that constructors can be overloaded, which is common in real Java code.

No, constructors are not inherited and they cannot be overridden. A child class can call a parent constructor, but it does not inherit that constructor as a normal method.

Constructors belong to object creation for their own class, so they are treated differently from normal methods. In interviews, a strong answer is: constructors can be overloaded, but not inherited or overridden.

Method overloading means having multiple methods with the same name in the same class but with different parameter lists. The difference can be in number of parameters, type of parameters, or order of parameters.

Overloading is an example of compile-time polymorphism because the compiler decides which method call matches. In interviews, mention that changing only the return type is not enough for overloading.

Method overriding happens when a child class provides its own version of a method that already exists in the parent class. The method name and parameter list must stay the same.

Overriding is used for runtime polymorphism because the actual object decides which implementation runs. In interviews, say that overriding changes inherited behavior in a subclass.

Method overloading happens in the same class and uses the same method name with different parameter lists. Method overriding happens between parent and child classes and keeps the same method signature while changing behavior.

Overloading is resolved at compile time, while overriding is resolved at runtime. In interviews, compare them using place, signature rule, and binding time.

Compile-time polymorphism is when the method call is decided by the compiler, and method overloading is the common example. Runtime polymorphism is when the method call is decided while the program is running, and method overriding is the common example.

The key difference is when the decision is made. In interviews, a short clean line is: overloading gives compile-time polymorphism, and overriding gives runtime polymorphism.

Dynamic method dispatch means the overridden method that runs is chosen according to the real object type at runtime, not just the reference type. This is one of the main reasons runtime polymorphism works in Java.

For example, a parent reference can point to a child object, and the child version of the overridden method will execute. In interviews, connect dynamic dispatch directly with overriding and runtime polymorphism.

Private methods cannot be overridden because they are not visible in the child class. Final methods cannot be overridden because Java explicitly blocks that change. Static methods are not truly overridden; they are hidden based on the reference type.

This is a common interview trap because many people group all methods together. A strong answer clearly separates not visible, blocked, and hidden behavior.

A covariant return type means an overriding method in the child class can return a more specific type than the method in the parent class. Java allows this when the returned type is a subclass of the parent method's return type.

This makes overridden methods more useful without breaking polymorphism. In interviews, the important point is that the return type can become more specific, not unrelated.

Upcasting means storing a child object inside a parent reference, and it is safe and common in polymorphism. Downcasting means converting a parent reference back to a child type, and it needs explicit casting.

Downcasting is only safe if the actual object really belongs to that child type, otherwise it causes a `ClassCastException`. In interviews, mention that upcasting is automatic, while downcasting is explicit and risky.

Association is a general relationship between two classes where objects of one class can use or know about objects of another class. It simply shows that the objects are connected in some way.

For example, a teacher and a student can be associated without one fully owning the other. In interviews, describe association as the broad relationship category that also includes aggregation and composition.

Both aggregation and composition represent HAS-A relationships, but composition is stronger. In aggregation, the child object can exist independently, while in composition the child object's lifecycle is usually tied to the parent.

For example, a department and professor can be aggregation, but a house and room is often explained as composition. In interviews, focus on ownership strength and lifecycle dependency.

Composition is usually better when you want to reuse behavior without creating a strict parent-child relationship. It keeps classes more flexible because one object can use another object instead of becoming tightly coupled to a class hierarchy.

Inheritance is powerful, but it can make designs rigid if used too early or too widely. In interviews, a strong line is: use inheritance for real IS-A relationships, and use composition when behavior can be built using smaller parts.

IS-A relationship is used in inheritance, where one class is a specialized type of another class. HAS-A relationship is used when one class contains or uses another class as a member.

For example, `Dog` IS-A `Animal`, but `Car` HAS-A `Engine`. In interviews, this question is often used to check whether you understand when to use inheritance and when to use composition.

The `Object` class is the root parent class of all Java classes. Every class in Java directly or indirectly inherits from `Object`.

Because of this, methods such as `toString()`, `equals()`, `hashCode()`, and `clone()` come from `Object`. In interviews, this is an important base concept because many common Java behaviors depend on `Object`.

For objects, `==` checks whether two references point to the same memory location. `equals()` is meant to check logical equality, and classes can override it to compare content instead of memory address.

If a class does not override `equals()`, then `equals()` behaves like reference comparison from `Object`. In interviews, always say reference equality versus logical equality.

If two objects are considered equal by `equals()`, they must produce the same hash code. If this rule is broken, hash-based collections such as `HashMap` and `HashSet` may behave incorrectly.

The main issue is consistency in searching, storing, and retrieving objects in buckets. In interviews, say that overriding `equals()` without matching `hashCode()` breaks the equals-hashCode contract.

The contract says that if two objects are equal according to `equals()`, they must return the same value from `hashCode()`. The opposite is not always required, because two different objects can still share the same hash code.

This rule matters especially in hash-based collections. In interviews, mention the guaranteed part clearly: equal objects must have equal hash codes.

An immutable class is a class whose objects cannot be changed after creation. Once the object is built, its state stays the same for the whole lifetime of that object.

Immutable classes are easier to reason about and are safer to use in shared or multithreaded code. In interviews, `String` is the most common example used to explain immutability.

A common way is to make the class final, keep fields private and final, avoid setter methods, and initialize all values through the constructor. If the class contains mutable objects, it should return defensive copies instead of the original reference.

The goal is to stop external code from changing internal state after object creation. In interviews, mention private final fields and no setters as the core points.

Static members belong to the class itself, while instance members belong to each object. A static variable is shared, but an instance variable has a separate copy for every object.

Static methods can be called without creating an object, but they cannot directly use instance data without an object reference. In interviews, say that static is class-level and instance is object-level.

A final variable cannot be reassigned once initialized. A final method cannot be overridden, and a final class cannot be extended.

The keyword is used to restrict change in different contexts. In interviews, the easiest way to answer is by separately explaining final variable, final method, and final class.

Yes. Modern Java allows interfaces to have default methods, static methods, and even private helper methods. This makes interfaces more powerful than they were in older Java versions.

Default methods provide a reusable implementation, static methods belong to the interface itself, and private methods help avoid repeated code inside the interface. In interviews, mention that normal interface fields are still constants by default.

Yes, a class can implement multiple interfaces. This is Java's way of allowing multiple inheritance of type without allowing multiple inheritance of classes.

It lets one class promise to support multiple behaviors or contracts. In interviews, this is a very common question, so answer directly and mention that it avoids the ambiguity of multiple class inheritance.

Yes, an interface can extend one or more interfaces. This helps build larger contracts from smaller ones.

An extending interface inherits the abstract methods and default methods that are part of the parent interfaces. In interviews, remember that interfaces can extend multiple interfaces, while classes can extend only one class.

A marker interface is an interface with no methods or fields that is used only to provide metadata or indicate a special capability. It tells the JVM or framework that the class has a specific meaning.

Examples often discussed are `Serializable` and `Cloneable`. In interviews, say that a marker interface marks a class rather than defining normal behavior.

A functional interface is an interface that has exactly one abstract method. It is mainly used with lambda expressions and method references.

Even if it has default or static methods, it is still functional as long as it has only one abstract method. In interviews, mention the `@FunctionalInterface` annotation as a helpful validation tool, even though it is optional.

An inner class is tied to an object of the outer class and can directly access instance members of that outer object. A static nested class belongs to the outer class itself and does not need an outer object instance.

The main difference is whether the nested class depends on outer object state. In interviews, say that inner class is object-level and static nested class is class-level.

An anonymous class is a class without a separate name that is declared and created in one step. It is usually used for a short one-time implementation of a class or interface.

Anonymous classes were commonly used before lambdas became popular. In interviews, say that they are helpful for small custom behavior that does not need a full named class.

A shallow copy copies the top-level object but still shares references to nested mutable objects. A deep copy copies the full object graph so that nested objects are also duplicated.

Because of shared references, changing nested data in a shallow copy can affect the original object. In interviews, focus on whether internal referenced objects are shared or fully copied.

Object cloning is a way to create a copy of an existing object. Java provides `clone()` and the `Cloneable` marker interface, but cloning is often considered tricky and is used carefully in real projects.

By default, cloning usually gives shallow copy behavior unless extra work is done. In interviews, it is good to mention that copy constructors or factory methods are often preferred because they are clearer and safer.

Tight coupling means classes depend heavily on each other's exact implementation details. Loose coupling means classes depend more on abstractions or contracts, so changes in one class affect the other less.

Loose coupling improves flexibility, testing, and maintainability. In interviews, say that interfaces, dependency injection, and composition help reduce coupling.

Polymorphism allows the same reference type or interface to work with different implementations. This reduces hard-coded dependencies and makes it easier to extend behavior without changing old calling code.

For example, code can depend on an interface such as `PaymentService` instead of a specific payment class. In interviews, explain that polymorphism supports extensibility and cleaner design.

In overriding, the child method cannot use a more restrictive access modifier than the parent method. Also, the child method cannot throw broader checked exceptions than the parent version.

This keeps overriding safe for code that is using the parent reference. In interviews, remember these two rules clearly because they are common Java-specific OOP questions.