OOPs using Java Notes.

[Only OOPs concepts]

 What are the main principles of Object-Oriented Programming?

1. Encapsulation: This principle involves bundling the data
(attributes) and methods (functions) that operate on the
data into a single unit, or class.
It restricts direct access to some of the object's
components, which helps to prevent unintended
interference and misuse of the data.

2. Inheritance : Inheritance allows a new class (subclass) to

inherit properties and behaviors (methods) from an
existing class (superclass).
This promotes code reusability and establishes a
hierarchical relationship between classes, enabling the
creation of more complex systems with less redundancy.

3. Polymorphism : Polymorphism enables objects of different

classes to be treated as objects of a common superclass.
It allows methods to be defined in a way that they can
operate on objects of different types, enhancing flexibility
and the ability to extend functionality without modifying
existing code.

4. Abstraction : Abstraction focuses on hiding the complex

implementation details and exposing only the essential
features of an object.
This simplifies interaction with the object and allows users
to work with a simplified model, making it easier to
understand and use.

5. Object and Class : A class is a blueprint for creating

objects, defining the properties and behaviors that the
objects created from the class will have.
 An object is an instance of a class, representing a specific
entity with its own state and behavior, allowing for the
modeling of real-world entities in programming.

 Difference between Procedural and Object-Oriented

Programming?

1. Definition : Procedural Programming focuses on a sequence of

actions or procedures to be performed, while Object-Oriented
Programming (OOP) is based on the concept of objects that
encapsulate data and behavior.

2. Structure : In Procedural Programming, the program is structured

around functions and procedures, whereas OOP organizes code into
classes and objects, promoting modularity.

3. Data Handling : Procedural Programming treats data and functions

separately, while OOP combines data and functions into a single unit
(objects), enhancing data security.

4. Reusability : OOP promotes code reusability through inheritance and

polymorphism, allowing new classes to be created based on existing
ones, unlike Procedural Programming which often requires rewriting
code.

5. Maintenance : OOP generally leads to easier maintenance and

modification of code due to its modular nature, while Procedural
Programming can become complex and harder to manage as the
codebase grows.

2. Classes and Objects

 How to create a class and object in Java? Write an example.

A class is a blueprint for creating objects, which are instances of the

class. To create a class, you use the `class` keyword followed by the
class name. Inside the class, you can define attributes (variables) and
methods (functions) that describe the behavior of the objects. To
create an object, you use the `new` keyword followed by the class
constructor.

For example:-
 class Car {

String color;

int year;

void displayInfo() {

System.out.println("Color: " + color + ", Year: " + year);

} }

public class Main {

public static void main(String[] args) {

Car myCar = new Car();

myCar.color = "Red";

myCar.year = 2020;

myCar.displayInfo();

} }

 What is the difference between a class and an object?

- A class is a blueprint or template for creating objects, defining

properties and behaviors.

- An object is an instance of a class, representing a specific entity with

its own state and behavior.

- Classes encapsulate data and functions, while objects hold actual

data and can perform actions.

- Classes can be reused to create multiple objects, promoting code

reusability.

- Objects can interact with one another, while classes do not interact
directly.

- In object-oriented programming, classes facilitate abstraction, while

objects enable encapsulation.
  How is the new keyword used in Java to create objects? { ab
behncho ye mat puchhna ki ‘keyword’ kya hote hain 🤡. Btw
imp. Hai def. bhi}

In Java, the `new` keyword is used to create instances of classes,

which are known as objects. When you use `new`, it allocates memory
for the object and invokes the class constructor to initialize the object.
The syntax typically involves specifying the class name followed by
parentheses, such as `ClassName objectName = new ClassName();`.
This process allows you to create multiple objects from the same class,
each with its own state and behavior.

3. Encapsulation

 What is encapsulation, and why is it important in Java?

1. Definition : Encapsulation is a principle of OOP in Java that restricts

direct access to an object's data and methods, allowing them to be
accessed only through well-defined interfaces.

2. Data Hiding : By encapsulating data, Java protects the internal state

of an object from unintended interference and misuse, ensuring that
the object's data can only be modified through controlled methods.

3. Improved Maintainability: Encapsulation promotes modularity,

making it easier to maintain and update code. Changes to the internal
implementation of a class can be made without affecting other parts of
the program that rely on the class.

4. Enhanced Security: Encapsulation enhances security by preventing

unauthorized access to sensitive data. It allows developers to enforce
access controls, ensuring that only authorized methods can manipulate
the data.

5. Ease of Use : Encapsulation simplifies the interaction with complex

systems by providing a clear interface. Users of a class can work with
its methods without needing to understand the underlying
implementation details, leading to better usability.

 Write a program to demonstrate encapsulation using private

variables and getter/setter methods.

Example Question:
class Student {

private int rollNo;

private String name;

public void setRollNo(int rollNo) {

this.rollNo = rollNo;

public int getRollNo() {

return rollNo;

public void setName(String name) {

this.name = name;

public String getName() {

return name;

} }

4. Inheritance

 What is inheritance in Java? Explain its types.

o Single : A structure that consists of a single level of information

or categories, often used for straightforward data organization.

o Multilevel - A structure that includes multiple levels of

information, allowing for a more complex organization of data
with subcategories.

o Hierarchical : A tree-like structure where information is organized

in levels, with a clear parent-child relationship among categories.

o Hybrid (via Interfaces) : A combination of different organizational

structures, often utilizing interfaces to integrate various data
types and formats.
  What is the super keyword in Java?

The super keyword in Java is used to refer to the immediate parent

class of the current object.

It allows access to the parent class's methods and constructors,

enabling the subclass to inherit and utilize the properties and
behaviors of its superclass.

This is particularly useful for overriding methods and accessing hidden

variables.

 Write a program to demonstrate multilevel inheritance.

Example:

class Animal {

void eat() {

System.out.println("This animal eats food.");

} }

class Mammal extends Animal {

void walk() {

System.out.println("This mammal walks.");

} }

class Dog extends Mammal {

void bark() {

System.out.println("This dog barks.");

} }

public class TestInheritance {

public static void main(String[] args) {

Dog dog = new Dog();

dog.eat();

dog.walk();

dog.bark();
 } }

5. Polymorphism

 What is polymorphism? Explain its types:

- **Polymorphism Definition**: Polymorphism is a core concept in

object-oriented programming that allows methods to do different
things based on the object it is acting upon, enabling a single interface
to represent different underlying forms (data types).

Types of Polymorphism :

1. Compile-Time Polymorphism :

- Also known as static polymorphism.

- Achieved through method overloading and operator overloading.

- Method overloading allows multiple methods with the same name

but different parameters (type, number, or both).

- Operator overloading allows operators to be redefined for user-

defined types.

- Resolved during the compile time, hence the name.

2. Runtime Polymorphism :

- Also known as dynamic polymorphism.

- Achieved through method overriding, where a subclass provides a

specific implementation of a method that is already defined in its
superclass.

- The decision of which method to invoke is made at runtime based

on the object type.

- Facilitates flexibility and the ability to extend code without

modifying existing code.

 What is method overloading? Write a program to demonstrate

it.
1. Definition : Method overloading is a feature in programming that
allows a class to have more than one method with the same name, but
different parameters (type, number, or both).

2. Purpose : It enhances the readability of the program and allows

methods to perform similar functions with different types of input.

3. How it Works : The compiler differentiates the methods based on

the method signature, which includes the method name and the
parameter list.

Benefits:
- Increases code clarity and usability.

- Reduces the need for different method names for similar

operations.

- Facilitates easier maintenance and updates to the code.

class MathOperations {

// Method to add two integers

int add(int a, int b) {

return a + b;

// Method to add three integers

int add(int a, int b, int c) {

return a + b + c;

// Method to add two double values

double add(double a, double b) {

return a + b;

} }

public class Main {

 public static void main(String[] args) {

MathOperations math = new MathOperations();

System.out.println(math.add(5, 10)); // Calls the first

method

System.out.println(math.add(5, 10, 15)); // Calls the second

method

System.out.println(math.add(5.5, 10.5)); // Calls the third

method

} }

 What is method overriding? Write a program to demonstrate it.

- What is Method?

- A method is a block of code that performs a specific task.

- It is defined within a class and can be called to execute its code.

- Methods can take parameters and return values.

- What is Method Overriding?

- Method overriding occurs when a subclass provides a specific

implementation of a method that is already defined in its superclass.

- It allows a subclass to modify the behavior of a method inherited

from a parent class.

- The method in the subclass must have the same name, return type,
and parameters as the method in the superclass.

-Program to Demonstrate Method Overriding:

- Define a superclass with a method.

- Create a subclass that overrides the method.

- Instantiate the subclass and call the overridden method to see the
effect.

Example Question:

 Difference between overloading and overriding?

6. Abstraction

 What is abstraction in Java? How is it achieved?\

- Definition of Abstraction: Abstraction in Java is a fundamental

concept that focuses on hiding the complex implementation details
and showing only the essential features of an object.

- Purpose : It helps in reducing programming complexity and increases

efficiency by allowing the programmer to focus on interactions at a higher
level.

1. Abstract Classes : These are classes that cannot be instantiated

and can contain abstract methods (without a body) as well as concrete
methods (with a body).

2. Interfaces : An interface is a reference type in Java that can contain

only constants, method signatures, default methods, static methods,
and nested types. It provides a way to achieve abstraction by defining
a contract that implementing classes must follow.

-Benefits :

- Promotes code reusability.

- Enhances maintainability and flexibility.

- Facilitates a clear separation between interface and implementation.

 What is the difference between abstract classes and

interfaces?

1. Definition :

- An abstract class is a class that cannot be instantiated and may

contain both abstract methods (without implementation) and concrete
methods (with implementation).

- An interface is a contract that defines a set of methods that a class

must implement, without providing any implementation itself.

2. Implementation:

- Abstract classes can provide some method implementations,

allowing for shared code among subclasses.
 - Interfaces cannot provide any method implementations (prior to
Java 8, after which default methods were introduced).

3. Inheritance:

- A class can inherit from only one abstract class (single inheritance).

- A class can implement multiple interfaces (multiple inheritance),

allowing for more flexible design.

4. Access Modifiers:

- Abstract classes can have access modifiers (public, protected,

private) for their methods and properties.

- All methods in an interface are implicitly public and cannot have

access modifiers.

5. Fields :

- Abstract classes can have fields (attributes) and can define

constructors.

- Interfaces cannot have instance fields; they can only have static
final constants.

6. Use Cases:

- Abstract classes are used when there is a common base with shared
code and behavior among related classes.

- Interfaces are used to define a contract for classes that may not be
related but need to implement the same methods.

7. Polymorphism: Both abstract classes and interfaces can be used to

achieve polymorphism,

but interfaces provide a more flexible approach to achieve it across

unrelated classes.

 Write a program to demonstrate abstraction using an abstract

class.

Example:

abstract class Animal {

abstract void makeSound(); // Abstract method

 void eat() {

System.out.println("This animal eats food.");

} }

class Dog extends Animal {

void makeSound() {

System.out.println("Bark");

} }

public class TestAbstraction {

public static void main(String[] args) {

Animal dog = new Dog();

dog.makeSound();

dog.eat();

} }

7. Constructors

 What is a constructor? How is it different from a method?

- A constructor is a special type of method in object-oriented

programming that is automatically called when an instance (object) of
a class is created.

- The primary purpose of a constructor is to initialize the object's

properties or attributes with specific values.

- Constructors have the same name as the class they belong to and do
not have a return type, not even void.

- A method, on the other hand, is a function defined within a class that

performs a specific action or operation on the object's data.

- Unlike constructors, methods can have different names and must

specify a return type.

---
 - Constructors are invoked only once when an object is instantiated,
while methods can be called multiple times on an object after it has
been created.

- Constructors can take parameters to allow for the initialization of an

object with specific values, whereas methods can also take
parameters but are used for executing actions rather than initialization.

 What are the types of constructors in Java (default,

parameterized)?

1. Default Constructor : This constructor does not take any

parameters. It initializes object attributes with default values. If no
constructor is explicitly defined in a class, the Java compiler
automatically provides a default constructor. For example:

public class Example {

int number;

String text;

// Default constructor

public Example() {

number = 0;

text = "Default";

} }

2. Parameterized Constructor : This constructor takes parameters to

initialize object attributes with specific values provided at the time of
object creation. It allows for more flexibility in object initialization. For
example:

public class Example {

int number;

String text;

// Parameterized constructor

public Example(int num, String str) {

 number = num;

text = str;

} }

8. Interfaces

 What is an interface? How is it different from an abstract

class?

- An interface is a contract that defines a set of methods and

properties that a class must implement, without providing any
implementation details.

- An abstract class can provide some implementation and can contain

both abstract methods (without implementation) and concrete
methods (with implementation).

- Interfaces support multiple inheritance, allowing a class to implement

multiple interfaces, while a class can only inherit from one abstract
class.

- An interface cannot have any state (fields), whereas an abstract class

can have fields and maintain state.

- Interfaces are used to achieve abstraction and polymorphism, while

abstract classes are used when there is a common base with shared
code among derived classes.

 Can a class implement multiple interfaces? Write a program.

Yes, a class can implement multiple interfaces in languages like Java

and C#. This allows a class to inherit the abstract methods of multiple
interfaces, enabling a form of multiple inheritance.

Here’s a simple Java program demonstrating a class implementing

multiple interfaces:

```java

// Define the first interface

interface Animal {

void eat();
}

// Define the second interface

interface Pet {

void play();

// Class Dog implements both Animal and Pet interfaces

class Dog implements Animal, Pet {

@Override

public void eat() {

System.out.println("The dog is eating.");

@Override

public void play() {

System.out.println("The dog is playing.");

// Main class to test the implementation

public class Main {

public static void main(String[] args) {

Dog myDog = new Dog();

myDog.eat(); // Output: The dog is eating.

myDog.play(); // Output: The dog is playing.

}
 }

```

In this example, the `Dog` class implements both the `Animal` and
`Pet` interfaces, providing concrete implementations for the `eat` and
`play` methods.

 Write a program to demonstrate multiple inheritance using

interfaces.

Example:

interface Printable {

void print();

interface Showable {

void show();

class Demo implements Printable, Showable {

public void print() {

System.out.println("Print Method");

public void show() {

System.out.println("Show Method");

} }

public class TestInterface {

public static void main(String[] args) {

Demo obj = new Demo();

obj.print();

obj.show();
 } }

9. Access Modifiers

o Private : This access modifier restricts visibility to the

class itself, meaning that the members (variables and
methods) declared as private cannot be accessed from
outside the class.

This is useful for encapsulation, ensuring that sensitive

data is protected from external interference.

o Default : Also known as package-private, this modifier

allows access to classes within the same package.

If no access modifier is specified, the default access level

is applied, enabling a level of visibility that is broader
than private but more restricted than protected and
public.

o Protected : This modifier allows access to the class itself,

subclasses, and classes within the same package.

is useful for inheritance, enabling subclasses to access

and modify the protected members of their parent class.

o Public : Members declared as public are accessible from

any other class in any package.

This modifier is used when you want to expose certain

functionalities or data to the entire application,
promoting maximum visibility and accessibility.

 Explain the access levels with examples.

Access Levels Overview : Access levels determine the permissions

granted to users for interacting with data and resources within a
system.

1. Public Access :

Definition: Information is available to anyone without restrictions.

 Example : A public website where anyone can view content without
logging in.

2. Read-Only Access :

- Definition : Users can view data but cannot make any changes.

Example : A shared document where team members can read but

not edit the content.

3. Write Access :

- Definition : Users can modify existing data and add new data.

- Example : A collaborative project folder where team members can

add files and edit documents.

- 4. Admin Access :

-Definition : Full control over the system, including the ability to

change settings, manage users, and delete data.

-Example : A system administrator who can configure server settings

and manage user accounts.

5. Restricted Access :

- Definition : Limited permissions based on user roles or specific

criteria.

Example : An employee who can access only their department's files

but not those of other departments.

6. Temporary Access :

Definition: Permissions granted for a limited time, often for specific

tasks or projects.

Example : A contractor given access to a project folder for the

duration of their contract.

7. Role-Based Access Control (RBAC) :

Definition : Access is granted based on the user's role within the

organization.

Example: A manager has different access rights compared to a

regular employee, allowing them to approve requests and view
sensitive data.
10. Exception Handling

 What is exception handling? Explain try, catch, finally blocks.

- Definition of Exception Handling: Exception handling is a

programming construct that allows developers to manage errors and
exceptional conditions in a controlled manner, ensuring that the
program can continue to run or terminate gracefully.

- Purpose: The main goal of exception handling is to separate error-

handling code from regular code, making programs easier to read and
maintain.

- Try Block:

- The `try` block contains the code that may potentially throw an
exception.

- It is used to wrap the code that needs to be monitored for errors.

- If an exception occurs within the `try` block, the control is

transferred to the corresponding `catch` block.

- Catch Block:

- The `catch` block is used to handle the exception that was thrown in
the `try` block.

- It allows the programmer to define how to respond to specific

exceptions.

- Multiple `catch` blocks can be used to handle different types of

exceptions.

- Finally Block :

- The `finally` block is optional and is executed after the `try` and
`catch` blocks, regardless of whether an exception was thrown or
caught.

- It is typically used for cleanup activities, such as closing files or

releasing resources.

- The `finally` block ensures that certain code runs no matter what,
providing a reliable way to execute cleanup code.
 - Flow of Control:

- If an exception occurs in the `try` block, the control is transferred to

the `catch` block.

- If no exception occurs, the `catch` block is skipped, and the `finally`

block is executed.

- If an exception is not caught, it may propagate up the call stack,

potentially terminating the program.

- Benefits:

- Improves program reliability by handling errors gracefully.

- Enhances code readability and maintainability by separating error

handling from regular logic.

- Provides a structured way to manage exceptions, making debugging

easier.

 What is the difference between checked and unchecked

exceptions?

 Write a program to handle exceptions using a try-catch block.

Example:

public class ExceptionDemo {

public static void main(String[] args) {

try {

int result = 10 / 0;

} catch (ArithmeticException e) {

System.out.println("Cannot divide by zero!");

} finally {

System.out.println("End of program.");

}
 What is multithreading, and how does it relate to OOP
concepts in Java?

Multithreading is a programming concept that allows multiple threads

to execute concurrently within a single process. In Java, a thread is a
lightweight subprocess, the smallest unit of processing that can be
scheduled by the operating system. Multithreading enables efficient
use of CPU resources, improves application performance, and
enhances the responsiveness of applications, especially in scenarios
where tasks can be performed simultaneously, such as in graphical
user interfaces or server applications.

In relation to Object-Oriented Programming (OOP) concepts in Java,

multithreading can be integrated with key OOP principles such as
encapsulation, inheritance, and polymorphism.

1. Encapsulation : In multithreaded applications, encapsulation helps in

managing the state of shared resources. By encapsulating data and
providing synchronized methods, developers can prevent data
inconsistency and ensure that only one thread can access a resource at
a time.

2. Inheritance : Java allows the creation of thread classes through

inheritance. By extending the `Thread` class or implementing the
`Runnable` interface, developers can create new thread types that
inherit properties and behaviors from existing classes, promoting code
reuse and organization.

3. Polymorphism : Polymorphism in multithreading can be observed

when different thread classes implement the same interface or extend
the same base class. This allows for dynamic method invocation, where
the appropriate method is called based on the object type at runtime,
enabling flexible and scalable thread management.

Overall, multithreading in Java not only enhances performance but also

aligns with OOP principles, allowing developers to create robust,
maintainable, and efficient applications.