Class as the Basis of all Computation

The Object as the Primary Computational Unit:

In Java, computation revolves entirely around objects. An object is a real-world entity or abstract concept that possesses three quintessential characteristics:

• State (Attributes / Data Members): The intrinsic properties, characteristics, or values held by the object at any given time. For an Account object, state includes accountNumber, holderName, and balance.
• Behaviour (Functions / Member Methods): The operations, transformations, or actions that an object can perform or have performed upon it. For Account, behaviour includes deposit(), withdraw(), and checkBalance().
• Identity (Memory Address): A unique, system-level identification distinguishing the object from all other objects in memory, even if two objects possess identical state values.

The Class as an Object Factory (Blueprint):

A class is an abstract template, blueprint, or specification from which individual objects are fabricated. Just as an architectural blueprint defines the dimensions and structure of a house without itself being a physical shelter, a class defines the fields and methods without allocating memory for actual data until an object is instantiated. Hence, a class is famously known as an "Object Factory".

Primitive vs User-Defined Composite Types:

While Java provides 8 built-in primitive data types (such as int, double, char), real-world systems require complex structures combining multiple related attributes. A class acts as a User-Defined Data Type (UDT) or composite type.

Three Tiers of Variables in Java:

Understanding variable scope, lifetime, and storage location is one of the most frequently tested concepts in ICSE Computer Applications.

The Anatomy of Object Instantiation:

Consider the classic declaration and instantiation statement:

Student s1 = new Student();

This single statement triggers three synchronized memory events:

1. Declaration (Student s1;): Allocates a reference variable named s1 on the Call Stack. At this stage, s1 contains no address (it evaluates to null).
2. Dynamic Allocation (new): The new keyword calculates the exact byte size required for all instance variables of the Student class and allocates a contiguous memory block on the Heap. It returns the 64-bit hexadecimal memory address of this block.
3. Initialization (Student()): The constructor is executed, populating the newly allocated Heap fields with default or user-specified initial values.
4. Assignment (=): The returned Heap memory address is assigned to reference variable s1 on the Stack.

Syntax and Role of the Dot Operator:

The dot operator (.) is the member access operator in Java. It establishes a dereference link between a reference variable on the Stack and the concrete data fields or member methods living inside the Heap object.

// Accessing instance variables:
s1.name = "Aarav Sharma";
s1.marks = 94.5;

// Invoking member methods:
s1.calculateGrade();
s1.displayReport();

Static Member Access via Class Name:

Because static variables and static methods belong to the entire class rather than any individual object, they should be invoked directly using the Class Name rather than an object reference:

// Recommended best practice:
Student.schoolName = "St. Xavier's School";
double root = Math.sqrt(144.0); // Math is the class name!

The Four Stages of an Object's Life:

1. Declaration: Binding a variable name to a class type on the Stack.
2. Instantiation: Physical creation of the object in Heap memory using the new operator.
3. Initialization: Execution of constructors to assign meaningful state to instance fields.
4. Destruction & Garbage Collection: When an object is no longer reachable by any active reference variable (e.g., s1 = null; or reassignment s1 = s2;), it becomes eligible for Garbage Collection (GC). The JVM's automatic garbage collector periodically reclaims orphaned Heap memory.

Model Program 1: Complete Class Architecture with Methods

import java.util.Scanner;

public class Student {
    // 1. Instance Variables (Data Members)
    private String name;
    private int rollNo;
    private double marks1, marks2, marks3;
    private double total, average;
    private char grade;

    // 2. Member Method to input data
    public void accept() {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter Student Name: ");
        name = sc.nextLine();
        System.out.print("Enter Roll Number: ");
        rollNo = sc.nextInt();
        System.out.print("Enter Marks in 3 Subjects: ");
        marks1 = sc.nextDouble();
        marks2 = sc.nextDouble();
        marks3 = sc.nextDouble();
    }

    // 3. Member Method to compute results
    public void compute() {
        total = marks1 + marks2 + marks3;
        average = total / 3.0;
        if (average >= 90) grade = 'A';
        else if (average >= 75) grade = 'B';
        else if (average >= 60) grade = 'C';
        else if (average >= 40) grade = 'D';
        else grade = 'F';
    }

    // 4. Member Method to display formatted output
    public void display() {
        System.out.println("----- Student Report Card -----");
        System.out.println("Roll No : " + rollNo);
        System.out.println("Name    : " + name);
        System.out.println("Total   : " + total + " / 300");
        System.out.println("Average : " + average + "%");
        System.out.println("Grade   : " + grade);
    }

    // 5. Main method instantiating object
    public static void main(String[] args) {
        Student obj = new Student(); // Object creation
        obj.accept();                // Invoking methods via dot operator
        obj.compute();
        obj.display();
    }
}

Model Program 2: Real-World Tariff Calculation Class

import java.util.Scanner;

public class ElectricBill {
    private String n;      // Consumer Name
    private int units;     // Units Consumed
    private double bill;   // Bill Amount

    public void accept() {
        Scanner in = new Scanner(System.in);
        System.out.print("Enter Consumer Name: ");
        n = in.nextLine();
        System.out.print("Enter Units Consumed: ");
        units = in.nextInt();
    }

    public void calculate() {
        // Slab tariff logic
        if (units <= 100) {
            bill = units * 2.0;
        } else if (units <= 300) {
            bill = (100 * 2.0) + ((units - 100) * 3.0);
        } else {
            bill = (100 * 2.0) + (200 * 3.0) + ((units - 300) * 5.0);
            // Surcharge of 2.5% if units exceed 300
            double surcharge = bill * 0.025;
            bill += surcharge;
        }
    }

    public void print() {
        System.out.println("=================================");
        System.out.println("ELECTRICITY CONSUMPTION INVOICE");
        System.out.println("Consumer Name  : " + n);
        System.out.println("Units Consumed : " + units);
        System.out.println("Net Payable    : Rs. " + bill);
        System.out.println("=================================");
    }

    public static void main(String[] args) {
        ElectricBill eb = new ElectricBill();
        eb.accept();
        eb.calculate();
        eb.print();
    }
}