Elementary Concept of Objects and Classes

A. The Three Inherent Characteristics of an Object:

In Java, an Object is a software bundle of related variables and methods modeling a real-world or conceptual entity. Every object possesses three fundamental characteristics:

1. State (Attributes / Characteristics): The static and dynamic data properties possessed by the object at any given instant. In Java, state is stored in Instance Variables (fields).
   Example (Student Object): Roll number (101), Name ("Aarav"), Marks (94.5), Grade ('A').
2. Behavior (Actions / Operations): What the object can do or what can be done to the object in response to messages. In Java, behavior is defined by Member Methods (functions).
   Example (Student Object): calculateGrade(), displayDetails(), payFees().
3. Identity (Unique Distinctness): The unique individuality that distinguishes an object from all other objects in computer memory, even if two objects possess identical state values. In Java, identity is established by the object's unique Heap Memory Address.

A. Why a Class is Called an "Object Factory":

Just as an industrial stamping die or factory mold produces thousands of identical plastic toys from a single pattern, a Java Class serves as an architectural template that can produce an unlimited number of distinct object instances on demand. Therefore, a class is universally recognized as an Object Factory.

B. Why a Class is a "User-Defined Composite Data Type":

Java provides 8 built-in primitive data types (such as int, double, char). However, primitive types cannot represent a complex real-world entity (e.g., an Employee possessing a name, salary, age, and department). When a programmer declares:

class Employee {
    String name;
    int empId;
    double salary;
}

The programmer has created a new, custom, composite data type named Employee. A variable of type Employee can now be instantiated just like a primitive variable: Employee emp1 = new Employee();

C. Class vs Object: Comprehensive Comparison:

A. The Three Stages of Object Creation:

Creating an object in Java involves three distinct grammatical and runtime steps:

Student s1 = new Student();

1. 1. Declaration (Student s1): Associates a variable name (s1) with an object type (Student). This allocates space on the Stack for an object reference variable. At this stage, s1 contains null (points to nothing).
2. 2. Instantiation (new): The new operator is a dynamic memory allocation operator. It allocates sufficient contiguous memory blocks on the Heap to hold all the instance variables of the Student class and returns a reference (memory address) to that allocated space.
3. 3. Initialization (Student()): The constructor (Student()) is invoked immediately following memory allocation to initialize the instance variables of the newly created object with default or user-specified values. The returned heap memory address is then assigned to reference variable s1.

B. Stack vs Heap Memory Architecture:

In Java's runtime memory layout:

• Stack Memory: Stores primitive local variables and object reference variables (e.g., s1, s2). Stack allocation is fast and follows strict LIFO (Last-In-First-Out) method scope.
• Heap Memory: The expansive memory pool where all actual object instances and their instance variables reside. When an object is no longer referenced by any stack variable, Java's automatic Garbage Collector reclaims its heap memory.

A. Inter-Object Communication (Message Passing):

In OOP, objects do not operate in isolated silos; they interact by sending and receiving messages. A message is simply a request sent from one object to another to invoke a specific member method.

B. The Dot Operator Syntax:

The dot operator (.) establishes the link between an object reference and its internal members (variables and methods):

• Accessing a Variable: objectName.variableName; (e.g., s1.name = "Rohan";)
• Invoking a Method: objectName.methodName(arguments); (e.g., s1.calculatePercentage(450, 500);)

C. Complete Working Java Exemplar:

// Class Definition (Blueprint)
class Circle {
    double radius; // Instance variable (State)

    // Member method to set radius
    void setRadius(double r) {
        radius = r;
    }

    // Member method to calculate area (Behavior)
    double computeArea() {
        return Math.PI * radius * radius;
    }
}

// Execution Class
public class GeometryDemo {
    public static void main(String[] args) {
        // Object Instantiation
        Circle c1 = new Circle();
        Circle c2 = new Circle();

        // Message Passing via Dot Operator
        c1.setRadius(7.0);
        c2.setRadius(14.0);

        System.out.println("Area of Circle 1: " + c1.computeArea());
        System.out.println("Area of Circle 2: " + c2.computeArea());
    }
}

A. The BankAccount Class Blueprint:

// Blueprint Class representing a Bank Account
public class BankAccount {
    // Private instance variables (State) - Encapsulation / Data Hiding
    private long accountNumber;
    private String accountHolderName;
    private double currentBalance;

    // Constructor to initialize an object at instantiation
    public BankAccount(long accNo, String name, double initialDeposit) {
        accountNumber = accNo;
        accountHolderName = name;
        currentBalance = initialDeposit;
    }

    // Member Method to deposit money (Behavior)
    public void deposit(double amount) {
        if (amount > 0) {
            currentBalance += amount;
            System.out.println("Deposited ₹" + amount + " | Updated Balance: ₹" + currentBalance);
        } else {
            System.out.println("Error: Deposit amount must be positive!");
        }
    }

    // Member Method to withdraw money with validation
    public void withdraw(double amount) {
        if (amount > 0 && amount <= currentBalance) {
            currentBalance -= amount;
            System.out.println("Withdrawn ₹" + amount + " | Remaining Balance: ₹" + currentBalance);
        } else {
            System.out.println("Transaction Failed: Insufficient funds or invalid amount!");
        }
    }

    // Method to display account status
    public void displayAccountStatement() {
        System.out.println("Account Number : " + accountNumber);
        System.out.println("Account Holder : " + accountHolderName);
        System.out.println("Current Balance: ₹" + currentBalance);
        System.out.println("----------------------------------------");
    }
}

B. Multi-Object Instantiation Demonstration:

public class BankSimulation {
    public static void main(String[] args) {
        // Creating Object 1 on Heap
        BankAccount acc1 = new BankAccount(100101L, "Aarav Sharma", 15000.0);
        
        // Creating Object 2 on Heap (completely independent state!)
        BankAccount acc2 = new BankAccount(100102L, "Ananya Sen", 25000.0);

        // Performing operations via message passing
        acc1.deposit(5000.0);    // Modifies only acc1 balance
        acc2.withdraw(8000.0);   // Modifies only acc2 balance

        acc1.displayAccountStatement();
        acc2.displayAccountStatement();
    }
}

A. Constructors in Java:

A Constructor is a specialized member method having the identical name as the class and lacking any return type (not even void). It is invoked automatically when an object is instantiated using new to initialize its instance variables.

• Default / Non-Parameterized Constructor: Takes no arguments; initializes instance variables with default or zero values. If no constructor is written, the Java compiler automatically synthesizes an empty default constructor.
• Parameterized Constructor: Accepts parameters to initialize distinct objects with custom starting values at creation time.

B. The `this` Keyword:

The this keyword is an implicit reference variable that points directly to the current calling object. It resolves name shadowing when parameter names are identical to instance variable names:

class Book {
    private String title;
    private double price;

    // Parameterized constructor utilizing 'this'
    public Book(String title, double price) {
        this.title = title; // 'this.title' is the instance variable; 'title' is the local parameter
        this.price = price;
    }

    public void displayBookDetails() {
        System.out.println("Book Title : " + this.title);
        System.out.println("Book Price : ₹" + this.price);
    }
}

A. The Four Java Access Specifiers:

• private: Accessible exclusively within the declaring class. Guarantees maximum data hiding.
• default (package-private): Accessible by any class residing within the identical package.
• protected: Accessible within the same package, and by subclasses in foreign packages via inheritance.
• public: Universally accessible from any class across any package.

B. Method Overloading in Class Design:

Method overloading allows a class to have multiple methods possessing the exact same name but differentiated by distinct parameter lists (different number of arguments, different data types, or different sequence of parameters). It exemplifies compile-time polymorphism.

class ShapeCalculator {
    double calculateArea(double radius) { return Math.PI * radius * radius; }
    double calculateArea(double length, double breadth) { return length * breadth; }
    double calculateArea(int side) { return side * side; }
}

A. Automated Memory Management vs C/C++:

In languages like C++, programmers must manually allocate and deallocate memory using malloc() and free() (or new and delete). Forgetting to free memory leads to catastrophic Memory Leaks, while freeing memory prematurely causes dangerous Dangling Pointers. Java completely eliminates both perils through an autonomous daemon thread: the Garbage Collector (GC).

• When does an object become eligible for Garbage Collection? An object on the Heap becomes eligible for garbage collection as soon as it is no longer reachable by any active reference variable in the application (e.g., when a reference variable is set to null, or when an object is created locally inside a method and that method finishes execution).
• Requesting GC: Programmers can politely suggest that the JVM run garbage collection using System.gc() or Runtime.getRuntime().gc(), although the JVM does not guarantee immediate execution.

In robust object-oriented software engineering, an object's state should never be modified directly from external classes. By declaring instance variables as private and exposing public mutator methods (setters) with parameter validation logic, the class guarantees that its internal state always remains in a mathematically consistent, valid configuration, preventing accidental corruption.