OOPS IN JAVA :------

1. What is Object Oriented Programming (OOPs)?

Object Oriented Programming (also known as OOPs) is a programming paradigm
where the complete software operates as a bunch of objects talking to each other. An
object is a collection of data and the methods which operate on that data.

2. Why OOPs?
The main advantage of OOP is better manageable code that covers the following:
1. The overall understanding of the software is increased as the distance
between the language spoken by developers and that spoken by users.
2. Object orientation eases maintenance by the use of encapsulation. One can
easily change the underlying representation by keeping the methods the
same.
3. The OOPs paradigm is mainly useful for relatively big software.

3. What is a Class?
A class is a building block of Object Oriented Programs. It is a user-defined data
type that contains the data members and member functions that operate on the data
members. It is like a blueprint or template of objects having common properties and
methods.
4. What is an Object?
An object is an instance of a class. Data members and methods of a class cannot be
used directly. We need to create an object (or instance) of the class to use them. In
simple terms, they are the actual world entities that have a state and behavior.

Eg. The code below shows is an example of how an instance of a class (i.e an
object ) of a class is created
#include <iostream>

using namespace std;

class Student{

private:

string name;

string surname;

int rollNo;
 public:

Student(string studentName, string studentSurname, int studentRollNo){

name = studentName;

surname = studentSurname;

rollNo = studentRollNo;

void getStudentDetails(){

cout << "The name of the student is " << name << " " << surname << endl;

cout << "The roll no of the student is " << rollNo << endl;

};

int main() {

Student student1("Vivek", "Yadav", 20);

student1.getStudentDetails();

return 0;

Output
The name of the student is Vivek Yadav
The roll no of the student is 20

5. What are the main features of OOPs?

The main feature of the OOPs, also known as 4 pillars or basic principles of OOPs
are as follows:
1. Encapsulation
2. Data Abstraction
3. Polymorphism
4. Inheritance
6. What is Encapsulation?
Encapsulation is the binding of data and methods that manipulate them into a single
unit such that the sensitive data is hidden from the users
It is implemented as the processes mentioned below:
1. Data hiding: A language feature to restrict access to members of an
object. For example, private and protected members in C++.
2. Bundling of data and methods together: Data and methods that operate
on that data are bundled together. For example, the data members and
member methods that operate on them are wrapped into a single unit
known as a class.
//simple demonstration of encapsulation

//It has a private data member and getter and setter methods.

public class Student{

//private data members

private String name;

private int rollNo;

//public getter method to access the name

public String getName(){

return name;

//public getter method to access rollNo

public int getRollNo(){

return rollNo;

//public setter method to set name

 public void setName(String name){

this.name=name

//public setter method to set rollNo

public void setRollNo(int rollNo){

this.rollNo=rollNo;

7. What is Abstraction?
Abstraction is similar to data encapsulation and is very important in OOP. It means
showing only the necessary information and hiding the other irrelevant information
from the user. Abstraction is implemented using classes and interfaces.

//implementation of abstraction through abstract class

abstract class Animal {

abstract void walk();

void eat()

{
 System.out.println("The animal is eating.");

Animal()

System.out.println(

"An Animal is going to be created.");

class Cow extends Animal {

Cow() { System.out.println("You have created a Cow"); }

void walk() { System.out.println("Cow is walking."); }

class Goat extends Animal {

Goat()

System.out.println("You have created a Goat");

void walk() { System.out.println("Goat is walking."); }

public class OOPS {

public static void main(String args[])

Cow cow = new Cow();

cow.walk();

cow.eat();

Goat goat = new Goat();

 goat.walk();

goat.eat();

8. What is Polymorphism?
The word “Polymorphism” means having many forms. It is the property of some
code to behave differently for different contexts. For example, in C++ language, we
can define multiple functions having the same name but different working
depending on the context.
Polymorphism can be classified into two types based on the time when the call to the
object or function is resolved. They are as follows:
 Compile Time Polymorphism
 Runtime Polymorphism
 A) Compile-Time Polymorphism
 Compile time polymorphism, also known as static polymorphism or early
binding is the type of polymorphism where the binding of the call to its code
is done at the compile time. Method overloading or operator overloading are
examples of compile-time polymorphism.
 B) Runtime Polymorphism
 Also known as dynamic polymorphism or late binding, runtime
polymorphism is the type of polymorphism where the actual implementation
of the function is determined during the runtime or execution. Method
overriding is an example of this method.

– Method Overloading
// An example of method overloading

class Student {

String name,surname;

int rollNo;

public void showStudentDetails(String name) {

System.out.println("The name of the student is " + name);

public void showStudentDetails(int rollNo) {

 System.out.println("the roll no of the student is "+ rollNo);

public void showStudentDetails(String name, String surname, int rollNo) {

System.out.println(name);

System.out.println(surname);

System.out.println(rollNo);

// Main Method

public static void main(String args[]){

// Student object Created

Student st=new Student();

// Method Overloading

st.showStudentDetails("Ank");

st.showStudentDetails(3);

st.showStudentDetails("Ank","Na",3);

Output
The name of the student is Ank
the roll no of the student is 3
Ank
Na
3

– Method Overriding
// Method Overriding Example
// Base Class

class Parent {

void show() { System.out.println("Parent's show()"); }

// Inherited class

class Child extends Parent {

// This method overrides show() of Parent

@Override void show()

super.show();

System.out.println("Child's show()");

// Driver class

class Main {

public static void main(String[] args)

Parent obj = new Child();

obj.show();

Output
Parent's show()
Child's show()

9. What is Inheritance? What is its purpose?

The idea of inheritance is simple, a class is derived from another class and uses data
and implementation of that other class. The class which is derived is called child or
derived or subclass and the class from which the child class is derived is called
parent or base or superclass.
The main purpose of Inheritance is to increase code reusability. It is also used to
achieve Runtime Polymorphism.
// an example of inheritance

class Student {

public void read() {

System.out.println("The student is reading");

class SchoolStudent extends Student {

public void read(String book) {

System.out.println("the student is reding "+ book);

10. What are access specifiers? What is their significance in OOPs?

Access specifiers are special types of keywords that are used to specify or control
the accessibility of entities like classes, methods, and so on. Private, Public,
and Protected are examples of access specifiers or access modifiers.
The key components of OOPs, encapsulation and data hiding, are largely achieved
because of these access specifiers.
class User {

public String userName;

protected String userEmail;

private String password;

public void setPassword(String password) {

this.password = password;

}
}

public class OOPS {

public static void main(String args[]) {

User user1 = new User();

user1.userName = "Vivek_Kumar_Yadav";

user1.setPassword("abcd@12345");

user1.userEmail = "abc@gmail.com";

11. What are the advantages and disadvantages of OOPs?

Advantages of OOPs Disadvantages of OOPs

The programmer should be well-skilled and

OOPs provides enhanced code
should have excellent thinking in terms of objects
reusability.
as everything is treated as an object in OOPs.

The code is easier to maintain and Proper planning is required because OOPs is a
update. little bit tricky.

It provides better data security by

OOPs concept is not suitable for all kinds of
restricting data access and avoiding
problems.
unnecessary exposure.

Fast to implement and easy to

redesign resulting in minimizing The length of the programs is much larger in
the complexity of an overall comparison to the procedural approach.
program.

12. What other paradigms of programming exist besides OOPs?

The programming paradigm is referred to the technique or approach of writing a
program. The programming paradigms can be classified into the following types:
1. Imperative Programming Paradigm
It is a programming paradigm that works by changing the program state through
assignment statements. The main focus in this paradigm is on how to achieve the
goal. The following programming paradigms come under this category:
1. Procedural Programming Paradigm: This programming paradigm is
based on the procedure call concept. Procedures, also known as routines or
functions are the basic building blocks of a program in this paradigm.
2. Object-Oriented Programming or OOP: In this paradigm, we visualize
every entity as an object and try to structure the program based on the state
and behavior of that object.
3. Parallel Programming: The parallel programming paradigm is the
processing of instructions by dividing them into multiple smaller parts and
executing them concurrently.
2. Declarative Programming Paradigm
Declarative programming focuses on what is to be executed rather than how it
should be executed. In this paradigm, we express the logic of a computation without
considering its control flow. The declarative paradigm can be further classified into:
1. Logical Programming Paradigm: It is based on formal logic where the
program statements express the facts and rules about the problem in the
logical form.
2. Functional Programming Paradigm: Programs are created by applying
and composing functions in this paradigm.
3. Database Programming Paradigm: To manage data and information
organized as fields, records, and files, database programming models are
utilized.
13. What is the difference between Structured Programming and Object
Oriented Programming?
Structured Programming is a technique that is considered a precursor to OOP and
usually consists of well-structured and separated modules. It is a subset of
procedural programming. The difference between OOPs and Structured
Programming is as follows:

Object-Oriented Programming Structural Programming

Programming that is object-oriented is A program’s logical structure is provided by

built on objects having a state and structural programming, which divides
behavior. programs into their corresponding functions.

It follows a bottom-to-top approach. It follows a Top-to-Down approach.

Restricts the open flow of data to

No restriction to the flow of data. Anyone can
authorized parts only providing better
access the data.
data security.

Enhanced code reusability due to the

Code reusability is achieved by using
concepts of polymorphism and
functions and loops.
inheritance.

In this, methods are written globally

In this, the method works dynamically, making
and code lines are processed one by
calls as per the need of code for a certain time.
one i.e., Run sequentially.

Modifying and updating the code is Modifying the code is difficult as compared to
easier. OOPs.

Data is given more importance in

Code is given more importance.
OOPs.

14. What are some commonly used Object Oriented Programming

Languages?
OOPs paradigm is one of the most popular programming paradigms. It is widely
used in many popular programming languages such as:
 C++
 Java
  Python
 Javascript
 C#
 Ruby
15. What are the different types of Polymorphism?
Polymorphism can be classified into two types based on the time when the call to the
object or function is resolved. They are as follows:
1. Compile Time Polymorphism
2. Runtime Polymorphism

A) Compile-Time Polymorphism
Compile time polymorphism, also known as static polymorphism or early binding is
the type of polymorphism where the binding of the call to its code is done at the
compile time. Method overloading or operator overloading are examples of
compile-time polymorphism.
B) Runtime Polymorphism
Also known as dynamic polymorphism or late binding, runtime polymorphism is the
type of polymorphism where the actual implementation of the function is determined
during the runtime or execution. Method overriding is an example of this method.

16. What is the difference between overloading and overriding?

A compile-time polymorphism feature called overloading allows an entity to have
numerous implementations of the same name. Method overloading and operator
overloading are two examples.
Overriding is a form of runtime polymorphism where an entity with the same name
but a different implementation is executed. It is implemented with the help of virtual
functions.
17. Are there any limitations on Inheritance?
Yes, there are more challenges when you have more authority. Although inheritance
is a very strong OOPs feature, it also has significant drawbacks.
 As it must pass through several classes to be implemented, inheritance
takes longer to process.
 The base class and the child class, which are both engaged in inheritance,
are also closely related to one another (called tightly coupled). Therefore,
if changes need to be made, they may need to be made in both classes at
the same time.
 Implementing inheritance might be difficult as well. Therefore, if not
implemented correctly, this could result in unforeseen mistakes or
inaccurate outputs.

18. What different types of inheritance are there?

Inheritance can be classified into 5 types which are as follows:

1. Single Inheritance: Child class derived directly from the base class
2. Multiple Inheritance: Child class derived from multiple base classes.
3. Multilevel Inheritance: Child class derived from the class which is also
derived from another base class.
4. Hierarchical Inheritance: Multiple child classes derived from a single
base class.
5. Hybrid Inheritance: Inheritance consisting of multiple inheritance types
of the above specified.
// an example of single inheritance

class Father {

// any properties and function specific to father

class Son extends Father {

//inherits the properties and functions of father

}

// an example of hierarchial inheritance

class Father {

// any properties and function specific to father

class Son extends Father {

//inherits the properties and functions of father

class Daughter extends Father {

//inherits the properties and functions of father

}

19. What is an interface?

A unique class type known as an interface contains methods but not their definitions.
Inside an interface, only method declaration is permitted. You cannot make objects
using an interface. Instead, you must put that interface into use and specify the
procedures for doing so.

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

Both abstract classes and interfaces are special types of classes that just include the
declaration of the methods, not their implementation. An abstract class is completely
distinct from an interface, though. Following are some major differences between an
abstract class and an interface.
Abstract Class Interface

When an abstract class is inherited,

When an interface is implemented, the
however, the subclass is not required to
subclass is required to specify all of the
supply the definition of the abstract method
interface’s methods as well as their
until and unless the subclass actually uses
implementation.
it.

A class that is abstract can have both An interface can only have abstract
abstract and non-abstract methods. methods.

An abstract class can have final, non-final, The interface has only static and final
static and non-static variables. variables.

Abstract class doesn’t support multiple An interface supports multiple

inheritance. inheritance.

21. 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 actually initialize the class members and methods when they are
created, using memory in the process.
22. Is it always necessary to create objects from class?
No. If the base class includes non-static methods, an object must be constructed. But
no objects need to be generated if the class includes static methods. In this instance,
you can use the class name to directly call those static methods.

23. What is the difference between a structure and a class in C++?

The structure is also a user-defined datatype in C++ similar to the class with the
following differences:
 The major difference between a structure and a class is that in a structure,
the members are set to public by default while in a class, members are
private by default.
 The other difference is that we use struct for declaring structure
and class for declaring a class in C++.
24. What is Constructor?
A constructor is a block of code that initializes the newly created object. A
constructor resembles an instance method but it’s not a method as it doesn’t have a
return type. It generally is the method having the same name as the class but in some
languages, it might differ. For example:
In python, a constructor is named __init__.
In C++ and Java, the constructor is named the same as the class name.
Example:

class Student {

String name;

String surname;

int rollNo;

Student()

System.out.println("contructor is called");

}
}

25. What are the various types of constructors in C++?

The most common classification of constructors includes:
1. Default Constructor
2. Non-Parameterized Constructor
3. Parameterized Constructor
4. Copy Constructor
1. Default Constructor
The default constructor is a constructor that doesn’t take any arguments. It is a non-
parameterized constructor that is automatically defined by the compiler when no
explicit constructor definition is provided.
It initializes the data members to their default values.
2. Non-Parameterized Constructor
It is a user-defined constructor having no arguments or parameters.
Example:
class Student {

String name;

String surname;

int rollNo;

Student()

System.out.println("Non-parameterized contructor is called");

}
}

3. Parameterized Constructor
The constructors that take some arguments are known as parameterized constructors.
Example:

class Student {

String name;

String surname;

int rollNo;

Student(String studentName, String studentSurname, int studentRollNo)

System.out.println("Constructor with argument is called");

}
}
4. Copy Constructor
A copy constructor is a member function that initializes an object using another
object of the same class.
Example:

class Student {

String name, surname; int rollNo;

Student(Student student) // copy constructor

this.name = student.name;

this.surname=student.surname;

this.rollNo= student.rollNo;

}
}

n Python, we do not have built-in copy constructors like Java and C++ but we can
make a workaround using different methods.

26. What is a destructor?

A destructor is a method that is automatically called when the object is made of
scope or destroyed.
In C++, the destructor name is also the same as the class name but with the (~) tilde
symbol as the prefix.
In Python, the destructor is named __del__.

class base {

public:

~base() { cout << "This is a destructor"; }

}
In Java, the garbage collector automatically deletes the useless objects so there is no
concept of destructor in Java. We could have used finalize() method as a
workaround for the java destructor but it is also deprecated since Java 9.

27. Can we overload the constructor in a class?

Yes We can overload the constructor in a class in Java. Constructor Overloading is
done when we want constructor with different constructor with different
parameter(Number and Type).

28. Can we overload the destructor in a class?

No. A destructor cannot be overloaded in a class. The can only be one destructor
present in a class.

29. What is the virtual function?

A virtual function is a function that is used to override a method of the parent class
in the derived class. It is used to provide abstraction in a class.
In C++, a virtual function is declared using the virtual keyword,
In Java, every public, non-static, and non-final method is a virtual function.
Python methods are always virtual.
Example:

class base {

void func()

System.out.printIn("This is a virtual function")

}
}

30. What is pure virtual function?

A pure virtual function, also known as an abstract function is a member function that
doesn’t contain any statements. This function is defined in the derived class if
needed.
Example:

abstract class base {

abstract void prVirFunc();

}
In Python, we achieve this using @abstractmethod from the ABC (Abstract Base
Class) module.