1. What is OOP?
OOP is a programming paradigm based on objects that contain data (attributes) and code
(methods). Objects are instances of classes, which act as blueprints.
2. Key Concepts
• Class: A template defining attributes and methods.
• Object: An instance of a class with its own data and behavior.
3. Procedural vs. Object-Oriented Programming
Feature Procedural Programming OOP
Approach Step-by-step execution Models real-world entities
Data Handling Global access, less secure Encapsulation for security
Code Reusability Limited High (Inheritance, Polymorphism)
Scalability Harder for large systems Easily scalable
Modularity Uses functions Uses classes and objects
4. Why Use OOP?
• Modularity: Divides code into reusable components.
• Code Reusability: Reduces duplication with inheritance.
• Scalability: Easily extends functionality.
• Security: Protects data using encapsulation.
5. Real-Life OOP Example (Bank System)
• Classes: Account, Customer, Transaction
• Objects: Raj’s Account, John’s Transaction
• Attributes: Account number, balance
• Methods: deposit(), withdraw(), transfer()
6. Class & Object in Java
Class Example:
class Employee {
private int salary;
public String employeeName;
public void setName(String s) {
employeeName = s;
Object Creation:
Employee obj1 = new Employee();
obj1.setName("Raj");
7. Attributes & Behaviors
• Attributes: Data inside an object (e.g., employeeName, salary).
• Behaviors: Actions an object can perform (e.g., setName(), getSalary()).
8. Memory Management in Java
• Stack Memory: Stores method calls, primitive data, and references.
• Heap Memory: Stores actual objects.
• Garbage Collection: Unused objects are automatically deleted.
Constructor in Java
Definition:
A constructor is a special method in a class used to initialize objects when they are created.
It has the same name as the class and no return type.
Types of Constructors:
1. Non-parameterized Constructor
o Does not take arguments.
o Used to initialize default values.
class Employee {
Employee() {
System.out.println("Employee created!");
}
}
2. Parameterized Constructor
o Accepts arguments to initialize object attributes.
class Employee {
String employeeName;
int salary;
Employee(String name, int salary) {
this.employeeName = name;
this.salary = salary;
3. Copy Constructor
o Creates a new object by copying attributes of an existing object.
class Employee {
String employeeName;
int salary;
Employee(Employee e) {
this.employeeName = e.employeeName;
this.salary = e.salary;
Concepts Related to Constructors:
• Constructor Chaining:
o One constructor calls another using this().
o Reduces code duplication.
• Constructor Overloading:
o Multiple constructors with different parameters allow flexible object creation.
class Employee {
String employeeName;
int salary;
Employee() {
this("Unknown", 0);
Employee(String name, int salary) {
this.employeeName = name;
this.salary = salary;
Advantages:
Object Initialization – Ensures objects start with default/user-defined values.
Code Reusability – Avoids repeated code for initializing objects.
Improved Readability – Organizes object creation logic effectively.
Encapsulation (Data Hiding)
• Definition: Bundling of data (attributes) and methods into a single unit (class) to
protect data from unauthorized access.
• Key Concept:
o Private attributes (fields) restrict direct access.
o Getter & Setter methods provide controlled access.
o Ensures data security, modularity, flexibility, and reduces complexity.
• Example:
class BankAccount {
private double balance;
public double getBalance() { return balance; }
public void deposit(double amount) { if (amount > 0) balance += amount; }
}
Access Modifiers
Defines the visibility of class members.
Modifier Class Package Subclass World
Public
Protected
Default
Private
1. Public: Accessible everywhere.
public String name;
public void showName() { System.out.println(name); }
2. Private: Accessible only within the class.
private double balance;
public double getBalance() { return balance; }
3. Protected: Accessible within the package and subclasses.
protected String type;
4. Default (No modifier): Accessible within the same package.
void showMessage()
{ System.out.println("Same package access."); }
Inheritance
Inheritance allows a child class to inherit properties and methods from a parent class,
promoting code reuse and hierarchy.
Types of Inheritance in Java
1. Single Inheritance - One class inherits from another.
2. Multilevel Inheritance - A class inherits from a child class, forming a chain.
3. Hierarchical Inheritance - Multiple classes inherit from a single parent.
Key Concepts
• Parent Class (Superclass) - Provides common properties and methods.
• Child Class (Subclass) - Inherits and can modify or extend parent class functionality.
• Method Overriding - A subclass provides a new implementation of a parent class
method.
• super Keyword - Calls parent class methods or constructor.
• Access Modifiers - Control inheritance visibility (public, protected, private).
Multiple Inheritance & Diamond Problem
• Java does NOT support multiple inheritance in classes to avoid conflicts.
• Solution: Java allows multiple inheritance via interfaces, not classes.
Polymorphism
Polymorphism allows the same method or object to behave differently based on context.
Types of Polymorphism in Java
1. Compile-Time Polymorphism (Static Polymorphism)
o Achieved using Method Overloading.
o Method name remains the same, but parameters differ.
o Resolved at compile-time.
2. Run-Time Polymorphism (Dynamic Polymorphism)
o Achieved using Method Overriding.
o Subclass provides a specific implementation of a parent class method.
o Resolved at runtime (Late binding).
Key Differences: Overloading vs Overriding
Feature Overloading Overriding
Dependency Same class Parent-Child classes
Parameters Must be different Must be same
Return Type Can be different Must be same
Execution Compile-time Run-time
Advantages of Inheritance & Polymorphism
✔ Code Reusability – Avoid code duplication.
✔ Extensibility – Add new features without modifying existing code.
✔ Maintainability – Centralized changes reduce errors.
✔ Dynamic Behavior – Enables runtime method resolution.
Abstraction in Java
Abstraction hides implementation details and shows only the essential features. It helps
simplify complex systems and improve maintainability.
Key Features
• Hides Complexity: Only necessary details are exposed.
• Abstract Methods: Declared without implementation, to be defined by subclasses.
• Concrete Methods: Have implementation in abstract classes.
Benefits
Simplifies the system
Improves maintainability
Increases reusability
Enhances security
Ways to Achieve Abstraction
1. Abstract Classes
o Cannot be instantiated directly.
o Can have both abstract and concrete methods.
abstract class Animal {
abstract void sound();
void eat() { System.out.println("This animal eats food."); }
2. Interfaces
o Contains only abstract methods (until Java 8).
o Implemented by classes to provide behavior.
interface Animal { void sound(); void eat(); }
class Dog implements Animal {
public void sound() { System.out.println("Bark"); }
public void eat() { System.out.println("Eating"); }
Static & Default Methods in Interfaces
1. Static Methods (Java 8+)
o Called using the interface name.
interface Example {
static void staticMethod() { System.out.println("Static method."); }
Example.staticMethod();
2. Default Methods (Java 8+)
o Allows interfaces to have method implementations.
interface Example {
default void defaultMethod() { System.out.println("Default method."); }
class Demo implements Example {}
new Demo().defaultMethod();
Why?
o Enables adding new methods to interfaces without breaking existing
implementations.
Common Questions
Can an abstract class extend another abstract class? Yes, it inherits methods but
doesn’t need to implement them unless it's concrete.
Can an abstract class have a constructor? Yes, but it cannot be instantiated directly.
The constructor runs when a subclass is created.
Interface in Java
• A blueprint defining method signatures without implementation.
• Example:
interface Animal {
void eat();
void sleep();
class Dog implements Animal {
public void eat() { System.out.println("Dog eats bones."); }
public void sleep() { System.out.println("Dog sleeps."); }
• Key Points:
o No instance variables (only public static final constants).
o No constructors (interfaces cannot be instantiated).
o A class can implement multiple interfaces.
Multiple Interface Implementation
interface Flyable { void fly(); }
interface Swimmable { void swim(); }
class Duck implements Flyable, Swimmable {
public void fly() { System.out.println("Duck flies."); }
public void swim() { System.out.println("Duck swims."); }
Default & Static Methods in Interfaces
• Default Method (Introduced in Java 8)
interface Example {
default void defaultMethod() {
System.out.println("This is a default method.");
class Demo implements Example {
public static void main(String[] args) {
new Demo().defaultMethod();
}
o Provides default behavior to interfaces.
o Helps in backward compatibility.
• Static Method in Interface
interface Utility {
static void staticMethod() {
System.out.println("This is a static method.");
class Test {
public static void main(String[] args) {
Utility.staticMethod();
o Cannot be overridden by implementing classes.
Interface Inheritance
interface Animal { void eat(); }
interface Mammal extends Animal { void walk(); }
class Human implements Mammal {
public void eat() { System.out.println("Human eats."); }
public void walk() { System.out.println("Human walks."); }
Static Members in Java
Static Variables
• Shared among all instances.
• Example:
class Counter {
static int count = 0;
Counter() { count++; }
o count is shared across objects.
Static Methods
• Called without creating an instance.
• Example:
class MathUtils {
static int add(int a, int b) { return a + b; }
class Main {
public static void main(String[] args) {
System.out.println(MathUtils.add(5, 3));
Static Block
• Used for initializing static variables.
• Example:
class Example {
static int value;
static { value = 10; System.out.println("Static block executed."); }
Static vs Non-Static Interaction
• Static methods cannot directly access non-static variables.
• Can access via an instance:
class Example {
int instanceVar = 10;
static void staticMethod() {
Example obj = new Example();
System.out.println("Instance variable: " + obj.instanceVar);
Advantages of Static Members
• Memory efficient (loaded once).
• Utility methods (e.g., Math.sqrt()).
• Static blocks initialize shared resources.
Utility Class Example
class Utils {
static void printMessage(String message) {
System.out.println(message);
class Main {
public static void main(String[] args) {
Utils.printMessage("Hello, Static!");
Inner Classes in Java
Inner classes are defined within another class, allowing better encapsulation and logical
grouping. They have access to all members of the outer class.
Types of Inner Classes:
1. Static Nested Classes
o Declared using the static keyword.
o Can access only static members of the outer class.
o No reference to an outer class instance.
o Example:
class Outer {
static int x = 100;
static class Nested {
void display() { System.out.println(x); }
2. Non-Static Inner Classes
o Requires an instance of the outer class.
o Can access both static and non-static members.
o Example:
class Outer {
int y = 42;
class Inner {
void show() { System.out.println(y); }
3. Local Inner Classes
o Defined inside a method/block.
o Can access only final or effectively final local variables.
o Example:
class Outer {
void method() {
int localVar = 10;
class LocalInner {
void show() { System.out.println(localVar); }
}
}
4. Anonymous Inner Classes
o Created without a name, often for one-time use.
o Useful for implementing interfaces or extending classes inline.
o Example:
abstract class Greeting {
abstract void sayHello();
public class Main {
public static void main(String[] args) {
Greeting g = new Greeting() {
void sayHello() { System.out.println("Hello, World!"); }
};
Relationships Between Classes
1. Association
• A general relationship where one class interacts with another.
• Types:
o One-to-One: Person ↔ Passport
o One-to-Many: Teacher ↔ Students
o Many-to-Many: Students ↔ Courses
2. Aggregation
• A "has-a" relationship with weak bonding.
• Objects can exist independently.
• Example: Department contains Employees, but employees exist independently.
class Department {
List<Employee> employees;
Department(List<Employee> emp) { this.employees = emp; }
3. Composition
• A strong "part-of" relationship where the dependent object cannot exist
independently.
• Example: House contains Rooms, and if the house is destroyed, rooms cease to exist.
class House {
List<Room> rooms = new ArrayList<>();
House() { rooms.add(new Room("Living Room")); }
Comparison Table
Aspect Association Aggregation Composition
Relationship General Weak Strong
Ownership No Has but doesn’t own Owns completely
Contained class can exist Contained class depends on
Independence Independent
independently whole
Teacher-
Example Employee-Department Car-Engine
Student
What is Object Cloning?
Object cloning is creating an exact copy of an object with a different memory location. It is
done using the Cloneable interface and the clone() method of the Object class.
Key Points:
• Cloned objects are independent of the original.
• Shallow cloning shares references, while deep cloning creates new copies.
Why Use Cloning?
• Efficiency: Avoids reinitialization of objects.
• Decoupling: Prevents unintended changes.
• State Preservation: Useful for undo/redo and caching.
• Prototyping: Used in the Prototype Design Pattern.
Working of Cloning
1. Cloneable Interface – Marker interface to enable cloning.
2. clone() Method – Performs a shallow copy by default.
Types of Cloning
1. Shallow Cloning
• Copies primitive fields and references (not the actual objects).
• Changes in shared references affect both original and cloned objects.
• Uses super.clone() method.
Example:
class Address {
String city;
Address(String city) { this.city = city; }
class Person implements Cloneable {
String name;
Address address;
Person(String name, Address address) { this.name = name; this.address = address; }
protected Object clone() throws CloneNotSupportedException { return super.clone(); }
2. Deep Cloning
• Creates independent copies of all objects, including nested objects.
• Requires manual cloning of reference-type fields.
Example:
class Address implements Cloneable {
String city;
Address(String city) { this.city = city; }
protected Object clone() throws CloneNotSupportedException { return (Address)
super.clone(); }
class Person implements Cloneable {
String name;
Address address;
Person(String name, Address address) { this.name = name; this.address = address; }
protected Object clone() throws CloneNotSupportedException {
Person cloned = (Person) super.clone();
cloned.address = (Address) address.clone();
return cloned;
Shallow vs Deep Cloning
Aspect Shallow Cloning Deep Cloning
Primitive Fields Copied Copied
Object References Shared Independent
Nested Objects Overriding? No Yes
Use Case Simple objects Objects with mutable references
Exception Handling in Java
Exception handling manages runtime errors and ensures the normal flow of a program.
Why Exception Handling?
• Prevents program crashes.
• Improves debugging.
• Separates normal and error-handling code.
• Ensures proper resource management.
Try-Catch Mechanism
• try block: Contains risky code.
• catch block: Handles exceptions.
• finally block: Always executes, used for resource cleanup.
Example:
try {
int num = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("Cannot divide by zero!");
} finally {
System.out.println("Execution completed.");
throw vs throws
Feature throw throws
Declare that a method may throw
Purpose Manually throw an exception
exceptions
Usage Inside a method In method signature
throw new
Example void divide() throws ArithmeticException
ArithmeticException("Error");
Custom Exceptions
User-defined exceptions help define specific error conditions.
class CustomException extends Exception {
CustomException(String message) {
super(message);
Checked vs Unchecked Exceptions
Type Description Examples
Checked Must be handled (compile-time) IOException, SQLException
Type Description Examples
Unchecked Occur at runtime NullPointerException, ArithmeticException
Example:
• Checked:
File file = new File("test.txt");
Scanner reader = new Scanner(file);
• Unchecked:
int num = 10 / 0;
Real-Life Example
Handling file exceptions:
try {
File file = new File("data.txt");
Scanner sc = new Scanner(file);
} catch (FileNotFoundException e) {
System.out.println("File not found!");
Generics in Java (Short Notes)
Introduction
• Introduced in Java 5 to ensure type safety and code reusability.
• Allows defining classes, interfaces, and methods that work with multiple data types.
Key Benefits
✔ Prevents ClassCastException (runtime error due to invalid type casting).
✔ Provides compile-time type checking.
✔ Reduces code redundancy.
Example Without Generics (Before Java 5)
ArrayList list = new ArrayList();
list.add("Hello");
list.add(100);
String str = (String) list.get(1);
Drawbacks: Allows different types, requires type casting, risks ClassCastException.
Example With Generics
ArrayList<String> list = new ArrayList<>();
list.add("Hello");
// list.add(100); // Compile-time error (Prevents mistakes)
String str = list.get(0);
Advantages: Type safety, no explicit type casting, better maintainability.
1. Generic Classes
• A single class works for multiple data types.
Syntax:
class Box<T> {
private T value;
public void set(T value) { this.value = value; }
public T get() { return value; }
Benefits: Works for any data type, improves code reusability.
2. Generic Methods
• Allows different data types in the same method.
Syntax:
class Example {
public <T> void print(T data) {
System.out.println("Data: " + data);
Benefits: Works for multiple types, avoids method overloading.
3. Bounded Type Parameters
• Restricts generic types to specific parent classes (ensures type safety).
Syntax:
class NumericBox<T extends Number> {
private T num;
public double square() { return num.doubleValue() * num.doubleValue(); }
Allowed: Integer, Double, etc. Not Allowed: String.
4. Wildcard Types (?)
• Used when the exact type is unknown.
✔ Upper Bounded (? extends T) – Allows reading, restricts writing.
public static void printList(List<? extends Number> list) {
for (Number num : list) { System.out.print(num + " "); }
✔ Lower Bounded (? super T) – Allows writing, restricts reading.
public static void addNumbers(List<? super Integer> list) {
list.add(10);
5. Raw Types (Not Recommended)
• Using generics without specifying type parameters.
Box rawBox = new Box();
rawBox.set("Hello");
Integer num = (Integer) rawBox.get();
Avoid raw types to prevent runtime errors.
6. Type Erasure
• Generics exist only at compile-time (removed at runtime).
• Compiler replaces generic types with raw types (Object or upper bound).
class Box<T> {
T value;
void set(T value) {
this.value = value;
T get() {
return value;
✔ After Compilation (Erased Generics):
class Box {
Object value;
void set(Object value) {
this.value = value;
Object get() {
return value;
}}
Impact: No runtime type information, cannot use instanceof with generics, generic
arrays not allowed.
Summary
Feature Purpose Key Benefit
Generic Class Works for multiple types Code reuse
Feature Purpose Key Benefit
Generic Method Works with different types Avoids overloading
Bounded Type (extends) Restricts to specific type Type safety
Wildcards (?) Allows unknown types Flexibility
Raw Types Uses generics without type Risky, avoid using
Type Erasure Removes generics at runtime Backward compatibility
File Handling in OOPs (Java)
File Handling refers to reading and writing files for data storage and retrieval.
Common File Operations
• Create a file
• Read from a file
• Write to a file
• Append data
• Delete a file
import java.io.File;
import java.io.IOException;
class Main {
public static void main(String[] args) {
try {
File file = new File("example.txt");
if (file.createNewFile())
System.out.println("File created: " + file.getName());
} catch (IOException e) {
e.printStackTrace();
}
Handling Errors: IOException is used for handling errors like invalid paths or permission
issues.
File Class (java.io.File)
• createNewFile(): Creates a file
• exists(): Checks file existence
• delete(): Deletes a file
• getAbsolutePath(): Returns file path
• length(): Returns file size
• canRead(), canWrite(): Checks permissions
Reading and Writing Files
Writing to a file using BufferedWriter:
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
class Main {
public static void main(String[] args) {
try (BufferedWriter writer = new BufferedWriter(new FileWriter("example.txt"))) {
writer.write("Hello, File Handling!");
} catch (IOException e) {
e.printStackTrace();
Reading a file using BufferedReader:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
class Main {
public static void main(String[] args) {
try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
System.out.println(reader.readLine());
} catch (IOException e) {
e.printStackTrace();
Logging with File Handling
import java.io.*;
class Logger {
private String path;
Logger(String path) throws IOException {
this.path = path;
new File(path).createNewFile();
void log(String message) {
try (BufferedWriter writer = new BufferedWriter(new FileWriter(path, true))) {
writer.write(message);
writer.newLine();
} catch (IOException e) {
System.out.println("Logging failed!");
}}
Common Issues
• FileNotFoundException: Check file existence before reading.
• IOException: Handle with try-catch.
• Resource Leaks: Use try-with-resources to auto-close files
