Java is a fully object-oriented language, meaning everything in Java is associated with objects and classes.

🔍 OOP is based on these 4 major principles:
1. Encapsulation
2. Abstraction
3. Inheritance
4. Polymorphism

🎯 Why use OOP?
● It helps you structure large programs efficiently.
● Encourages modularity and code reuse.
● Makes software easier to maintain and extend.

✅ What is a Class?
A class is a blueprint or template for creating objects. It defines:
● Properties (also called fields or attributes)
● Behaviors (also called methods or functions)

📌 Syntax of a Class:
class ClassName {
// variables
// methods
}

✅ What is an Object?
An object is a real-world entity based on a class. It holds actual values.

🧪 Example:
class Student {
int id;
String name;
void display() {
System.out.println("ID: " + id);
System.out.println("Name: " + name);
}
}
public class Main {
public static void main(String[] args) {
Student s1 = new Student(); // Creating object
s1.id = 101;
s1.name = "Aman";
s1.display(); // Calling method
}
}
💬 Output:
ID: 101
Name: Aman

A constructor is a special method that runs automatically when an object is created.

🔧 Features:
● Same name as the class
● No return type (not even void)
● Used to initialize objects

✅ Types of Constructors:
A. Default Constructor:
class Bike {
Bike() {
System.out.println("Bike is created");
}
}
public class Main {
public static void main(String[] args) {
Bike b = new Bike(); // calls constructor
}
}
B. Parameterized Constructor:
class Car {
String model;
Car(String m) {
model = m;
}
void show() {
System.out.println("Model: " + model);
}
}
C. Constructor Overloading:
Multiple constructors with different arguments.
class Rectangle {
int length, width;
Rectangle() {
length = width = 0;
}
Rectangle(int l, int w) {
length = l;
width = w;
}
void area() {
System.out.println("Area: " + (length * width));
}
}

Encapsulation = Wrapping data (variables) and code (methods) together + restricting access.

✅ Example:
class Account {
private int balance = 1000;
public int getBalance() {
return balance;
}
public void deposit(int amount) {
if (amount > 0) {
balance += amount;
}
}
}
● balance is private
● Accessible only through public methods
● Prevents unauthorized access = Data Security

Abstraction = Hiding complex details and showing only what’s necessary.

✅ Example with Abstract Class:
abstract class Animal {
abstract void makeSound(); // abstract method
}
class Dog extends Animal {
void makeSound() {
System.out.println("Bark");
}
}
● makeSound() is declared in Animal but implemented in Dog
● User only knows that Dog can makeSound() — not how

Inheritance allows a class to inherit features (methods, variables) from another class.

📌 Syntax:
class Parent {
void greet() {
System.out.println("Hello");
}
}
class Child extends Parent {
void study() {
System.out.println("Studying");
}
}
✅ Usage:
Child c = new Child();
c.greet(); // from Parent
c.study(); // from Child
Inheritance promotes code reuse

Polymorphism = Many forms. Same method name behaves differently.

A. Method Overloading (Compile-time):
class MathOps {
int add(int a, int b) {
return a + b;
}
int add(int a, int b, int c) {
return a + b + c;
}
}
B. Method Overriding (Run-time):
class Animal {
void sound() {
System.out.println("Animal sound");
}
}
class Cat extends Animal {
void sound() {
System.out.println("Meow");
}
}

this refers to current object. Often used to avoid confusion when variable names are same.

✅ Example:
class Student {
int id;
Student(int id) {
this.id = id; // differentiates local and instance variable
}
void show() {
System.out.println("ID: " + id);
}
}

● static members belong to the class, not object.
● Shared by all instances.
✅ Example:
class Counter {
static int count = 0;
Counter() {
count++;
System.out.println("Object count: " + count);
}
}
Calling Counter c1 = new Counter(); 3 times increases count each time.

Control who can access classes, methods, and variables.

Modifier Access Level:
private Accessible only in the same class
default Accessible in the same package
protected Accessible in same package and subclass
d
public Accessible from anywhere

OOP Concept Real Life Example
Class Blueprint of a Car
Object Actual car made from the blueprint
Inheritance Child inherits features from parents
Encapsulation ATM hides internal working; shows interface
Abstraction You drive a car without knowing the engine
Polymorphism One function: brake (car, bike, truck)