Home

Learning Hub

Articles

Top OOPs Interview Questions and Answers 2024

In today’s world, we do not have to worry about finding an approach to design software and maintaining its standard procedures and robustness. All thanks to object-oriented programming because it brings a structured approach to the coding industry and a revolution in programming techniques that we are familiar with. Without it, we cannot comprehend anything about a perfect solution to all basic limitations in programming. Hence, OOP is one of the subjects most frequently asked about in any coding interview.

In this article, we have discussed top OOP interview questions and answers with examples for 2024. You will get an idea about frequently asked OOP interview questions along with some advanced questions and problem-solving coding questions that will help you prepare for the interview.

Frequently Asked OOPs Interview Questions

1. What is Object Oriented Programming?

It is a programming model based directly upon the concept of “objects”. Objects refer to anything you assume, like any certain object used in a game while conducting game development. For example, game characters and many other objects that repeat themselves. Hence, we can reuse those components again and again with a minimal amount of code. There are many OOP methods, such as reusability, abstraction, polymorphism, etc.

2. What is the difference between OOP and SOP?

3. What is the function of a super keyword?

The super keyword is used to call the constructor method of the parent class from the base class. It is also used to refer to the methods of the parent class that are overridden in the base class.

4. What is a class?

A class in OOP can be represented as a blueprint for creating different objects. Those objects will further help in reusability and abstraction. An OOP class possesses different properties (attributes) and Behaviours (methods) that all the objects present in that class would have.

5. What is an object?

An object will act as an instance of a defined class. Hence object refers to any real-world entity and that entity will have its own properties and attributes. To create a complex system that has a huge amount of encapsulated data, objects play a very crucial role.

6. Define a subclass and a superclass.

When there are many multiple objects or particularly multiple classes, then superclass and subclass help to define which property of other classes is inherited by our new class. A superclass (parent class) is a class that is extended or inherited by other classes. Hence, a superclass’s properties are shared by those other classes. While a subclass (child class) inherits different methods and attributes from its superclass, along with its own individual attributes.

7. What are Getters and Setters?

Getters and setters are used to access and modify the private fields of a class, like private names, data types, values, or any kind of attributes. Getters try to retrieve the value of a field while setters update those values.

Here is a C++ code to understand more about how they are used:

class Person {

private:

string name;

int age;

public:

string getName() {

return name;

}

void setName(string newName) {

name = newName;

}

};

8. What are the types of variables in OOP?

There are several types of variables in OOP which can be categorised on their scope and lifetime:

• Instance Variables (non-static variables): Defined inside a class but outside any method, and each object of the class will have its own copy of instance variables.
• Class Variables (static variables): Declared with the ‘static’ keyword within a class.
• Local Variables: These can be declared inside a method or code block and accessible within
• Parameter Variables: These are local to a method or function and can be used to receive arguments from the caller.
• Constants: generally declared using the ‘final’ keyword in Java or ‘const’ in C++, whose values cannot be changed once assigned.

9. What is the difference between a class and a structure?

10. What is the difference between a class, method and an object?

11. What are the different types of inheritance?

1. Single inheritance: A class that inherits from only one base class.
2. Multiple inheritance: This class inherits from multiple base classes.
3. Multilevel inheritance: Class that inherits from a derived class, creating a chain of inheritance.
4. Hierarchical inheritance: Multiple classes inherited from a single base class.
5. Hybrid inheritance: a combination of two or more types of inheritance.

12. What is the difference between multiple and multilevel inheritance?

13. Differentiate between overloading and overriding.

class Dog : public Animal { void makeSound() { … } }

14. What is garbage collection in OOP?

This is the process where the programming language automatically deallocates the unused memory that is no longer needed or reachable by the program. It helps to manage memory in a more efficient manner, preventing memory leaks and boosting overall performance.

15. What are some commonly used object-oriented programming languages?

Some of the commonly used OOP languages are:

• Java
• C++
• C#
• Python
• Ruby
• PHP
• JavaScript
• Swift
• Scala
• Kotlin

19. How is an abstract class different from an interface?

20. Differentiate between data abstraction and encapsulation.

21. Why is it important to use design patterns in software development?

Design patterns are important in providing proven solutions to common design problems in software development. There are many different specific design patterns that use OOP concepts like reusability, maintainability, scalability, etc., while also improving the quality and efficiency of the overall software program.

22. What is Cohesion in OOP?

Cohesion refers to the measurement of how focused and tightly related responsibilities of a single module or class are. High cohesion means that the object class or particular module has only one dedicated task, while low cohesion means there are multiple unrelated tasks/responsibilities of that class.

23.  What are the different types of Polymorphism?

The two main types of polymorphism are:

• Compile-time (static) polymorphism: This is done using function overloading and operator overloading. The compiler defines which function or operator to call based on the arguments given at compile time.

• Run-Time (dynamic) polymorphism: By using method overriding in case the specific implementation of a method is given at runtime, based on the actual type of called object, the run-time polymorphism is achieved.

24. What is the Liskov Substitution Principle (LSP)? How does it relate to inheritance and polymorphism?

LSP states that the objects of a superclass must be replaceable with the objects of its subclasses, and it should not affect the correctness of the program. Hence a subclass should be able to substitute for its superclass without changing the overall behaviour of the program.

It is closely related to inheritance and polymorphism because, in inheritance, a new class (subclass) is created from the existing superclass, and on the other hand, polymorphism allows different class objects to be treated as a common superclass. LSP ensures that subclasses adhere to superclasses by enabling polymorphic substitution, creating a strong relationship between classes in an inheritance hierarchy.

25. How much memory does a class occupy?

The memory occupied depends on the size of its instance variables, methods and any additional functions in inheritance. Moreover, the exact memory usage by a class can vary based on the compilers used and the programming language itself.

26. What are the advantages and disadvantages of OOPs?

27. What is a Constructor, and what is a destructor? Also, mention types of constructors.

A special type of method in a class that can be automatically called during object creation is called a constructor. There are many types of constructors, such as parameterised constructors, copy constructors, default constructors, and constructor overloading.

On the other hand, a destructor is a method that is called when the object has gone out of scope or completely destroyed. Hence it is used to free resources, like memory or file handles. Generally, there is only one type of destructor. However, in some languages like C++, the concept of “virtual destructor” exists.

28. Can we overload the constructor or destructor in a class?

Yes, this can be done in many languages, like C++ and Java. In Java, overloading constructors is done to create objects with different initialisations or behaviours. But Java does not have destructors in the same manner as C++, as Java has automatic garbage collection.

In C++, constructor overloading allows the creation of objects in different initialisations, along with overloading destructors. Destructor overloading is not recommended due to the automatic and volatile nature of destructor calls.

29. What is pure virtual function?

A pure virtual function is declared in a base class but has zero implementation. It can be done using the ‘virtual’ keyword and assigning the value 0 to it. Classes that contain pure virtual functions are abstract classes and cannot be instantiated. Hence, subclasses must override pure virtual functions to provide implementations.

30. What is the difference between shallow copy and deep copy? When would you use each?

Shallow copy is used to copy the reference to objects so that objects are not duplicated by themselves. A deep copy creates a new copy of the object itself and all its elements. We can use shallow copy when we want to duplicate an object’s references. Using deep copy signifies complete duplication of an object along with its elements.

31. What is the purpose of the ‘this’ keyword?

It is generally used to refer to the current object instance, primarily to access the method or variable of the current object and also to showcase the difference between class attributes and method parameters with the same name.

Code-based Practical OOP Interview Questions

32. Implement an abstract class in C++ with an abstract method.

Program:

#include <iostream>

using namespace std;

class AbstractClass {

public:

virtual void abstractMethod() = 0; // Pure virtual function

};

class ConcreteClass : public AbstractClass {

public:

void abstractMethod() {

cout << “Implementation of abstractMethod” << endl;

}

};

int main() {

ConcreteClass obj;

obj.abstractMethod();

return 0;

}

33.  Create a class that uses composition to create a “has-a” relationship with another class in Python.

Program:

class Engine:

def start(self):

print(“Engine started”)

def stop(self):

print(“Engine stopped”)

class Car:

def __init__(self):

self.engine = Engine()

def start(self):

print(“Car starting…”)

self.engine.start()

def stop(self):

print(“Car stopping…”)

self.engine.stop()

# Create a Car instance

car = Car()

# Use the Car’s start and stop methods

car.start()

car.stop()

34. Implement a Singleton class in Java.

Solution Program:

public class Singleton {

private static Singleton instance = new Singleton();

private Singleton() {}

public static Singleton getInstance() {

return instance;

}

}

35. Predict the output of the following

Question Program:

class Animal {

public void makeSound() {

System.out.println(“Animal makes a sound”);

}

}

class Dog extends Animal {

@Override

public void makeSound() {

System.out.println(“Dog barks”);

}

}

public class Main {

public static void main(String[] args) {

Animal animal = new Dog();

animal.makeSound();

}

}

Output: Dog Barks

Explanation: The ‘makeSound’ method of the ‘Dog’ class overrides the method of the ‘Animal’ class, invoking the method of the ‘Dog’ class due to dynamic method dispatch – a feature of polymorphism.

36. One of the key OOP interview questions could be to give a real-life example of data abstraction.

You can give one real-life scenario by taking the example of the car dashboard. In that, the dashboard shows essential info like fuel, speed, and temperature without revealing complex internal mechanisms. The driver interacts easily with simplified controls, allowing users to operate the vehicle without needing to understand its inner workings. Hence abstracting away the complex internal functions, which are time-consuming and difficult to understand.

37. Can we run a Java application without implementing the OOPs concept?

Yes, you can run a Java application by using procedural programming. Java supports procedural code, which allows the use of static methods and variables within a single class containing the ‘main’ method.

38. Describe how you would refactor a legacy system to incorporate appropriate design patterns for better maintainability

To do this, first find the areas with tightly coupled code, which is unstructured and may contain possible errors. Design patterns like Singleton for shared resources can be used. Along with it, design patterns like Factory for object creation, Strategy for interchangeable behaviours, etc., can be done.

39. Can you discuss the trade-offs between using a design pattern and not using it?

By using a design pattern, you can get information about the maintainable and scalable code, commonly changing code, which may contain possible problems. However, changing it can also introduce more complexity to the project, especially when the code is not properly understood.

Not using a design pattern can also result in ad-hoc solutions that are even harder to maintain and extend in long-term projects.

40. Name three operators in C++ that can’t be overloaded.

1. Member Selection Operator(.)
2. Pointer to Member Selection Operator(->)
3. Scope Resolution Operator(::)
4. Sizeof Operator

Interview Questions on Common OOP Design Patterns and Problems

41. Can you name some of the common design patterns?

1. Factory Method Pattern
2. Observer Pattern
3. Strategy Pattern
4. Singleton Pattern
5. Decorator Pattern
6. Adapter Pattern
7. Composite Pattern
8. Template Method Pattern
9. Command Pattern

42. Can you explain the difference between structural, creational, and behavioural design patterns?

43. What is a final block?

A final block is used in Java within a try-catch-finally statement to always execute the code without any errors. Whenever any error comes, code is executed regardless if it throws out an exception or not.

44. How can you handle situations where there are too many observers in the Observer pattern?

To handle situations like this, you can consider the following approaches:

1. Reduce the number of notifications (only relevant changes)
2. Using a mediator that manages observers and reduces direct coupling between subjects and observers
3. Batch updates regularly
4. Using a different pattern also helps, such as the Pub/Sub (Publisher/Subscriber) pattern, to handle large numbers of subscribers more efficiently.

45. How can you ensure that a Singleton class is thread-safe?

Here to ensure that a singleton class is thread-safe, you can take the help of synchronisation techniques like the double-checked locking or synchronised method to control access to the instance creation method.

Exception Handling Questions in OOPs Interview

46. What is the difference between an error and an exception?

47. What is a try/catch block?

It is used to handle exceptions in Java. The code which possibly throws an exception is placed in the try block, and the catch block is used to output the exception if it occurs.

Program:

try {

int result = 10 / 0; // This will throw an ArithmeticException

} catch (ArithmeticException e) {

System.out.println(“An error occurred: ” + e.getMessage());

}

48. List down the limitations of Object-Oriented Programming.

The following can be the limitations of OOP:

• Overloading and Performance Overhead
• Difficulty in Modelling real-world systems
• Not suitable for all types of problems
• May end up being very complex designs
• Steeper learning curve

49. Explain the difference between checked and unchecked exceptions in Java.

50. Are there any limitations on Inheritance?

Yes, some of the limitations are:

1. Tight Coupling: Inheritance can sometimes create tight coupling between classes, hence making the code harder to refactor and maintain.
2. Inherited Members: Those derived classes inherit all members of the base class, including very unnecessary ones also which can lead to confusion and overall performance can be impacted.
3. Limited to Single Inheritance: Some of the languages support single inheritance, and flexibility is greatly affected.
4. Fragile Base Class Problem: If you want to make changes to the base class, you must require modifications to all derived classes, which can be error-prone and time-consuming
5. Inheritance Depth: Deep inheritance hierarchies sometimes become very complex and difficult to understand, again time-consuming and leading to maintenance challenges.

Final Thoughts

In conclusion, these interview questions will help you find out the true nature of interview rounds and what type of questions can be asked. Preparation in each sub-field is necessary to easily answer all the interview questions.