1. What is the difference between OOP and SOP?

Object-Oriented Programming Structural Programming

Object-Oriented Programming is a type of
Provides logical structure to a program where
programming which is based on objects rather than just
programs are divided functions
functions and procedures
Bottom-up approach Top-down approach
Provides data hiding Does not provide data hiding
Can solve problems of any complexity Can solve moderate problems
Code can be reused thereby reducing redundancy Does not support code reusability

2. What is OOPs?

OOPs (Object-Oriented Programming) is a type of programming which is based on objects rather than just
functions and procedures. Individual objects are grouped into classes. OOPs implements real-world entities like
inheritance, polymorphism, hiding, etc into programming. It also allows binding data and code together.

3. Why use OOPs?

 OOPs allows clarity in programming thereby allowing simplicity in solving complex problems
 Code can be reused through inheritance thereby reducing redundancy
 Data and code are bound together by encapsulation
 OOPs allows data hiding, therefore, private data is kept confidential
 Problems can be divided into different parts making it simple to solve
 The concept of polymorphism gives flexibility to the program by allowing the entities to have multiple
forms

4. What are the main features of OOPs?

 Inheritance
 Encapsulation
 Polymorphism
 Data Abstraction

Classes and Objects OOPs Interview Questions:

5. What is an object?

An object is a real-world entity which is the basic unit of OOPs for example chair, cat, dog, etc. Different objects
have different states or attributes, and behaviours.

6. What is a class?

A class is a prototype that consists of objects in different states and with different behaviours. It has a number of
methods that are common the objects present within that class.

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

Class: User-defined blueprint from which objects are created. It consists of methods or set of instructions that
are to be performed on the objects.

Structure: A structure is basically a user-defined collection of variables which are of different data types.

8. Can you call the base class method without creating an instance?

Yes, you can call the base class without instantiating it if:
  It is a static method
 The base class is inherited by some other subclass

9. What is the difference between a class and an object?

Object Class
A class is basically a template or a blueprint within
A real-world entity which is an instance of a class
which objects can be created
An object acts like a variable of the class Binds methods and data together into a single unit
An object is a physical entity A class is a logical entity
Objects take memory space when they are created A class does not take memory space when created
Objects can be declared as and when required Classes are declared just once
To know more about objects and classes in JAVA, Python, and C++ you can go through the following blogs:

Interview Questions on Features of OOPs

Inheritance:

10. What is inheritance?

Inheritance is a feature of OOPs which allows classes inherit common properties from other classes. For
example, if there is a class such as ‘vehicle’, other classes like ‘car’, ‘bike’, etc can inherit common properties
from the vehicle class. This property helps you get rid of redundant code thereby reducing the overall size of the
code.

11. What are the different types of inheritance?

 Single inheritance
 Multiple inheritance
 Multilevel inheritance
 Hierarchical inheritance
 Hybrid inheritance

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

Multiple Inheritance Multilevel Inheritance

Multilevel inheritance means a class inherits from
Multiple inheritance comes into picture when a class
another class which itself is a subclass of some other
inherits more than one base class
base class
Example: A class describing a sports car will inherit
Example: A class defining a child inherits from two
from a base class Car which inturn inherits another
base classes Mother and Father
class Vehicle
13. What is hybrid inheritance?

Hybrid inheritance is a combination of multiple and multi-level inheritance.

14. What is hierarchical inheritance?

Hierarchical inheritance refers to inheritance where one base class has more than one subclasses. For example,
the vehicle class can have ‘car’, ‘bike’, etc as its subclasses.

15. What are the limitations of inheritance?

 Increases the time and effort required to execute a program as it requires jumping back and forth
between different classes
 The parent class and the child class get tightly coupled
 Any modifications to the program would require changes both in the parent as well as the child class
 Needs careful implementation else would lead to incorrect results
16. What is a superclass?

A superclass or base class is a class that acts as a parent to some other class or classes. For example, the
Vehicle class is a superclass of class Car.

17. What is a subclass?

A class that inherits from another class is called the subclass. For example, the class Car is a subclass or a
derived of Vehicle class.

Polymorphism

18. What is polymorphism?

Polymorphism refers to the ability to exist in multiple forms. Multiple definitions can be given to a single interface.
For example, if you have a class named Vehicle, it can have a method named speed but you cannot define it
because different vehicles have different speed. This method will be defined in the subclasses with different
definitions for different vehicles.

19. What is static polymorphism?

Static polymorphism (static binding) is a kind of polymorphism that occurs at compile time. An example of
compile-time polymorphism is method overloading.

20. What is dynamic polymorphism?

Runtime polymorphism or dynamic polymorphism (dynamic binding) is a type of polymorphism which is resolved
during runtime. An example of runtime polymorphism is method overriding.

21. What is method overloading?

Method overloading is a feature of OOPs which makes it possible to give the same name to more than one
methods within a class if the arguments passed differ.

22. What is method overriding?

Method overriding is a feature of OOPs by which the child class or the subclass can redefine methods present in
the base class or parent class. Here, the method that is overridden has the same name as well as the signature
meaning the arguments passed and the return type.

23. What is operator overloading?

Operator overloading refers to implementing operators using user-defined types based on the arguments passed
along with it.

24. Differentiate between overloading and overriding.

Overloading Overriding
Two or more methods having the same name but Child class redefining methods present in the base
different parameters or signature class with the same parameters/ signature
Resolved during compile-time Resolved during runtime
To know more about polymorphism in Java and Python, read the below articles:
Encapsulation

25. What is encapsulation?

Encapsulation refers to binding the data and the code that works on that together in a single unit. For example, a
class. Encapsulation also allows data-hiding as the data specified in one class is hidden from other classes.

26. What are ‘access specifiers’?

Access specifiers or access modifiers are keywords that determine the accessibility of methods, classes, etc in
OOPs. These access specifiers allow the implementation of encapsulation. The most common access specifiers
are public, private and protected. However, there are a few more which are specific to the programming
languages.

27. What is the difference between public, private and protected access modifiers?

Accessibility from own Accessibility from derived

Name Accessibility from world
class class
Public Yes Yes Yes
Private Yes No No
Protected Yes Yes No

Data abstraction

28. What is data abstraction?

Data abstraction is a very important feature of OOPs that allows displaying only the important information and
hiding the implementation details. For example, while riding a bike, you know that if you raise the accelerator, the
speed will increase, but you don’t know how it actually happens. This is data abstraction as the implementation
details are hidden from the rider.

29. How to achieve data abstraction?

Data abstraction can be achieved through:

 Abstract class
 Abstract method

30. What is an abstract class?

An abstract class is a class that consists of abstract methods. These methods are basically declared but not
defined. If these methods are to be used in some subclass, they need to be exclusively defined in the subclass.

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

No. Instances of an abstract class cannot be created because it does not have a complete implementation.
However, instances of subclass inheriting the abstract class can be created.

32. What is an interface?

It is a concept of OOPs that allows you to declare methods without defining them. Interfaces, unlike classes, are
not blueprints because they do not contain detailed instructions or actions to be performed. Any class that
implements an interface defines the methods of the interface.

33. Differentiate between data abstraction and encapsulation.

 Data abstraction Encapsulation
Solves the problem at the design level Solves the problem at the implementation level
Allows showing important aspects while hiding Binds code and data together into a single unit and
implementation details hides it from the world

Methods and Functions OOPs interview questions

34. What are virtual functions?

Virtual functions are functions that are present in the parent class and are overridden by the subclass. These
functions are used to achieve runtime polymorphism.

35. What are pure virtual functions?

Pure virtual functions or abstract functions are functions that are only declared in the base class. This means that
they do not contain any definition in the base class and need to be redefined in the subclass.

36. What is a constructor?

A constructor is a special type of method that has the same name as the class and is used to initialize objects of
that class.

37. What is a destructor?

A destructor is a method that is automatically invoked when an object is destroyed. The destructor also recovers
the heap space that was allocated to the destroyed object, closes the files and database connections of the
object, etc.

38. Types of constructors

Types of constructors differ from language to language. However, all the possible constructors are:

 Default constructor
 Parameterized constructor
 Copy constructor
 Static constructor
 Private constructor

39. What is a copy constructor?

A copy constructor creates objects by copying variables from another object of the same class. The main aim of
a copy constructor is to create a new object from an existing one.

40. What is the use of ‘finalize’?

Finalize as an object method used to free up unmanaged resources and cleanup before Garbage Collection(GC).
It performs memory management tasks.

41. What is Garbage Collection(GC)?

GC is an implementation of automatic memory management. The Garbage collector frees up space occupied by
objects that are no longer in existence.

43. Differentiate between an abstract class and an interface?

Basis for comparison Abstract Class Interface

Methods Can have abstract as well as other Only abstract methods
 methods
May contain final and non-final Variables declared are final by
Final Variables
variables default
Accessibility of Data Members Can be private, public, etc Public by default
Can provide the implementation of Cannot provide the implementation
Implementation
an interface of an abstract class
44. What is a final variable?

A variable whose value does not change. It always refers to the same object by the property of non-transversity.

Q1. What Is an Exception?

An exception is an abnormal event that occurs during the execution of a program and disrupts the normal flow of the
program's instructions.

Q2. What Is the Purpose of the Throw and Throws Keywords?

The throws keyword is used to specify that a method may raise an exception during its execution. It enforces explicit
exception handling when calling a method:
public void simpleMethod() throws Exception {
// ...
}
The throw keyword allows us to throw an exception object to interrupt the normal flow of the program. This is most
commonly used when a program fails to satisfy a given condition:
if (task.isTooComplicated()) {
throw new TooComplicatedException("The task is too complicated");
}

Q3. How Can You Handle an Exception?

By using a try-catch-finally statement:
try {
// ...
} catch (ExceptionType1 ex) {
// ...
} catch (ExceptionType2 ex) {
// ...
} finally {
// ...
}
The block of code in which an exception may occur is enclosed in a try block. This block is also called “protected” or
“guarded” code.
If an exception occurs, the catch block that matches the exception being thrown is executed, if not, all catch blocks are
ignored.
The finally block is always executed after the try block exits, whether an exception was thrown or not inside it.

Q4. How Can You Catch Multiple Exceptions?

There are three ways of handling multiple exceptions in a block of code.

The first is to use a catch block that can handle all exception types being thrown:
try {
// ...
} catch (Exception ex) {
// ...
}
You should keep in mind that the recommended practice is to use exception handlers that are as accurate as possible.
Exception handlers that are too broad can make your code more error-prone, catch exceptions that weren't anticipated, and
cause unexpected behavior in your program.
The second way is implementing multiple catch blocks:
try {
// ...
} catch (FileNotFoundException ex) {
// ...
} catch (EOFException ex) {
// ...
}
Note that, if the exceptions have an inheritance relationship; the child type must come first and the parent type later. If we
fail to do this, it will result in a compilation error.
The third is to use a multi-catch block:
try {
// ...
} catch (FileNotFoundException | EOFException ex) {
// ...
}
This feature, first introduced in Java 7; reduces code duplication and makes it easier to maintain.

Q5. What Is the Difference Between a Checked and an Unchecked Exception?

A checked exception must be handled within a try-catch block or declared in a throws clause; whereas an unchecked
exception is not required to be handled nor declared.
Checked and unchecked exceptions are also known as compile-time and runtime exceptions respectively.
All exceptions are checked exceptions, except those indicated by Error, RuntimeException, and their subclasses.

Q6. What Is the Difference Between an Exception and Error?

An exception is an event that represents a condition from which is possible to recover, whereas error represents an external
situation usually impossible to recover from.
All errors thrown by the JVM are instances of Error or one of its subclasses, the more common ones include but are not
limited to:

 OutOfMemoryError – thrown when the JVM cannot allocate more objects because it is out memory, and the
garbage collector was unable to make more available
 StackOverflowError – occurs when the stack space for a thread has run out, typically because an application
recurses too deeply
 ExceptionInInitializerError – signals that an unexpected exception occurred during the evaluation of a static
initializer
 NoClassDefFoundError – is thrown when the classloader tries to load the definition of a class and couldn't find it,
usually because the required class files were not found in the classpath
 UnsupportedClassVersionError – occurs when the JVM attempts to read a class file and determines that the
version in the file is not supported, normally because the file was generated with a newer version of Java

Although an error can be handled with a try statement, this is not a recommended practice since there is no guarantee that the
program will be able to do anything reliably after the error was thrown.

Q7. What Exception Will Be Thrown Executing the Following Code Block?
Integer[][] ints = { { 1, 2, 3 }, { null }, { 7, 8, 9 } };
System.out.println("value = " + ints[1][1].intValue());
It throws an ArrayIndexOutOfBoundsException since we're trying to access a position greater than the length of the array.

Q8. What Is Exception Chaining?

Occurs when an exception is thrown in response to another exception. This allows us to discover the complete history of our
raised problem:
try {
task.readConfigFile();
} catch (FileNotFoundException ex) {
throw new TaskException("Could not perform task", ex);
}

Q9. What Is a Stacktrace and How Does It Relate to an Exception?

A stack trace provides the names of the classes and methods that were called, from the start of the application to the point an
exception occurred.
It's a very useful debugging tool since it enables us to determine exactly where the exception was thrown in the application
and the original causes that led to it.

Q10. Why Would You Want to Subclass an Exception?

If the exception type isn't represented by those that already exist in the Java platform, or if you need to provide more
information to client code to treat it in a more precise manner, then you should create a custom exception.
Deciding whether a custom exception should be checked or unchecked depends entirely on the business case. However, as a
rule of thumb; if the code using your exception can be expected to recover from it, then create a checked exception otherwise
make it unchecked.
Also, you should inherit from the most specific Exception subclass that closely relates to the one you want to throw. If there
is no such class, then choose Exception as the parent.

Q11. What Are Some Advantages of Exceptions?

Traditional error detection and handling techniques often lead to spaghetti code hard to maintain and difficult to read.
However, exceptions enable us to separate the core logic of our application from the details of what to do when something
unexpected happens.
Also, since the JVM searches backward through the call stack to find any methods interested in handling a particular
exception; we gain the ability to propagate an error up in the call stack without writing additional code.
Also, because all exceptions thrown in a program are objects, they can be grouped or categorized based on its class
hierarchy. This allows us to catch a group of exceptions in a single exception handler by specifying the exception's
superclass in the catch block.

Q12. Can You Throw Any Exception Inside a Lambda Expression's Body?

When using a standard functional interface already provided by Java, you can only throw unchecked exceptions because
standard functional interfaces do not have a “throws” clause in method signatures:
List<Integer> integers = Arrays.asList(3, 9, 7, 0, 10, 20);
integers.forEach(i -> {
if (i == 0) {
throw new IllegalArgumentException("Zero not allowed");
}
System.out.println(Math.PI / i);
});
However, if you are using a custom functional interface, throwing checked exceptions is possible:
@FunctionalInterface
public static interface CheckedFunction<T> {
void apply(T t) throws Exception;
}
public void processTasks(
List<Task> taks, CheckedFunction<Task> checkedFunction) {
for (Task task : taks) {
try {
checkedFunction.apply(task);
} catch (Exception e) {
// ...
}
}
}

processTasks(taskList, t -> {
// ...
throw new Exception("Something happened");
});

Q13. What Are the Rules We Need to Follow When Overriding a Method That Throws an Exception?

Several rules dictate how exceptions must be declared in the context of inheritance.
When the parent class method doesn't throw any exceptions, the child class method can't throw any checked exception, but it
may throw any unchecked.
Here's an example code to demonstrate this:
class Parent {
void doSomething() {
// ...
}
}

class Child extends Parent {

void doSomething() throws IllegalArgumentException {
// ...
}
}
The next example will fail to compile since the overriding method throws a checked exception not declared in the overridden
method:
class Parent {
void doSomething() {
// ...
}
}

class Child extends Parent {

void doSomething() throws IOException {
// Compilation error
}
}
When the parent class method throws one or more checked exceptions, the child class method can throw any unchecked
exception; all, none or a subset of the declared checked exceptions, and even a greater number of these as long as they have
the same scope or narrower.
Here's an example code that successfully follows the previous rule:
class Parent {
void doSomething() throws IOException, ParseException {
// ...
}
 void doSomethingElse() throws IOException {
// ...
}
}

class Child extends Parent {

void doSomething() throws IOException {
// ...
}

void doSomethingElse() throws FileNotFoundException, EOFException {

// ...
}
}
Note that both methods respect the rule. The first throws fewer exceptions than the overridden method, and the second, even
though it throws more; they're narrower in scope.
However, if we try to throw a checked exception that the parent class method doesn't declare or we throw one with a broader
scope; we'll get a compilation error:
class Parent {
void doSomething() throws FileNotFoundException {
// ...
}
}

class Child extends Parent {

void doSomething() throws IOException {
// Compilation error
}
}
When the parent class method has a throws clause with an unchecked exception, the child class method can throw none or
any number of unchecked exceptions, even though they are not related.
Here's an example that honors the rule:
class Parent {
void doSomething() throws IllegalArgumentException {
// ...
}
}

class Child extends Parent {

void doSomething()
throws ArithmeticException, BufferOverflowException {
// ...
}
}

Q14. Will the Following Code Compile?

void doSomething() {
// ...
throw new RuntimeException(new Exception("Chained Exception"));
}
Yes. When chaining exceptions, the compiler only cares about the first one in the chain and, because it detects an unchecked
exception, we don't need to add a throws clause.

Q15. Is There Any Way of Throwing a Checked Exception from a Method That Does Not Have a Throws Clause?

Yes. We can take advantage of the type erasure performed by the compiler and make it think we are throwing an unchecked
exception, when, in fact; we're throwing a checked exception:
public <T extends Throwable> T sneakyThrow(Throwable ex) throws T {
throw (T) ex;
}

public void methodWithoutThrows() {

this.<RuntimeException>sneakyThrow(new Exception("Checked Exception"));
}