Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Object Oriented Programming · Question Set
Inheritance & Polymorphism interview questions for placements and exams.
Questions
14
Included in this set
Subject
Object Oriented Programming
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for Object Oriented Programming.
The diamond problem arises in languages with multiple inheritance when a class inherits from two classes which both inherit from a common base class. This can lead to ambiguity about which base class’s implementation to use. Many languages avoid this with interfaces or virtual inheritance.
For complete preparation, combine this set with full subject-wise practice for Object Oriented Programming. You can also explore other subjects and sets from the links below.
Single inheritance is when a class (often called the child or subclass) inherits attributes and methods from exactly one parent (base or superclass). It allows the subclass to reuse and extend functionality in a straightforward “is-a” relationship without the complexity of multiple base classes.
Multiple inheritance allows a subclass to inherit from more than one base class. This can enable rich reuse but also introduces challenges like the diamond problem. Some languages avoid it by using interfaces instead of full class inheritance.
Inheritance expresses an “is-a” relationship: the subclass *is a* more specialized version of its superclass. For example a Dog is a Mammal. Using correct relationship terminology helps in design and interview discussions.
Compile-time polymorphism (also called static binding) is achieved by method overloading – defining multiple methods with the same name but different parameter lists (or types). The compiler decides which method to call before runtime.
Runtime polymorphism (or dynamic binding) occurs when a base‐class reference points to a subclass object, and the subclass’s overridden method is invoked at runtime based on the actual object type.
When a base class reference holds a subclass object (Animal a = new Dog()), it demonstrates polymorphism: the code can treat various subclasses uniformly while each subclass exhibits its own behavior when methods are called.
Inheritance allows new classes to reuse existing functionality from base classes, reducing duplication and making maintenance easier. This is a major reason why inheritance is widely used in OOP design.
Inheritance allows a subclass to derive properties and behaviors from a superclass, creating a hierarchical relationship. Polymorphism lets code written for the superclass type work with subclass objects too. Together they enable flexibility: you define general behavior once in the superclass and let each subclass provide its own specific implementation, while using the same interface. For instance, you might have a base class `Vehicle` with a method `drive()`, and subclasses `Car`, `Bike`, `Truck` override `drive()` differently. With polymorphism you can write `Vehicle v = new Car(); v.drive();` and the correct method executes depending on the actual object type. This combination supports code reuse, extension and maintainability.
Inheritance can take many forms: *Single inheritance* where a class inherits from one base class; *Multilevel inheritance* where a class inherits from a class which itself inherits another; *Hierarchical inheritance* where multiple subclasses inherit from the same superclass; *Multiple inheritance* where a class inherits from more than one base class (allowed in some languages); and *Hybrid inheritance* which combines two or more of the above. For example, in Java you might have `class Dog extends Animal` (single), `class Puppy extends Dog extends Animal` (multilevel), `class Cat extends Animal` and `class Dog extends Animal` (hierarchical). Explaining language support and limitations—such as Java not supporting multiple inheritance of classes—shows strong interview readiness.
Method overloading (compile-time polymorphism) and method overriding (runtime polymorphism) are often confused but serve different purposes. Overloading lets multiple methods in the same class share a name but differ in parameter lists—useful when you want to provide multiple ways to call a method (for example `print(int)` and `print(String)`). Overriding means a subclass provides its own version of a method defined in a superclass. Overriding is used when you want to alter or extend behavior in derived classes (for example `class Bird { fly() }` and `class Penguin extends Bird { fly() { throw new CannotFlyException(); } }`). Showing when and why to use each is key for interviews.
Polymorphism enables flexibility and scalability in code by allowing objects of different types to be treated uniformly through a common interface. It supports extendability—new subclasses can be introduced without modifying existing code. It enhances maintainability by decoupling code from specific implementations, and encourages use of interchangeable components. Mentioning how polymorphism underpins design patterns and frameworks helps in interview discussions.
While inheritance offers reuse, it can also introduce tight coupling, fragility when base classes change, and violates encapsulation if subclass depends heavily on parent internals. Composition (‘has-a’ relationship) is often more flexible: you can change behaviour at run time by delegating to different components and avoid deep inheritance hierarchies. In interviews highlighting “favor composition over inheritance” demonstrates sound design sense.
Method overriding occurs when a subclass provides its own implementation of a method defined in its superclass, using the same signature. This enables runtime polymorphism – the correct method executes based on the object’s actual type.