4. Object-Oriented Programming (OOP) in Java

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.

Object-Oriented Programming (OOP) is a programming paradigm that uses 'objects' to design software. In Java, which is a completely object-oriented language, every element is associated with classes and objects. The main advantages of using OOP include: efficient program structure, modular design, and ease in maintenance and extension. The four foundational principles of OOP are Encapsulation (bundling data with methods), Abstraction (hiding complex details), Inheritance (deriving new classes from existing ones), and Polymorphism (allowing entities to be represented in multiple forms).

Think of OOP like different departments in a company: each department (object) has its own role (methods) and responsibilities (data). This organization allows for clear communication and collaboration, making it easier to build and manage projects.

✅ 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 class in Java serves as a blueprint for creating objects. It encapsulates attributes (like 'id' and 'name' in the Student class) and methods (like 'display' that defines behavior). Objects are instances of classes, representing real-world entities with actual values and states. In the provided Student example, we create an object, 's1', that holds specific details about a student and can perform actions like displaying its information.

Imagine a class as a recipe for a cake. The class contains all the ingredients (properties) and instructions (methods) needed to bake the cake. Each cake you make from that recipe (the object) can then have its own unique features, like flavor or decoration.

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)); } }

Constructors are unique methods used to initialize new objects. Their names always match the class name and they have no return type. There are several types of constructors in Java: the default constructor, which initializes an object without parameters, parameterized constructors that allow passing values during the object creation, and constructor overloading which permits multiple constructors within a class that vary in their parameter lists.

Think of a constructor as a factory for cars. When a customer orders a car, they can specify options (like color or engine type) – this is similar to a parameterized constructor. Alternatively, a basic factory model (the default constructor) may produce a standard car without customization.

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

Encapsulation is a fundamental concept in OOP that involves bundling data (attributes) and the methods that manipulate that data into a single unit (class). It also restricts access to some components to protect the integrity of the data - for instance, the 'balance' variable is marked as private and can only be accessed via public methods like getBalance and deposit.

Think of a capsule that contains medication. The outside protects the internal contents from external factors, and you can only access the medicine by following the correct procedure (like taking a pill). Similarly, in encapsulation, methods are required to access or modify data safely.

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

Abstraction focuses on exposing only the relevant details of an object while hiding the complex background processes. In Java, abstraction can be implemented using abstract classes and interfaces. In the provided example, the Animal class defines an abstract method 'makeSound', which is implemented in the Dog class. Users of the Dog class can call makeSound() without knowing the underlying implementation details.

Consider a television remote control. You press buttons to change channels or adjust volume, but you don’t need to understand the internal electronics or software that make it work. The remote shows only the necessary controls while hiding the complexities of how it operates.

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

Inheritance is a principle of OOP where a new class (child class) derives properties and behavior (methods) from an existing class (parent class). This promotes code reuse and establishes a natural hierarchy. In the example, the Child class inherits the greet method from the Parent class, allowing an instance of Child to use this inherited method alongside its own study method.

Think of inheritance like a family tree. Just as children inherit traits from their parents (like hair color or height), classes in OOP inherit attributes and behaviors from other classes, building upon the existing functionality.

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"); } }

Polymorphism allows methods to do different things based on the object that it is acting upon. There are two types: method overloading, where multiple methods have the same name but different parameters (compile-time polymorphism), and method overriding, where a child class provides a specific implementation of a method defined in its parent class (run-time polymorphism).

Imagine a universal remote control. It has different buttons for different devices, but pressing the 'power' button results in different actions depending on whether you are using it for the TV or the DVD player. Similarly, polymorphism in programming allows the same method name to behave differently for different objects.

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); } }

The 'this' keyword is a reference variable that refers to the current object within a method or constructor. It's particularly useful when a local variable (like 'id' in the constructor) has the same name as an instance variable. By using 'this.id', you clarify that you are referring to the instance variable rather than the local one.

Consider a teacher calling on a student in class named 'Alex'. If there's confusion about which Alex is being referred to, the teacher might say, 'Alex (the one in the blue sweater), please answer this question.' Similarly, 'this' helps clarify which variable is being referred to.

● 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.

The 'static' keyword is used to define class-level members rather than instance-level. This means a static variable (like 'count' in the Counter class) is shared across all instances of the class. When one instance increments 'count', it affects all instances, as they reference the same variable.

Imagine a school where each classroom has a common attendance ledger. Regardless of how many classrooms (instances) there are, all use the same ledger (static variable) to record the overall student count. When a new student joins, the number is updated in the ledger and reflects across all classrooms.

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

Access modifiers in Java determine the visibility of classes, methods, and variables. The four main types are: private (accessible only within the same class), default (accessible within the same package), protected (accessible within the package and sub-classes), and public (accessible from anywhere). Understanding access level is crucial for maintaining encapsulation and controlling access to sensitive data.

Think of access modifiers like security doors in a building. Some doors are locked (private), some are for specific groups (protected), while others are open to everyone (public). Just as you would restrict access to certain areas, access modifiers safeguard information and methods in programming.

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)

This chunk visually compares OOP concepts to everyday experiences. Classes are seen as blueprints that can manufacture specific items, like cars. Objects portray the final product crafted from the blueprint. Inheritance resembles familial traits passed from parent to child. Encapsulation and abstraction emphasize building interfaces while hiding detailed complexities. Lastly, polymorphism demonstrates how one action can result in diverse outcomes depending on the object being acted on.

Imagine a shopping mall, where each store represents a class. Each store has a specific design and layout (the structure), but when you walk into these stores, you see different products (objects). The mall organizes a variety of stores (inheritance) while providing clear signs (interfaces, encapsulation) that guide you without exposing the mall's complex internal structure.

--