Basic OOPs Interview Questions
Basic OOPs Interview Questions
Basic OOPs Interview Questions
OOPs refers to Object-Oriented Programming. It is the programming paradigm that is defined using objects. Objects can be considered as real-
world instances of entities like class, that have some characteristics and behaviors.
There are many reasons why OOPs is mostly preferred, but the most important among them are:
OOPs helps users to understand the software easily, although they don’t know the actual implementation.
With OOPs, the readability, understandability, and maintainability of the code increase multifold.
Even very big software can be easily written and managed easily using OOPs.
Java
C++
JavaScript
Python
PHP
Programming paradigms refers to the method of classification of programming languages based on their features. There are mainly two types of
Programming Paradigms:
Imperative
Declarative
1. Imperative Programming Paradigm: Imperative programming focuses on HOW to execute program logic and defines control flow as
statements that change a program state. This can be further classified as:
a) Procedural Programming Paradigm: steps a program must take to reach the desired state
b) Object-Oriented Programming or OOP: organizes programs as objects, that contain some data and have some behavior.
c) Parallel Programming: breaks a task into subtasks and focuses on executing them simultaneously at the same time.
2. Declarative Programming Paradigm: Declarative programming focuses on WHAT to execute and defines program logic, but not a detailed
control flow. Declarative paradigm can be further classified into:
a) Logical Programming Paradigm: refers to a set of sentences expressing facts and rules about how to solve a problem
b) Functional Programming Paradigm: programs are constructed by applying and composing functions.
c) Database Programming Paradigm: is used to manage data and information structured as fields, records, and files.
Structured Programming refers to the method of programming which consists of a completely structured control flow. Here structure refers to a
block, which contains a set of rules, and has a definitive control flow, such as (if/then/else), (while and for), block structures, and subroutines.
Inheritance
Encapsulation
Polymorphism
Data Abstraction
Not only that, the main pillar of OOPs - Data Abstraction, Encapsulation, Inheritance, and Polymorphism, makes it easy for programmers to solve
complex scenarios. As a result of these, OOPs is so popular.
9. What is a class?
A class can be understood as a blueprint, which contains some values, known as data members, and some set of rules, known as functions. So,
when an object is created, it automatically takes the data and functions that are defined in the class.
For example, first, a car’s template is created. Then multiple units of car are created based on that template.
An object refers to the instance of the class, which contains the instance of the members and behaviors defined in the class template.
process of binding data members and methods of a program together to do a specific job, without revealing unnecessary details.
1) Data hiding: process of hiding unwanted information, such as restricting access to any member of an object.
2) Data binding: process of binding the data members and the methods together as a whole, as a class.
The word polymorphism means having many forms. In simple words, we can define polymorphism as the ability of a message to be displayed
in more than one form.
Compile-time polymorphism and Run time polymorphism are the two types of polymorphisms in OOPs languages.
What is Compile time Polymorphism and how is it different from Runtime Polymorphism?
Compile Time Polymorphism: Compile time polymorphism, == Static Polymorphism, refers to the type of Polymorphism that happens at compile
time. What it means is that the compiler decides what shape or value has to be taken by the entity in the picture.
Runtime Polymorphism: Runtime polymorphism, == Dynamic Polymorphism, refers to the type of Polymorphism that happens at the run time.
What it means is it can't be decided by the compiler. Therefore, what shape or value has to be taken depends upon the execution. Hence the name
Runtime Polymorphism.
Compile Time Polymorphism: C++ supports compile-time polymorphism with the help of features like templates, function overloading, and
default arguments.
Runtime Polymorphism: C++ supports Runtime polymorphism with the help of features like virtual functions. Virtual functions take the
shape of the functions based on the type of object in reference and are resolved at runtime.
Inheritance is the mechanism by which an object or class (referred to as a child) is created using the definition of another object or class (referred
to as a parent). Inheritance not only helps to keep the implementation simpler but also helps to facilitate code reuse.
Abstraction is the method of hiding unnecessary details from the necessary ones. It is one of the main features of OOPs.
For example, consider a car. You only need to know how to run a car, and not how the wires are connected inside it. This is obtained using
Abstraction.
Classes do not consume any memory. They are just a blueprint based on which objects are created. Now when objects are created, they actually
initialize the class members and methods and therefore consume memory.
No. An object is necessary to be created if the base class has non-static methods. But if the class has static methods, then objects don’t need to be
created. You can call the class method directly in this case, using the class name.
19. What is a constructor?
Constructors are special methods whose name is the same as the class name. The constructors serve the special purpose of initializing the objects.
For example, suppose there is a class with the name “MyClass”, then when you instantiate this class, you pass the syntax:
MyClass myClassObject = new MyClass();
Now here, the method called after “new” keyword - MyClass(), is the constructor of this class. This will help to instantiate the member data and
methods and assign them to the object myClassObject.
Parameterized constructor: constructors that take some arguments are known as parameterized constructors.
Copy constructor: member function that initializes an object using another object of the same class.
copy constructor will clone an object and its values, into another object, is provided that both the objects are of the same class.
destructors free up the resources and memory occupied by an object. Destructors are automatically called when an object is being destroyed.
23. Are class and structure the same? If not, what's the difference between a class and a structure?
No, class and structure are not the same. Though they appear to be similar, they have differences that make them apart.
For example, the structure is saved in the stack memory, whereas the class is saved in the heap memory. Also, Data Abstraction cannot be achieved
with the help of structure, but with class, Abstraction is majorly used.
24. Explain Inheritance with an example?
It is the mechanism in java by which one class is allowed to inherit the features (fields and methods) of another class. Inheritance not only helps
to keep the implementation simpler but also helps to facilitate code reuse.
Let me explain to you with a common example. Let's take three different vehicles - a car, truck, or bus. These three are entirely different from one
another with their own specific characteristics and behavior. But. in all three, you will find some common elements, like steering wheel, accelerator,
clutch, brakes, etc. Though these elements are used in different vehicles, still they have their own features which are common among all vehicles.
This is achieved with inheritance. The car, the truck, and the bus have all inherited the features like steering wheel, accelerator, clutch, brakes, etc.,
and used them as their own. Due to this, they did not have to create these components from scratch, thereby facilitating code reuse.
Yes, with more powers comes more complications. Inheritance is a very powerful feature in OOPs, but it has some limitations too.
Inheritance needs more time to process, as it needs to navigate through multiple classes for its implementation.
Also, the classes involved in Inheritance - the base class and the child class, are very tightly coupled together. So, if one needs to make some
changes, they might need to do nested changes in both classes.
Inheritance might be complex for implementation, as well. So, if not correctly implemented, this might lead to unexpected errors or incorrect
outputs.
The subclass is a part of Inheritance. The subclass is an entity, which inherits from another class. It is also known as the child class.
Superclass is also a part of Inheritance. The superclass is an entity, which allows subclasses or child classes to inherit from itself.
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.
Compile time Polymorphism can be achieved through Method overloading or operator overloading.
The dynamic or runtime polymorphism can be achieved with the help of method overriding.
Overloading is a compile-time polymorphism feature in which an entity has multiple implementations with the same name. For example, Method
overloading and Operator overloading.
Whereas Overriding is a runtime polymorphism feature in which an entity has the same name, but its implementation changes during execution.
For example, Method overriding.
Image
Data abstraction is accomplished with the help of abstract methods or abstract classes.
An abstract class is a special class containing abstract methods. The significance of abstract class is that the abstract methods inside it is not
implemented and only declared.
So as a result, when a subclass inherits the abstract class and needs to use its abstract methods, they need to define and implement them.
The main difference between the two is that, when an interface is implemented, the subclass must define all its methods and provide its
implementation. Whereas when an abstract class is inherited, the subclass does not need to provide the definition of its abstract method, until and
unless the subclass is using it.
Also, an abstract class can contain abstract methods as well as non-abstract methods.
Access specifiers, are a special type of keywords, which are used to control or specify the accessibility of entities like classes, methods, etc. Some of
the access specifiers or access modifiers include “private”, “public”, etc.
These access specifiers also play a very vital role in achieving Encapsulation - one of the major features of OOPs.
An exception == event, which is raised during the execution of a program at runtime, that brings the execution to a halt. The reason for the
exception is mainly due to a position in the program, where the user wants to do something for which the program is not specified, like
undesirable input.
No one wants its software to fail or crash. Exceptions are the major reason for software failure. The exceptions can be handled in the program
beforehand and prevent the execution from stopping. This is known as exception handling.
So exception handling is the mechanism for identifying the undesirable states that the program can reach and specifying the desirable outcomes
of such states.
Try-catch is the most common method used for handling exceptions in the program.
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 refers to this mechanism of handling the memory in the program. Through garbage collection, the unwanted memory is freed
up by removing the objects that are no longer needed.
40. Can we run a Java application 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.
However, on the other hand, C++ can be implemented without OOPs, as it also supports the C-like structural programming model.
Public: Making the main() method public makes it globally available . It is made public so that JVM can invoke it from outside the class as it is
not present in the current class.
Static: The main() method is static so that JVM can invoke it without instantiating the class. This also saves the unnecessary wastage of memory
which would have been used by the object declared only for calling the main() method by the JVM.
Void: It is a keyword and used to specify that a method doesn’t return anything. It doesn’t make any sense to return from main() method as
JVM can’t do anything with the return value of it.
Main: It is the identifier that the JVM looks for as the starting point of the java program. It’s not a keyword.
Java does not return int implicitly, even if we declare return type of main as int.
We will get compile time error
However, the java program runs as ‘main thread’ in JVM. The Java program is not even a process of Operating System directly. There is no
direct interaction between Java program and Operating System.
Can we overload static methods? The answer is ‘Yes’. We can have two or more static methods with same name, but differences in input
parameters
Can we Override static methods in java? The answer is ‘No’. Static methods cannot be overridden because method overriding only occurs in
the context of dynamic (i.e. runtime) lookup of methods. Static methods (by their name) are looked up statically (i.e. at compile-time).
What happens if you remove static modifier from the main method?
Program compiles successfully. But at runtime throws an error “NoSuchMethodError”.
reference variable that is used to refer parent class objects. The keyword “super” came into the picture with the concept of Inheritance.
The static keyword belongs to the class than the instance of the class.
The static can be:
In Java, when we only declare a variable of a class type, only a reference is created (memory is not allocated for the object). To allocate memory
to an object, we must use new(). So the object is always allocated memory on the heap.