Top 50 OOPs Interview Questions and Answers

OOPs Interview Questions and Answers

Object-oriented programming (OOP) is a programming approach that organizes software design around data, rather than functions and logic. It is a fundamental concept of programming. 

Major companies seek developers proficient in object-oriented approaches as well as patterns. So, if you are planning to appear for such an interview process, you must have an in-depth understanding of the OOP concepts. No matter whether you give the interview for a C++, Java, or Python developer, OOP questions will come to the surface. Hence, it's compulsory to get yourself prepared for the toughest of the OOP questions.

To help you in your journey, we've collected from various sources some of the commonly asked OOP questions and segregated them under basic, intermediate, and advanced category questions. If you've faced any other questions in the past or come across in the future, do comment and let us know. 

OOPs Interview Questions & Answers for Beginners

1. What do you understand by the term OOP?

OOPs is an acronym for Object Oriented Programming. It is a programming paradigm in which everything is represented as an object. OOPs, implement real-world entities in the form of objects. The main aim of OOP is to organize together the data and the functions that operate on them so that no other part of the program can access this data except that function.

2. What is a class in OOP?

Class is a collection of objects. It is like a blueprint for an object. It is the foundational element of object-oriented programming. An instance of a class is created for accessing its data types and member functions.

3. What is an object in OOP?

An object is a real-world entity having a particular behavior and a state. It can be physical or logical. An object is an instance of a class and memory is allocated only when an object of the class is created.

Example illustrating Classes and Objects in Different Programming Languages

       class MyClass:  # The class
    def __init__(self):  # Constructor
        self.num = 0  # Attribute (int variable)
        self.string = ""  # Attribute (string variable)

if __name__ == "__main__":
    obj = MyClass()  # Create an object of MyClass
    
    # Access attributes and set values
    obj.num = 25
    obj.string = "Welcome to ScholarHat"
    
    # Print attribute values
    print(obj.num)
    print(obj.string)

    

      public class MyClass { // The class
    public int num; // Attribute (int variable)
    public String string; // Attribute (string variable)
    
    public static void main(String[] args) {
        MyClass obj = new MyClass(); // Create an object of MyClass
        
        // Access attributes and set values
        obj.num = 25;
        obj.string = "Welcome to ScholarHat";
        
        // Print attribute values
        System.out.println(obj.num);
        System.out.println(obj.string);
    }
}

    

        
#include 
#include 

class MyClass {    // The class
public:             // Access specifier
    int num;      // Attribute (int variable)
    std::string string;  // Attribute (string variable)
};

int main() {
    MyClass obj;  // Create an object of MyClass

    // Access attributes and set values
    obj.num = 25; 
    obj.string = "Welcome to ScholarHat";

    // Print attribute values
    std::cout << obj.num << "\n";
    std::cout << obj.string;

    return 0;
}
    
    

Output

25
Welcome to ScholarHat   

Read more: Object Oriented Programming (OOPs) Concepts in C++

4. What are the differences between Structured Programming and Object Oriented Programming?

5. What are the main features of OOPs?

Below are the four main features of OOPs:

1. Inheritance
2. Encapsulation
3. Polymorphism
4. Data Abstraction

6. How is a class different from a structure?

7. List out a few advantages of using OOPs.

• Modularity: OOP promotes modularity by encapsulating data and methods into objects, facilitating easy maintenance and updates.
• Reusability: Objects can be reused in different parts of the program or other projects.
• Readability: OOP enhances code readability with a clear structure, making it easier for developers to understand and collaborate.
• Scalability: OOP accommodates the growth of software projects, allowing the creation of large, complex systems with manageable components.
• Flexibility: Polymorphism and inheritance provide flexibility, allowing the creation of versatile and adaptable code.
• Data abstraction: OOP hides complex implementation details through data abstraction, exposing only essential features for user interaction.
• Code maintenance: OOP simplifies code maintenance by isolating changes to specific objects or classes, reducing the risk of unintended consequences in other parts of the code.

8. What is encapsulation?

Encapsulation helps to wrap up the functions and data together in a single unit. By privatizing the scope of the data members it can be achieved. This particular feature makes the program inaccessible to the outside world.

Example illustrating Encapsulation

class MyClass {    // The class
public:             // Access specifier
    int num;      // Attribute (int variable)
    std::string string;  // Attribute (string variable)

   // class function
    void show_data() {
        // code
};    

In the above example, we bundled together the variables num, string, and the function show_data() into a class named MyClass. Encapsulation ensures that only member functions of a class can access its data, which results in data hiding.

9. What do you understand about Access Specifiers/Access Modifiers? What are their types?

Access specifiers define how the members (data members and member functions) of a class can be accessed. They allow us to determine which class members are accessible to other classes and functions, and which are not.

There are three access specifiers in object-oriented programming:

1. public
2. private
3. protected

These modifiers are crucial in achieving Encapsulation as they control the visibility of internal details and contribute to the overall security and organization of the code.

10. Explain the types of Access Modifiers in detail with examples.

1. Public Access Modifier: This employs a public keyword to create public members (data and functions). The public members are accessible from any part of the program i.e. from inside or outside the class.

   Example of public Access Specifier

   
   #include <iostream>
   using namespace std;
   class ScholarHat {
    public: // Public access specifier
    int x; // Public attribute
   
    void display() { //// Public method
    cout << "x = " << x << endl;
    }
   
   };
   
   int main() {
    ScholarHat myObj;
    myObj.x = 70; 
    myObj.display();
    return 0;
   }
   

   Run Code >>
   • Here, we have created a class named ScholarHat, which contains a public variable x and a public function display().
   • In main(), we have created an object of the ScholarHat class named myObj.
   • We then access the public elements directly by using the codes myObj.x and myObj.display().

   Output

   x = 70
   

2. Private Access Modifier: This employs a private keyword to create private members (data and functions). The private members can only be accessed from within the class.

   Example of private Access Specifier

   
   #include <iostream>
   using namespace std;
   class ScholarHat {
    private: // Private access specifier
    int y; //private attribute
    public: // Public access specifier
    int x; // Public attribute
   
    void display() { // Public method
    cout << "y = " << y << ", x = " << x << endl;
    }
   
   };
   
   int main() {
    ScholarHat myObj;
    myObj.x = 70; 
    myObj.y = 80
    myObj.display();
    return 0;
   }
   

   Run Code >>

   Here, y is a private member. It cannot be accessed outside the class. Therefore the program shows an error on compilation.

   Output

   prog.cpp: In function ‘int main()’:
   prog.cpp:18:9: error: ‘int ScholarHat::y’ is private within this context
    18 | myObj.y = 70;
    | ^
   prog.cpp:5:9: note: declared private here
    5 | int y; //private attribute
    | ^
   

3. Protected Access Modifier: This employs the protected keyword to create protected members (data and function). The protected members can be accessed within the class and from the derived class.

   Example of protected Access Specifier

   
   	class User {
   
   	protected int year = 2024;
   	protected void printYear()
   	{
   		System.out.println("Its " + year + " !!");
   	}
   
   	public static void main(String[] args)
   	{
   		User user = new User();
   		System.out.println(user.year);
   		user.printYear();
   	}
   }
   

   Run Code >>
   • The User class has a protected member variable year and a protected method printYear().
   • In the main method, we create an instance of the User class.
   • We can access the protected member variable year directly within the same package.
   • We call the printYear() method, which prints the value of the year variable. This method is accessible within the same package.

Read More: Access Modifiers in C++

11. Compare classes and objects in OOP.

12. What is meant by constructor?

A constructor is a special member function invoked automatically when an object of a class is created. It is generally used to initialize the data members of the new object. They are also used to run a default code when an object is created. The constructor has the same name as the class and does not return any value.

Example

MyClass obj = new MyClass();

In the above code, the method called after the “new” keyword - MyClass(), is the constructor of this class. This will help to instantiate the data members and methods and assign them to the object obj.

13. Explain the types of constructors in C++.

1. Default Constructor: It is a constructor in C++ with no parameters.

   Example of C++ Default Constructor

   
   #include <iostream> 
   using namespace std; 
   class Student {
   public:
    Student() {
    cout << "Default Constructor Invoked" << endl;
    }
   };
   
   int main() {
    Student s1; // Creating an object of Student class
    Student s2;
    return 0;
   } 

   Run Code >>

   The above C++ code in C++ Online Compiler has a default constructor named Student(). When the objects s1 and s2 of the Student class is created, the constructor Student() gets invoked and prints the statement written inside it

   Output

   Default Constructor Invoked
   Default Constructor Invoked
   

2. Parameterized Constructor: It is a constructor in C++ with parameters.

   Example of C++ Parametrized Constructor

   
   #include <iostream> 
   using namespace std;
   class Student {
   public:
    int id; // data member (also instance variable)
    string name; // data member (also instance variable)
    float marks;
   
    Student(int i, string n, float m) {
    id = i;
    name = n;
    marks = m;
    }
   
    void display() {
    cout << id << " " << name << " " << marks << " " << endl;
    }
   };
   
   int main() {
    Student s1 = Student(101, "Pradnya", 78); // creating an object of Student
    Student s2 = Student(102, "Pragati", 89);
    s1.display();
    s2.display();
    return 0;
   }
   

   Run Code >>

   Here the class Student has a parametrized constructor Student(int i, string n, float m). When the object s1 and s2 of the Student class is created, the constructor is called with arguments to initialize the data members of the class.

   Output

   101 Pradnya 78
   102 Pragati 89
   

3. Copy Constructor: A member function initializes an object's data members using another object from the same class. In other words, the copy constructor in C++ is used to copy data of one object into another.

   Example of C++ Copy Constructor

   
   #include <iostream> 
   using namespace std;
   class Student {
   public:
    int id; // data member (also instance variable)
    string name; // data member (also instance variable)
    float marks;
   
    Student(int i, string n, float m) { // parametrized constructor
    id = i;
    name = n;
    marks = m;
    }
   
    // Copy constructor with a Student object as a parameter
    // Copies data of the obj parameter
    Student(const Student& obj) {
    id = obj.id;
    name = obj.name;
    marks = obj.marks;
    }
   
    void display() {
    cout << id << " " << name << " " << marks << " " << endl;
    }
   };
   
   int main() {
    Student s1 = Student(101, "Pradnya", 78); // Creating an object of the Student class
    Student s2 = s1; // Copy contents of s1 to s2
    s1.display();
    s2.display();
    return 0;
   }
   

   Run Code >>

   In this program, we have used a copy constructor, Student(const Student& obj) to copy the contents of one object of the Student class to another.

   • The parameter of this constructor has the address of an object of the Student class.
   • We then assign the values of the variables of the obj object to the corresponding variables of the object by calling the copy constructor. This is how the contents of the object are copied.
   • The const in the copy constructor's parameter const Student& obj is used to ensure that the object being passed as an argument to the copy constructor is not modified within the copy constructor itself.
   • In main(), we then create two objects s1 and s2 and then copy the contents of s1 to s2.
   • The s2 object calls its copy constructor by passing the address of the s1 object as its argument i.e. &obj = &s1.

   Output

   101 Pradnya 78
   101 Pradnya 78
   

Read More: Constructors and Destructors in C ++

14. How is a constructor different from a method?

15. What is inheritance?

Inheritance in object-oriented programming (OOP) allows one class to inherit the attributes and functions of another. The class that inherits the properties is known as the child class/derived class and the main class is called the parent class/base class. This means that the derived class can use all of the base class's members as well as add its own. Because it reduces the need to duplicate code for comparable classes, inheritance promotes code reusability and maintainability.

Inheritance is an is-a relationship. We can use inheritance only if there is an is-a relationship between two classes.

In the above figure:

1. A car is a Vehicle
2. A bus is a Vehicle
3. A truck is a Vehicle
4. A bike is a Vehicle

Here, the Car class can inherit from the Vehicle class, the bus class can inherit from the Vehicle class, and so on.

Read More: What is Inheritance in Java

16. Explain the concept of a base class, subclass, and superclass.

1. Base Class: It is the class that other classes inherit from. The base class defines the attributes and methods that its derived classes inherit. In addition, the base class can specify its properties and methods. It is also known as the parent class.

   In the above-given figure, the Vehicle is the base class. It would have common properties like speed, color, and methods like start() and stop(). These properties and methods are typical for various types of vehicles.

2. Subclass: A subclass inherits the base class's properties and methods. The derived class can inherit all of the base class's attributes and methods or only a subset of them. The derived class may additionally include its own set of properties and methods. It is also known as the child class.

   In the above-given figure, the Car inherits from the Vehicle base class. Hence, the Car class will automatically have the properties and methods of the Vehicle class.

3. Superclass: A class from which other classes, called subclasses, inherit properties and behaviors. It is used as the base class for one or more derived classes.

   In the above-given figure, the Vehicle class is a superclass containing common vehicle properties and methods. Cars and Buses are subclasses, inheriting the properties and methods from the Vehicle class.

17. State the advantages of inheritance.

• Code Reusability: Inheritance allows you to create new classes that are based on existing classes, so you can reuse existing code and avoid rewriting the same functionality. This saves a lot of time and effort when you’re creating new programs.
• Organization: Inheritance helps you organize your code in a logical and structured way. You can create a hierarchy of related classes that makes it easy to understand how your code works and how different parts of your program are related.
• Polymorphism: Inheritance facilitates polymorphism, which allows you to treat objects of derived classes as objects of their base class, enabling you to write code that operates on base-class pointers or references but can work with objects of derived classes at runtime.
• Overriding: Inheritance allows you to override methods in a derived class, which means you can change the way a method works without changing the original code.
• Abstraction: Inheritance allows you to create abstract classes that define the basic behavior of a group of related classes while leaving the implementation details to the derived classes.

18. Describe Polymorphism.

Polymorphism is made up of two words, poly means more than one and morphs means forms. So, polymorphism means the ability to take more than one form. This property makes the same entities such as functions, and operators perform differently in different scenarios. You can perform the same task in different ways.

In the given figure, a person when a student pays his bills. After completing his studies, the same person becomes a millionaire and pays bills of various types. Here the person is the same and his functions are also the same. The only difference is in the type of bills.

19. List out the object-oriented programming languages.

• Java
• C++
• Python
• C#
• Ruby
• PHP
• TypeScript

20. How much memory does a class occupy?

Classes do not use memory. They merely serve as a template from which items are made. Now, objects initialize the class members and methods when they are created, using memory in the process.

Intermediate OOPs Interview Questions & Answers

21. Is it always necessary to create objects from class?

No, it is not always necessary to create objects from a class. A class can be used to define a blueprint for creating things, but it is not required to create an object from a class to use its methods or access its properties.

22. What are the different types of polymorphism?

There are two types of polymorphism. These are:

1. Compile time Polymorphism: In this, the compiler at the compilation stage knows which functions to execute during the program execution. It matches the overloaded functions or operators with the number and type of parameters at the compile time.

   The compiler performs compile-time polymorphism in two ways:

   1. Function Overloading: If two or more functions have the same name but different numbers and types of parameters, they are known as overloaded functions.
   2. Operator Overloading: It is function overloading, where different operator functions have the same symbol but different operands. And, depending on the operands, different operator functions are executed. The operands here are the user-defined data types like objects or structures and not the basic data types.
2. Runtime Polymorphism: In this, the compiler at the compilation stage does not know the functions to execute during the program execution. The function call is not resolved during compilation, but it is resolved in the run time based on the object type. This is also known as dynamic binding or late binding. This is achieved through function overriding.
   1. When you redefine any base class method with the same signature i.e. same return type, number, and type of parameters in the derived class, it is known as function overriding.

Read More: Polymorphism in Java: Compile-Time and Runtime Polymorphism

23. Differentiate between static and dynamic binding.

24. Explain the virtual function and pure virtual function.

A virtual function is a member function of a class, and its functionality can be overridden in its derived class. A virtual function can be declared using a virtual keyword in C++. In Java, every public, non-static, and non-final method is a virtual function. Python methods are always virtual.

Example of a virtual function

#include 

class Base {
public:
    // Virtual function
    virtual void display() {
        std::cout << "Display from Base class" << std::endl;
    }
};

class Derived : public Base {
public:
    // Override virtual function
    void display() override {
        std::cout << "Display from Derived class" << std::endl;
    }
};

int main() {
    // Base class pointer pointing to a Derived class object
    Base* ptr = new Derived();

    // Call the virtual function
    ptr->display();

    delete ptr; // Freeing allocated memory
    return 0;
}
        

The derived class Derived overrides the display() function. In the main() function, we create a pointer of type Base that points to a Derived object. When we call ptr->display(), the overridden function in Derived is invoked due to dynamic polymorphism.

Output

Display from Derived class
        

Pure Virtual Function: It is a do-nothing virtual function declared in the base class with no definition relative to the base class. A base class containing the pure virtual function cannot be used to declare the objects of its own. Such classes are known as abstract base classes.

The main objective of the base class is to provide the traits to the derived classes and to create the base pointer used for achieving the runtime polymorphism.

Example of a pure virtual function

// Abstract class with abstract method
abstract class Shape {
    // Abstract method (no implementation)
    abstract void draw();
}

// Concrete subclass implementing the abstract method
class Circle extends Shape {
    // Implementation of the abstract method
    void draw() {
        System.out.println("Drawing a circle");
    }
}

// Subclass implementing the abstract method
class Rectangle extends Shape {
    // Implementation of the abstract method
    void draw() {
        System.out.println("Drawing a rectangle");
    }
}

public class Main {
    public static void main(String[] args) {
        // Creating objects of subclasses
        Shape circle = new Circle();
        Shape rectangle = new Rectangle();

        // Calling the draw method on objects of concrete subclasses
        circle.draw();
        rectangle.draw();
    }
}
        

There's an abstract class Shape with an abstract method draw(). We then have two subclasses Circle and Rectangle, each implementing the draw() method with their specific implementation. In the main method, we create objects of the subclasses, circle, and rectangle, and call the draw() method on them. The specific implementation of the draw() method for each subclass is invoked based on the object's runtime type.

Output

Drawing a circle
Drawing a rectangle    

Read More: Virtual Functions in C++

25. What is Abstraction?

Abstraction means providing only the essential details to the outside world and hiding the internal details, i.e., hiding the background details or implementation. Abstraction is a programming technique that depends on the separation of the interface and implementation details of the program.

26. What is an interface?

An interface refers to a special type of class, which contains methods, but not their definition. Only the declaration of methods is allowed inside an interface. To use an interface, you cannot create objects. Instead, you need to implement that interface and define the methods for their implementation.

Example of interface implementation

// Define the interface
interface Animal {
  public void makeSound();
}
// Define a class that implements the interface
class Cat implements Animal {
  public void makeSound() {
    System.out.println("Meow");
  }
}
// Define another class that implements the interface
class Dog implements Animal {
  public void makeSound() {
    System.out.println("Woof");
  }
}
// Test the interface and the classes that implement it
public class InterfaceExample {
  public static void main(String[] args) {
    Animal myCat = new Cat();
    Animal myDog = new Dog();
    myCat.makeSound();
    myDog.makeSound();
  }
}

This example in the Java Online Editor shows how to use the "Animal" interface and its two implementing classes, "Cat" and "Dog." It enables the "makeSound()" method, which prints out the corresponding noises "Meow" and "Woof" when called in the "main" method, to be called by objects of these types.

Output

Meow
Woof

Read More: Interfaces and Data Abstraction in C++

27. How is an Abstract class different from an Interface?

Read More: Abstract Class in Java: Concepts, Examples, and Usage

28. Describe the use of the super keyword.

super keyword in Java is used to identify or refer to parent (base) class.

• We can use super to access the superclass constructors and call methods of the superclass.
• When method names are the same in the superclass and subclass, the super keyword refers to the superclass.
• To access the same name data members of the parent class when they are present in parent and child class.
• Super can be used to make an explicit call to no-arg and parameterized constructors of the parent class.
• Parent class method access can be done using super when the child class has a method overridden.

class DotNetTricks {
    public void print() { // overridden function
        System.out.println("Welcome to DotNetTricks");
    }
}

class ScholarHat extends DotNetTricks {
    @Override
    public void print() { // overriding function

   // call method of the superclass
    super.print();
        System.out.println("Welcome to ScholarHat");
    }
}

public class Main {
    public static void main(String[] args) {
        ScholarHat obj1 = new ScholarHat();

        // Call the print() function 
        obj1.print();
    }
}

Here, the super keyword in the Java Online Editor is used to call the print() method present in the superclass.

Output

Welcome to DotNetTricks
Welcome to ScholarHat

Read More: What is Inheritance in Java: Types of Inheritance in Java

29. What is a friend function in C++?

A friend function is a friend of a class that is allowed to access public, private, or protected data in that same class without being a member of that class. They are the non-member functions that can access and manipulate the private and protected members of the class for they are declared as friends.

A friend function can be:

1. A global function
2. A member function of another class

#include 

class MyClass;

// Declaration of the friend function
void display(const MyClass& obj);

class MyClass {
private:
    int num;
public:
    MyClass(int n) : num(n) {}

    // Declare the friend function as a friend
    friend void display(const MyClass& obj);
};

// Definition of the friend function
void display(const MyClass& obj) {
    std::cout << "Friend function: The value of num is " << obj.num << std::endl;
}

int main() {

    MyClass obj(42);

    // Call the friend function
    display(obj);

    return 0;
}

• Here, the class MyClass has a private member variable num.
• The friend function display() takes a MyClass object as a parameter. This function is declared as a friend of the MyClass class, giving it access to the private members of MyClass.
• Inside the display function, we can access the private member num of the MyClass object.
• In the main function, we create an object of MyClass and call the display function, passing the object as an argument.

Output

Friend function: The value of num is 42

30. What are some other programming paradigms other than OOPs?

• Functional Programming: This emphasizes using functions and immutable data to solve problems.
• Procedural Programming: This emphasizes breaking a program into small procedures or functions to improve readability and maintainability.
• Logic Programming: This emphasizes using logic and mathematical notation to represent and manipulate data.
• Event-driven Programming: This emphasizes handling events, and the control flow is based on the events.

31. Distinguish between Method Overloading and Method Overriding.

32. Is Operator overloading supported in Java?

No, operator overloading is not supported in Java. Unlike languages like C++ where you can redefine the behavior of operators for user-defined types, Java does not allow you to overload operators.

In Java, operators such as +, -, *, /, etc., have predefined meanings for built-in types (like int, double, String, etc.), and you cannot change their behavior for your custom classes or types. Instead, Java provides methods (such as toString(), equals(), compareTo(), etc.) and operator-like methods (such as + for concatenating strings) to achieve similar functionality.

33. How will you differentiate a class from an interface?

34. What are the operators that cannot be overloaded?

Following are the operators that cannot be overloaded:

• Scope Resolution (::)
• Member Selection (.)
• Member selection through a pointer to function (.*)

35. Is it possible for the static method to use nonstatic members?

In Java, a static method cannot directly access or use non-static (instance) members of a class. This is because static methods are associated with the class itself, rather than with instances of the class. Non-static members, on the other hand, belong to individual instances of the class and require an object reference to be accessed.

Advanced OOPs Interview Questions & Answers for Experienced

36. What is meant by Garbage Collection in OOPs?

Object-oriented programming revolves around entities like objects. Each object consumes memory and there can be multiple objects of a class. So if these objects and their memories are not handled properly, then it might lead to certain memory-related errors and the system might fail.

Garbage Collection (GC) is an automatic memory management process in programming languages. It involves identifying and reclaiming memory occupied by objects no longer in use by the program. Instead of requiring manual memory deallocation, which can lead to memory leaks and bugs, GC tracks and frees up memory occupied by objects that are no longer reachable or referenced in the program.

37. Why new keyword is used in Java?

When we create an instance of the class, i.e. objects, we use the Java keyword new. It allocates memory in the heap area where JVM reserves space for an object. Internally, it invokes the default constructor as well.

Syntax

Class_name obj = new Class_name();

38. Explain hybrid and hierarchical inheritance.

1. Hybrid Inheritance: It is the combination of more than one type of inheritance i.e. hybrid variety of inheritance.

   

   Example to demonstrate hybrid inheritance

   
   #include <iostream>
   using namespace std;
   
   class Birds {
   public:
    Birds() {
    cout << "Birds are of two types" << endl;
    }
   };
   
   class Oviparous : public Birds {
   public:
    Oviparous() {
    cout << "Oviparous birds lay eggs." << endl;
    }
   };
   
   class Sparrow {
   public:
    void name2() {
    cout << "I am a sparrow." << endl;
    }
   };
   
   class HybridSparrow : public Oviparous, public Sparrow {
   public:
    void display() {
    name2();
    cout << "HybridSparrow class is a combination of Oviparous and Sparrow." << endl;
    }
   };
   
   int main() {
    HybridSparrow h1;
    h1.display();
    return 0;
   }
   

   Run Code >>
   • In the above code in C++ Online Compiler, class Oviparous inherits from class Birds. This is a single inheritance.
   • The class HybridSparrowinherits from both classOviparous and class Sparrow. This is multiple inheritance.
   • The Oviparousclass inheritsBirdsclass which is further inherited by theHybridSparrowclass. This is a multilevel inheritance.

   Output

   Birds are of two types
   Oviparous birds lay eggs.
   I am a sparrow.
   HybridSparrow class is a combination of Oviparous and Sparrow.
   

2. Hierarchical Inheritance: If more than one derived class inherits a single base class, a hierarchy of base classes is formed and so it is known as hierarchical inheritance.

   

   Example to demonstrate hierarchical inheritance

   
   #include <iostream>
   using namespace std;
   class Birds {
    public:
    void type() {
    cout << "I'm an oviparous bird" << endl;
    }
   };
   
   class pigeon: public Birds{
    public:
    void name1() {
    cout << "I am a pigeon." << endl;
    }
   };
   
   class Sparrow: public Birds {
    public:
    void name2() {
    cout << "I am a sparrow." << endl;
    }
   };
   
   int main() {
    pigeon p; // object of pigeon class
    cout << "\npigeon Class:" << endl;
    p.type(); // base class method
    p.name1();
   
    Sparrow h; // object of Sparrow class
    cout << "\nSparrow Class:" << endl;
    h.type(); // base class method
    h.name2();
   
    return 0;
   } 

   Run Code >>

   Here, both the pigeon and Sparrow classes are derived from the Birds class. As such, both the derived classes can access the type() function belonging to the Birds class.

   Output

   pigeon Class:
   I'm an oviparous bird
   I am a pigeon.
   
   Sparrow Class:
   I'm an oviparous bird
   I am a sparrow.
   

Read More:

• Inheritance in C++ with Modifiers
• Hierarchical Inheritance in Java

39. What is an inline function?

An inline function is a particular type of function in programming where the code from the function is inserted directly into the calling code instead of having a separate set of instructions in memory. It reduces overhead and allows for better optimization.

40. What are errors and what are exceptions? Differentiate between them.

Exceptions are runtime errors. Many a time, your program looks error-free during compilation. But, at the time of execution, some unexpected errors or events or objects come to the surface and the program prints an error message and stops executing.

Errors represent serious system or hardware failures, typically leading to program termination, and are usually beyond the program’s control.

Differences between Errors and Exceptions

41. How does Java implement multiple inheritance?

Multiple inheritance is not supported by Java using classes. To achieve multiple inheritance in Java, we must use the interface. Interfaces ensure that classes follow predetermined behaviors by defining method contracts without implementing them.

Example

// Define two interfacesinterface Animal {
  void eat();
  void sleep();
}interface Bird {
  void fly();
}// Create a class that implements both interfaces
class Sparrow implements Animal, Bird {
  @Override
  public void eat() {
    System.out.println("Sparrow is eating.");
  }  @Override
  public void sleep() {
    System.out.println("Sparrow is sleeping.");
  }  @Override
  public void fly() {
    System.out.println("Sparrow is flying.");
  }
}public class Main {
  public static void main(String[] args) {
    Sparrow sparrow = new Sparrow();
    sparrow.eat(); // Calls the eat() method from the Animal interface
    sparrow.sleep(); // Calls the sleep() method from the Animal interface
    sparrow.fly(); // Calls the fly() method from the Bird interface

  }

}

The "Animal" and "Bird" interfaces are defined in this code, along with the class "Sparrow," which implements both interfaces. The 'eat()','sleep()', and 'fly()' methods are implemented by the 'Sparrow' class. It generates a "Sparrow" object and invokes its methods in the "main" method to show multiple inheritance through interfaces.

Output

Sparrow is eating.
Sparrow is sleeping.
Sparrow is flying.

Read More: Multiple Inheritance in Java

42. Explain the difference between abstract class and method.

43. Distinguish encapsulation from abstraction.

44. What is the use of the finalize method?

The finalize method helps to perform cleanup operations on the resources that are not currently used. The finalize method is protected, and it is accessible only through this class or by a derived class.

45. Can a Java application be run without implementing the OOPs concept?

No. Java applications are based on Object-oriented programming models or OOPs concept, and hence they cannot be implemented without it.

46. What are the differentiating points between extends and implements?

47. Is Java a pure Object Oriented language?

Java is not an entirely pure object-oriented programming language. The following are the reasons:

• Java supports and uses primitive data types such as int, float, double, char, etc.
• Primitive data types are stored as variables or on the stack instead of the heap.
• In Java, static methods can access static variables without using an object, contrary to object-oriented concepts.

48. Can you create an instance of an abstract class?

No, an instance of the Abstract class cannot be created.

However, you can create an instance of a concrete subclass that extends the abstract class. This concrete subclass must provide implementations for all the abstract methods defined in the abstract class. Then you can create an instance of this subclass.

abstract class AbstractClass {
    abstract void abstractMethod(); // Abstract method
}

class ConcreteClass extends AbstractClass {
    void abstractMethod() {
        System.out.println("Implementation of abstractMethod in ConcreteClass");
    }
}

public class Main {
    public static void main(String[] args) {
        // AbstractClass obj = new AbstractClass(); // Error: Cannot instantiate abstract class
        ConcreteClass obj = new ConcreteClass(); // Creating an instance of ConcreteClass
        obj.abstractMethod(); // Calling the implemented method
    }
}

Here,

• AbstractClass is an abstract class with an abstract method abstractMethod().
• ConcreteClass is a concrete subclass of AbstractClass that provides an implementation for the abstractMethod().
• In the main method, we create an instance of ConcreteClass, which is allowed because it provides implementations for all abstract methods defined in AbstractClass.

49. What are manipulators?

Manipulators are the functions that can be used in conjunction with the insertion (<<) and extraction (>>) operators on an object. Examples are endl and setw.

50. Define the term 'composition' in OOP.

Composition in Object-Oriented Programming refers to a design principle where a class includes instances of other classes to add functionality or behavior. This "has-a" relationship allows for flexible and reusable code.

Summary

So here we saw in depth almost all the important OOP interview questions and answers from a basic to advanced level. Go through it before going for your interview.

Take our free skill tests to evaluate your skill!

In less than 5 minutes, with our skill test, you can identify your knowledge gaps and strengths.

GET TEST NOW