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
Interfaces & Abstract Classes interview questions for placements and exams.
Questions
11
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.
An interface defines a set of methods (and sometimes constants) that implementing classes must provide. It describes what behaviour a class must offer without specifying how that behaviour is implemented. This enables loosely-coupled design and polymorphism.
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.
In Java, a class uses extends to inherit from a superclass (including an abstract class) and uses implements to implement an interface. This difference is key in object-oriented design.
Java does not allow a class to extend more than one class, so you cannot have multiple class inheritance. However, a class can implement many interfaces, enabling multiple behaviour inheritance. This distinction is important for designing flexible APIs.
An abstract class is useful when you have related classes that share common behaviour and some common code, as well as some methods you want subclasses to implement. Interfaces are about defining a contract, not sharing implementations.
From Java 8 onwards, interfaces may include default and static methods with implementations, allowing them to evolve over time without breaking existing implementations. This blurred the line between interfaces and abstract classes.
Even though you cannot instantiate an abstract class directly, it can have a constructor which is called when a subclass is instantiated. This lets the abstract class initialize data common to all subclasses.
In Java interfaces, variables are implicitly public, static and final (constants). They cannot be instance variables that vary per object.
Interfaces provide abstraction by declaring methods without implementing them, allowing multiple classes to implement the same interface in their own way. This means you can write code that works with the interface type without knowing the concrete class implementation. For example, an interface `PaymentMethod` might define `processPayment(amount)`. Then classes `CreditCardPayment`, `PaypalPayment`, and `CryptoPayment` implement that interface. Your checkout module can depend on `PaymentMethod`, not concrete classes, enabling flexibility and easier substitution.
In a plugin architecture you may define an interface `PluginModule` with methods like `initialize()` and `execute()`. This sets the contract for all modules. If some modules share common initialization code or data fields, you could provide an abstract class `BasePlugin` which implements `PluginModule` and offers default implementation of common logic. Then each concrete plugin class extends `BasePlugin`. This setup uses the interface for flexibility and abstract class for code reuse. Such hybrid designs are often expected in senior-level interviews.
An abstract class serves as a base class that cannot be instantiated on its own. It may define some methods with implementation and leave others abstract for subclasses to override. This allows code reuse and enforcement of certain behaviours.
Abstract classes and interfaces both support abstraction but differ in their use. An abstract class can include implemented methods, instance variables, constructors, and allows controlled inheritance; while an interface primarily defines a contract and supports multiple implementation. You would choose an abstract class when you have shared code among related classes and you want to enforce a base type. Use an interface when you want unrelated classes to share a capability or when you need multiple inheritance of behaviour. For example, you might have `Vehicle` as an abstract class with implementation for start() and stop(), and `Flyable` as an interface for anything that can fly. A `Car` class extends `Vehicle`, while `Helicopter` extends `Vehicle` and implements `Flyable`. This design shows when you pick each.