Object Oriented Programming interview questions can help programmers and developers enhance their knowledge of key concepts in the programming world.
OOP is one of the most necessary and needful programming paradigms, focusing on objects and classes instead of procedures and functions.
Some OOP-based programming languages are Objective-C, Java, Ada, Perl, Python, C , and more.
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.
Let’s look at some of the frequently asked OOP interview questions and answers to help you prepare for interviews and tests.
Object Oriented Programming (OOP): An Overview
OOP is a programming paradigm that revolves around objects. Here, the objects are considered as real-world instances, like a class that includes some behaviors and characteristics specified in the class template.
For example, let’s consider a car. According to the OOPs model:
- Object: A car. It can be of any type or model, such as the car you own.
- Class: The car’s model or type, such as BMW, Chevrolet, Kia, Audi, and more.
- Characteristics: Color of the car, chassis number of the car, engine type, gear type, and more.
- Behavior: How to change the gear, how to start the car, and more.
Here, characteristics are also known as properties, attributes, or data, whereas behaviors are known as procedures, methods, or functions in programming languages.
So, let’s start with some frequently asked OOP interview questions.
What is meant by the term OOPs?
Answer: Object Oriented Programming (OOP) is a programming model based on objects and classes instead of procedures and functions. Individual objects are arranged into classes. OOPs describes real-world entities with concepts like polymorphism, hiding, inheritance, etc., and programming paradigms.
OOPs bind code and data together. Objects are real-world entities defined via classes with specific characteristics and behavior, whereas a class is defined as the pattern for a specific object. It is also known as a user-defined datatype.
This includes programs for design and manufacturing along with the mobile application. For example, you can use OOP for manufacturing system simulation software.
What are some other programming paradigms than OOPs?
Answer: Programming paradigms are the method of categorizing programming languages based on each language’s feature. There are two types of programming paradigms:
- Imperative Programming Paradigm: It focuses on how to execute logic and defines the control flow. It includes the Procedural Programming Paradigm, Object Oriented Programming (OOP), and Parallel Programming.
- Declarative Programming Paradigm: It focuses on what to execute in the program and defines its logic, not the control flow. It includes the Logical Programming Paradigm, Functional Programming Paradigm, and Database Programming Paradigm.
What is the difference between OOP and SOP?
Answer: Let’s understand the difference between OOP and SOP with this table:
| Object Oriented Programming | Structure Oriented Programming |
| It is a programming model based on objects instead of procedures and functions. | It provides a logical structure to the program, where the programs are divided into functions. |
| Follows a bottom-up approach | Follows a top-down approach |
| Provides data hiding or encapsulation | It doesn’t provide data hiding |
| It can solve complex problems. | It can solve moderate problems. |
| Low redundancy as code can be used again | It doesn’t support code reusability. |
| More flexible | Less flexible |
| Its primary concern is data. | Its primary concern is the logical structure of a program. |
What are the main features of OOPs?
Answer: Here are the main features of OOPs:
- Inheritance
- Encapsulation
- Abstraction
- Polymorphism
- Method overriding
- Method overloading
- Objects
- Classes
- Constructors and destructors
Inheritance, polymorphism, and encapsulation are the fundamental elements of OOP that differentiate these features from non-OOP languages.
What is encapsulation?
Answer: Encapsulation is a method of putting class, variables, methods, and more inside a capsule that is required to do the work and present the same capsule to the user. In simple terms, all the necessary methods and data are put together, and the unnecessary details are hidden from the users.
It can also be defined in other ways:
- Data binding: Encapsulation is a process of binding data members along with the methods together as a class or as a whole.
- Data hiding: Encapsulation is a process of hiding unnecessary information, such as access restrictions to the member of an object, etc.
What is Polymorphism?
Answer: Let’s understand polymorphism by separating the term into two words that form it:
“Poly” means “many”
“Morph” means “shapes”
So, polymorphism can be described as an object that has different shapes.
In OOPs, it is referred to as the process through which some data, object, method, or code behaves differently under multiple contexts or circumstances. There are two types of polymorphism in the OOPs model:
- Run time polymorphism
- Compile time polymorphism
In other words, it is the multiple definitions of a single interface. For example, there is a class named ‘vehicle’, which consists of a method’ speed’. It is impossible to define the speed as different vehicles have different speeds. Thus, this can be defined in the subclasses of various definitions for various vehicles.
What is Static Polymorphism?
Answer: Static polymorphism is also known as compile time polymorphism. It is the feature through which an object can be linked with the respective operator or function based on the values. This can be achieved through operator overloading or method overloading.
Here, the methods use a similar name, but the parameter of each name varies. The object behaves differently for a similar trigger. Thus, multiple methods are implemented in the same class.
What is Dynamic Polymorphism?
Answer: Dynamic polymorphism is also known as runtime polymorphism. It refers to the type of polymorphism in OOPs through which the actual incorporation of function is settled during the execution or runtime. It can be achieved by method overriding.
For example, two classes, bike and Yamaha are created, and the class Yamaha extends the bike class overriding its run() method. Since the subclass method overrides the parent class method, it is invoked at run time.
What is a Class?
Answer: A class can be defined as the blueprint or template that contains some values, called member data. It also includes some rules, which are known as functions or behaviors. When you create an object, it automatically takes the functions and data defined in the class.
However, a class is a blueprint or template for objects. One can design as many objects as per the requirement based on a class. For example, a car’s template is created at first. After that, different units of cars are designed based on the car’s template.
What is an Object?
Answer: The object can be defined as the instance of a class that contains the instance of behaviors and members defined in the template. The object is the actual entity a user interacts with, but class is just a blueprint for that object.
Thus, objects have some characteristics or behavior and consume space—for example, a specific car model.
What is the difference between a Class and a Structure?
Answer: Let’s understand this with the help of a table:
| Class | Structure |
| Classes are of reference types. | Structures are of value types. |
| It is allocated to heap memory. | It is allocated on stack memory. |
| Allocation is cheaper in the large reference type | Allocation is cheaper in value type than a reference type |
| It has limitless features. | It has limited features. |
| A class is used in large programs. | A structure is used in small programs. |
| It contains a constructor and a destructor. | It contains parameterized or static constructor. |
| It uses a new() keyword every time it creates instances. | It can easily create instances with or without any keywords. |
| A class can inherit from another class. | A structure is not allowed to inherit. |
| The data members of a class can be protected. | The data members of a structure can’t be protected. |
| Function members can be abstract or virtual | Function members can’t be abstract or virtual |
| Two different variables of class can include the reference of a similar object. | Each variable contains its own copy. |
What is Inheritance?
Answer: Inheritance is one of the features of OOPs that enable a class to inherit the main properties of another class. For example, if ‘vehicle’ is a class then ‘car’, ‘bike’, etc., are other classes that can inherit key properties from the class’ vehicle’.
This feature helps in getting rid of redundant code; hence, reducing the size of the code. In simple terms, inheritance is defined as the receiver of properties from the parent class to the child class. Here, ‘vehicle’ is the parent class, and ‘car’ or ‘bike’ are child classes from the above example.
This way, you can reuse the programming code of one class in another class without writing the same code again or wasting time in the process.
What are the various types of inheritance?
Answer: There are various types of inheritance used in the OOPs model, such as:
- Single inheritance: It defines as the inheritance in which a single class inherits common functions of a single base class.
- Multiple inheritances: It comes into the picture when a single class inherits more than one class.
- Multilevel inheritance: This means a class inherits from other classes, which are subclasses of some other class.
- Hierarchical inheritance: It refers to the inheritance where one class has multiple subclasses.
- Hybrid inheritance: It is the combination of multilevel and multiple inheritances.
What are the limitations of inheritance?
Answer: Some of the limitations of inheritance are as follows:
- It increases the effort and time required to execute the program. This is because it requires jumping from one class to another class frequently, which takes time.
- The parent class, along with the child class, are coupled very tightly, so, less flexibility.
- It needs careful incorporation, or else it would lead to insufficient or incorrect results.
- A single modification in the program may lead to a change in code in both parent and child classes.
What is Abstraction?
Answer: Abstraction is one of the elements of OOPs. The key role of abstraction is to handle complexity. This is done by hiding unwanted details from the users. This allows users to implement complex logic on top of abstraction without thinking about the hidden complexity.
For example, if you are a coffee lover, you need to know how much milk, coffee beans, and sugar cubes you want to add to make a cup of coffee using a coffee machine. There is no point in thinking about the working principle of that machine. The coffee machine is a hidden complexity that you don’t need to know, but the process of making a coffee is a necessity.
There are two types of abstraction:
- Data abstraction
- Process abstraction
What is a Constructor?
Answer: A constructor is a special method in the class or structure whose name is similar to the class name. It serves the required purpose of initializing objects. It also helps in instantiating member data as well as methods to assign objects to the class.
When creating a constructor, a few things are necessary to keep in mind:
- It is named the same as the class name.
- It can’t be abstract, final, or static.
- It doesn’t have any return type variable.
What are the various types of constructors in C ?
Answer: There are mainly three types of constructors in C :
- Default constructor: A constructor with no parameters or arguments in the definition. This type of constructor is used to initialize the data members or variables with real values.
- Parameterized Constructor: It contains arguments or parameters in the declaration and definition. More than one parameter can pass through the parameterized constructor. It is used for overloading to know the differences in multiple constructors.
- Copy constructor: It is a member function that uses another object of a similar class to initialize an object. Moreover, it helps copy data from a single object to another.
What is a Destructor?
Answer: A destructor is a method called automatically while destroying an object. It implements certain actions:
- Recovering heap space that is allocated before during the initialization of the object
- Closing database connections and files
- Releasing network resources and resource locks
- Performing various housekeeping tasks
In other words, a destructor destroys the objects initialized by the constructor. It is a special member function with the same name as the class name but is preceded by a (~) symbol. A destructor can be overloaded as it is a one-way function.
What is Garbage Collection (GC)?
Answer: Garbage collection (GC) is a memory recovery element built into programming languages, such as Java and C#. A GC-enabled programming language contains at least one garbage collector that frees up memory space automatically that’s no longer required within a program.
Garbage collection confirms that the program still is within its memory quota. It prevents developers from manually managing the program’s memory, which minimizes memory-related bugs.
What is exception handling?
Answer: Exception handling is a method of responding to unexpected events while a computer program runs. Programmers must “handle” unwanted events (exceptions) to prevent a system or program from crashing. Without this method, exceptions may disrupt the common operation of a program and result in inefficiencies or risks.
What is a try/catch block?
Answer: Try or catch are the keywords that represent exception handlings due to coding or data errors during the execution of a program.
- A try block is the code block where exceptions occur
- A catch block handles and catches try block exceptions
The try and catch statements are frequently used in various programming languages, including C . C#, Java, SQL, and JavaScript. Every try statement matches with a catch statement in order to handle the execution. Here are a few more things to remember in try and catch statements:
- A try block is followed by the catch block.
- A try block is followed by at least one catch block.
- A try block is followed by another try block and further followed by the catch block.
What is structured programming?
Answer: Structured programming is a programming paradigm that emphasizes organized code for improved readability and maintenance. Simply put, the main goal of structured programming is to make the code easier to understand, which also helps reduce bugs. This method breaks the code into smaller modules, such as functions and procedures, which are logically linked.
What is base class, subclass, and superclass?
Answer: Base Class (Parent Class or Super Class): A base class is a blueprint that defines common properties and methods shared across one or multiple related classes. This class provides a foundation for other classes. The subclasses inherit the properties and methods described in the base class.
Base Class Example: Imagine a base class named “Vehicle”, which would have common properties such as speed, color, and methods like start() and stop(). These properties and methods are typical for various types of vehicles.
Subclass (Child Class or Derived Class): A subclass is a class that inherits the properties and methods from an existing class, i.e., the base class or super class. In the subclass, you can override the methods and properties of the base class, and you can also add new methods and properties.
Subclass Example: If a subclass “Car” inherits from the “Vehicle” base class, the “Car” class will automatically have the properties and methods of the “Vehicle” class. In the “Car” class, you can add properties like models and methods like accelerate().
Super Class: A super class is a class that provides a base for subclasses. Subclasses inherit the properties and methods of the superclass. The superclass is used in inheritance, which helps improve code reusability and maintainability.
Super Class Example: The “Vehicle” class can be a superclass containing common vehicle properties and methods. “Car” and “Motorcycle” can be subclasses, inheriting the properties and methods from the “Vehicle” class.
In summary, the base class is that class in which common features and methods are defined; the subclass is that class that inherits features from the base class and can add additional features to it; and the superclass is that class that provides a base for subclasses. This way, in OOP, it helps organize and reuse code.
What is an interface?
Answer: In programming, an interface is a set of rules that classes agree to follow. It specifies specific methods that any class implementing the interface must have.
Classes can be different but follow the same interface, ensuring they have common methods even though they work differently. It promotes a consistent way of using various classes in the code.
What is an abstract class?
Answer: An abstract class is a blueprint that declares specific methods but not their actual implementation. This class cannot be created directly; only its subclasses can be created.
Those abstract methods declared in the abstract class are implemented in the subclasses. The purpose of an abstract class is to define common methods and share them across multiple classes.
What is an abstract method?
Answer: An abstract method is declared in an abstract class without any actual code. It only shows what it should look like. Subclasses must provide the existing code for this method.
For example, if there’s an abstract method make_sound in an “Animal” class, a “Dog” subclass must define what make_sound actually does (like returning “Woof!”).
What are access specifiers?
Answer: Access specifiers in object-oriented programming define the visibility and accessibility of class members (methods and properties).
Explain access modifiers and their types.
Answer: Access Modifiers are not just concepts but also keywords used in programming. More specifically, Access Modifiers are keywords in OOP (object-oriented programming). They determine the accessibility of methods, classes, constructors, and other class members.
Public, private, protected, and package/default are the four main access modifiers in most OOP languages.
- Private: This restricts access to only within the class it’s declared in. No external access is allowed.
- Public: As open as it gets. It doesn’t matter where you are; inside or outside the class, package, or even another package — you can access it.
- Protected: This one’s interesting. Within its package, it’s accessible. Outside the package? Only its subclasses can access it, and even then, only when an instance of the subclass is present.
- Default: If no specific access is mentioned, it defaults to this, limiting visibility to its package. Other packages can’t access it.
What are sealed modifiers?
Answer: In OOPs, a “sealed” modifier prevents a class from being inherited or a method from being overridden. Please follow the Example below that explains the sealed modifier in C#:
sealed class MyClass { }
#This means no other class can inherit from MyClass.What is constructor chaining?
Answer: Constructor chaining means linking multiple constructors together. It can be done in two ways:
- Using “
this()” to connect constructors in the same class. - Using “
super()” to connect constructors from a parent class.
What is composition?
Answer: Composition is a basic idea in object-oriented programming. It’s when one class has objects from other classes in its variables. This shows a “has-a” link between objects, as we often see in everyday life.
Explain coupling and its types.
Answer: Coupling refers to how much software modules rely on each other. When there’s tight coupling, modules are significantly linked, so changing one might impact others. But with loose coupling, modules mostly stand alone, so changes in one don’t bother the others. High coupling implies strong dependencies, making classes tightly interconnected, making changes in one class likely to impact other classes.
Types of Coupling:
1. Low Coupling:
- Classes are independent and don’t rely heavily on each other.
- Changes in one class don’t affect other classes much.
- Promotes flexibility and easier maintenance.
2. Medium Coupling:
- Classes depend on limited, specific parts of other classes.
- Changes in one class might have some impact on a few related classes.
- Moderate flexibility and maintainability.
3. High Coupling:
- Classes are highly dependent on each other’s internal workings.
- Changes in one class often require changes in many related classes.
- Low flexibility and challenging to maintain.
What are early and late bindings?
Answer: In object-oriented programming, early binding, also called static binding, happens during the compile time. It links a method call with the method body before the program runs, making the execution faster as the method is known in advance.
On the other hand, late binding, or dynamic binding, occurs during runtime. It links the method call with the method body when the program is executed, allowing flexibility as the specific method is chosen based on the object’s type during runtime.
Early binding is like planning your route before the journey, while late binding is like deciding the route as you travel.
What is ‘this’?
Answer: In OOP, ‘this’ is a keyword that refers to the current object in a class. It helps differentiate between instance variables and method parameters with the same name. It points to the object on which a method operates, avoiding confusion in the code.
How much memory does a class occupy?
Answer: In OOP, a class doesn’t directly use memory; it’s a blueprint. Memory is used by objects created from the class based on their properties and methods. Each object takes up memory, not the class itself.
What are virtual functions?
Answer: A virtual function is a function in a main class that you can change in a class that comes from it. A pure virtual function is a function in the main class that’s set up in that class but changed or filled out in the class that’s based on it.
What is a pure virtual function?
Answer: In object-oriented programming, think of a pure virtual function as a promise. It’s like a job listed in the base class but not actually done there. You know it’s a pure virtual function when you see “= 0” next to it. If a class has one of these, you can’t create an object from it directly since it’s like an incomplete blueprint, also known as an abstract class.
Any class that inherits from this “blueprint” class has to do the job (or implement the function) before you can use it. This ensures every version of the class follows some standard rules but can act differently based on specific needs.
What is an inline function?
Answer: 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.
What is a friend function?
Answer: In object-oriented programming, a friend function is a unique function that is not a member of a class but can access its private and protected members. It’s like giving special permission to a function outside the class to work with the class’s private data.
This helps in scenarios where specific functions require access to private details of a class without becoming a part of that class.
What is operator overloading?
Answer: Operator overloading, or polymorphism, is a technique in object-oriented systems where the same operator name or symbol can be used for multiple operations.
Discuss the difference between overloading and overriding.
Answer: Understanding the distinctions between method overloading and method overriding is crucial in object-oriented programming.
Overloading allows multiple methods with the same name but different parameters within the same class. In contrast, method overriding enables a subclass to provide a specific implementation for a method defined in its superclass.
Let’s compare these concepts using key parameters in the table below:
| Parameter | Overloading | Overriding |
|---|---|---|
| Definition | Multiple methods in the same class | Method in a subclass with the same name as in the superclass |
| Inheritance | Not necessary, can be in the same class | Must have the same method name and parameter list as the superclass |
| Signature | Must have different parameter lists | Must have the same method name and parameter list as the superclass |
| Return Type | Can be different | Must be the same as the method in the superclass |
| Usage | Provides multiple methods with the same name but different parameters | Allows a subclass to provide a specific implementation of a method defined in the superclass |
What is a finally block?
Answer: In object-oriented programming, a finally block is a segment of code that always gets executed, regardless of whether an exception is thrown or not. It ensures that certain code statements are executed, be it a successful execution or if an exception occurs.
This block is often used for actions like closing files or releasing resources to guarantee they are properly handled, regardless of any errors that might occur during program execution.
Discuss the difference between an error and an exception.
Answer: Errors represent serious system or hardware failures, typically leading to program termination, and are usually beyond the program’s control. Exceptions, however, arise from specific conditions within the program and can be managed through handling mechanisms.
Please refer to the table below for a better understanding,
| Parameter | Error | Exception |
|---|---|---|
| Typical Use | Represents serious system failures | Used for manageable exceptional conditions in programs |
| Examples | OutOfMemoryError, StackOverflowError |
NullPointerException, ArrayIndexOutOfBoundsException |
| Handling | Often cannot be recovered, leads to program termination | Can be caught and handled to prevent program termination |
| Cause | Typically caused by the system or hardware | Caused by program conditions that can be handled |
Discuss the difference between a class and an object.
Answer: In Object-Oriented Programming (OOP), the concepts of a “class” and an “object” relate to how we structure and create our software. Below is the table to understand the difference properly:
| Aspect | Class | Object |
|---|---|---|
| Nature | Blueprint or template | Instance of a class; a specific realization |
| Role | Defines properties and methods | Represents a real entity with those properties and behaviors |
| Abstract/Concrete | Abstract: Defines structure and behavior, but isn’t a tangible entity | Concrete: A tangible entity that can be interacted with in the program |
| Usage | Cannot be used directly for storing data or performing actions | Used to store data and perform actions as defined by its class |
| Example | If you have a class Car, it’s just a specification. It describes what a car is, but it isn’t an actual car. | An object like myCar, based on the Car class is an actual car, with a specific make, model, and color. |
| Uniqueness | Every class is defined once and sets a template for what objects created from it will be like. | Objects can be numerous, each created from the class template but with potentially unique characteristics. |
Discuss the difference between a class and a method.
Answer: In Object-Oriented Programming, the distinction between a class and a method is pivotal yet straightforward. A class serves as a broader template, defining the essential properties (like size and color) and methods of an object. It sets the stage, outlining what objects of this class can know and do, but in itself, it doesn’t take any direct action or hold specific data.
When we talk about creating something in OOP, we usually refer to creating an object from a class, not something from a method.
Methods, nestled within the class, focus on particular actions or behaviors. They are the individual operations or functions defined in the class geared towards performing specific tasks.
When you invoke a method, you’re essentially telling an object how to act or respond, making the method a dynamic and active element of the class. Unlike a class, which provides a general blueprint, a method breathes life into the class’s capabilities, turning theory into practice.
| Class | Method |
|---|---|
| A class is a blueprint or template for creating objects. It defines properties (like size and color) and behaviors (methods) that these objects will have. | A method is a block of code defined within a class that describes a specific action. Methods are how an object of a class performs its tasks. |
| A class is used to create objects and establish a structure for them, including what data they can hold and what actions they can perform. | A method is used to implement the behaviors or actions of an object, describing what the object can do. |
| Broader, as it encompasses the overall definition of what an object is and what it can do. | Narrower, focusing on a specific task or operation within a class. |
| From a class, you create instances (objects), each with its own state that adheres to the class’s structure. | Methods are called upon by objects to perform tasks, manipulate object data, or carry out operations. |
| If you have a class named Car, it describes what a car is in general (properties like color, engine type, and behaviors like drive, stop). | A method in the Car class might be startEngine(), which when called, performs the action of starting the car’s engine. |
Discuss the difference between a class and an interface.
Answer: In Object-Oriented Programming (OOP), both classes and interfaces are fundamental concepts, but they serve different purposes and follow different rules. Understanding the difference between them is key to designing robust and flexible software.
Let’s dive into a table for clearer differences:
| Class | Interface |
|---|---|
| A template for creating objects, defining their state (attributes) and behavior (methods). | A collection of abstract methods (and sometimes constants) that a class can implement. |
| Contains concrete implementations of methods and properties. | Does not contain any method implementation. Only declares method signatures. |
| A class can extend another class, inheriting its properties and methods. | A class implements an interface, agreeing to perform the specific behaviors outlined in the interface. |
| Typically, a class cannot extend more than one class (depends on the language, but it is true for languages like Java). | A class can implement multiple interfaces, allowing for a form of multiple inheritances. |
| To encapsulate data and provide functionality. | To define a contract that implementing classes must follow, ensuring a certain level of functionality. |
Discuss the difference between a class and a structure
Answer: While class and structure might appear similar at first glance, they are used differently based on the programming language and the specific requirements of the application.
| Class | Structure |
|---|---|
| Reference type. When you assign an instance of a class to another variable, both variables refer to the same object in memory. | Value type. Assigning an instance of a struct to another variable copies the entire struct, creating two independent objects. |
| Can inherit from another class, allowing for more complex behaviors and properties. | Typically, it does not support inheritance. However, in C# programming language, structs can implement interfaces. |
| Class members are private by default (in C# and Java), meaning you have to explicitly set members to be publicly accessible. | Struct members are public by default in C , but in C#, they are private, like in classes. |
Discuss the difference between multiple and multi-level inheritance
Answer: The differences between multiple inheritance and multi-level inheritance are crucial for designing the hierarchy and interaction of classes in your software.
| Multiple Inheritance | Multi-level Inheritance |
|---|---|
| The subclass extends across multiple base classes. | The inheritance forms a straight line, with each class extending from the one above it. |
| A child class has immediate relationships with multiple parent classes. | A child class is related to its parent, and indirectly to its grandparent, and so on. |
| Useful in situations where a class genuinely needs to inherit diverse functionality from multiple unrelated classes. | Common in scenarios where an enhanced or specialized version of an existing class is needed. |
Discuss the difference between runtime polymorphism and compile time polymorphism.
Answer: In Object-Oriented Programming (OOP), polymorphism allows objects of different classes to be treated as objects of a common superclass, resulting in two primary forms: compile-time polymorphism and runtime polymorphism.
- Compile-Time Polymorphism: This type of polymorphism is determined during the compilation of the program, hence the name.
It’s achieved through methods like method overloading (where multiple methods in the same class have the same name but different parameters) and operator overloading (where an operator is given a new meaning or function for different types of operations).
The compiler decides which method or operator version to use, making the process faster but less flexible.
- Runtime Polymorphism: This occurs during the execution of the program, where the exact method to be called is decided at runtime. It’s mostly seen in method overriding, where a subclass provides a specific implementation of a method that is already defined in its superclass.
Unlike compile-time, runtime polymorphism allows for greater flexibility as the decision about which method to execute is made during the program’s run, although it can be slightly slower due to this additional decision-making process.
Conclusion
OOP is an essential concept for programmers to know. Learning it thoroughly will also help you program well in languages that use the OOP concepts.
If you are preparing for an interview or test, the above interview questions and answers will help you refresh your understanding of OOP concepts like classes, objects, encapsulation, polymorphism, inheritance, abstraction, and more. This way, you can confidently face the interviews and get through them successfully to build your career.
You may also look at some of these SQL Interview Questions.
