Unit 6: OOP — Classes, Objects & Constructors

Opening Hook — Every Zomato Order Is an Object

Learning Outcomes — Bloom's Taxonomy Mapped

Concept Explanation — OOP from Scratch

1. Class vs Object — The Blueprint Analogy

Imagine the DDA (Delhi Development Authority) designs a blueprint for a 2BHK flat. The blueprint specifies: 2 bedrooms, 1 kitchen, 1 bathroom, 1 balcony, total area = 850 sq ft. This blueprint is the class. Now DDA builds 500 actual flats from this blueprint in Dwarka. Each flat has a unique flat number, different paint colours, different furniture — but the structure is the same. Each flat is an object.

Syntax — Defining a class and creating objects:

Java
// Class definition — the blueprint
class Student {
    // Fields (instance variables)
    String name;
    int rollNo;
    double marks;

    // Method
    void display() {
        System.out.println(name + " | Roll: " + rollNo + " | Marks: " + marks);
    }
}

public class Main {
    public static void main(String[] args) {
        // Creating objects — building flats from blueprint
        Student s1 = new Student();
        s1.name = "Aarav";
        s1.rollNo = 101;
        s1.marks = 92.5;

        Student s2 = new Student();
        s2.name = "Priya";
        s2.rollNo = 102;
        s2.marks = 88.0;

        s1.display();
        s2.display();
    }
}

2. Writing Classes in Java

A well-written Java class has a clear anatomy: access modifier, class keyword, class name (PascalCase), fields, constructors, and methods.

Full BankAccount Class:

Java
public class BankAccount {
    // Fields (private for encapsulation)
    private String accountNumber;
    private String holderName;
    private double balance;
    private String ifscCode;

    // Parameterized Constructor
    public BankAccount(String accountNumber, String holderName,
                       double initialDeposit, String ifscCode) {
        this.accountNumber = accountNumber;
        this.holderName = holderName;
        this.balance = initialDeposit;
        this.ifscCode = ifscCode;
    }

    // Deposit method
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("₹" + amount + " deposited. New Balance: ₹" + balance);
        } else {
            System.out.println("Invalid deposit amount!");
        }
    }

    // Withdraw method
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("₹" + amount + " withdrawn. Remaining: ₹" + balance);
        } else {
            System.out.println("Insufficient balance or invalid amount!");
        }
    }

    // Display method
    public void displayDetails() {
        System.out.println("A/C: " + accountNumber + " | Name: " + holderName);
        System.out.println("Balance: ₹" + balance + " | IFSC: " + ifscCode);
    }

    public double getBalance() {
        return balance;
    }
}

public class BankDemo {
    public static void main(String[] args) {
        BankAccount acc1 = new BankAccount("SBI-10042", "Rahul Verma", 50000, "SBIN0001234");
        acc1.displayDetails();
        acc1.deposit(15000);
        acc1.withdraw(8000);
        System.out.println("Final Balance: ₹" + acc1.getBalance());
    }
}

3. Constructors — Default, Parameterized & Copy

A constructor is a special method that runs automatically when you create an object with new. It has the same name as the class and no return type (not even void). Its job is to initialise the object's fields.

Full StudentRecord class with all 3 constructors:

Java
public class StudentRecord {
    String name;
    int rollNo;
    String branch;
    double cgpa;

    // 1. Default Constructor
    public StudentRecord() {
        this.name = "Unknown";
        this.rollNo = 0;
        this.branch = "Not Assigned";
        this.cgpa = 0.0;
        System.out.println("Default constructor called");
    }

    // 2. Parameterized Constructor
    public StudentRecord(String name, int rollNo, String branch, double cgpa) {
        this.name = name;
        this.rollNo = rollNo;
        this.branch = branch;
        this.cgpa = cgpa;
        System.out.println("Parameterized constructor called");
    }

    // 3. Copy Constructor
    public StudentRecord(StudentRecord other) {
        this.name = other.name;
        this.rollNo = other.rollNo;
        this.branch = other.branch;
        this.cgpa = other.cgpa;
        System.out.println("Copy constructor called");
    }

    void display() {
        System.out.println(name + " | " + rollNo + " | " + branch + " | CGPA: " + cgpa);
    }

    public static void main(String[] args) {
        StudentRecord s1 = new StudentRecord();
        s1.display();

        StudentRecord s2 = new StudentRecord("Ananya", 201, "CSE", 9.2);
        s2.display();

        StudentRecord s3 = new StudentRecord(s2);  // copy of s2
        s3.display();
    }
}

4. Constructor Overloading

Constructor overloading means having multiple constructors in the same class with different parameter lists. Java decides which constructor to call based on the arguments you pass to new.

Java
public class Product {
    String name;
    double price;
    String category;
    int quantity;

    // Constructor 1: No arguments
    public Product() {
        this.name = "Generic Product";
        this.price = 0.0;
        this.category = "General";
        this.quantity = 1;
    }

    // Constructor 2: Name and price
    public Product(String name, double price) {
        this.name = name;
        this.price = price;
        this.category = "General";
        this.quantity = 1;
    }

    // Constructor 3: Name, price, category
    public Product(String name, double price, String category) {
        this.name = name;
        this.price = price;
        this.category = category;
        this.quantity = 1;
    }

    // Constructor 4: All fields
    public Product(String name, double price, String category, int quantity) {
        this.name = name;
        this.price = price;
        this.category = category;
        this.quantity = quantity;
    }

    void display() {
        System.out.println(name + " | ₹" + price + " | " + category + " | Qty: " + quantity);
    }

    public static void main(String[] args) {
        Product p1 = new Product();
        Product p2 = new Product("Notebook", 45.0);
        Product p3 = new Product("Pen", 10.0, "Stationery");
        Product p4 = new Product("Eraser", 5.0, "Stationery", 10);

        p1.display();
        p2.display();
        p3.display();
        p4.display();
    }
}

5. Constructor Chaining — this()

Constructor chaining means calling one constructor from another constructor within the same class using this(). This avoids code duplication — instead of repeating initialisation logic in every constructor, you chain them.

Java
public class Employee {
    String name;
    int empId;
    String department;
    double salary;

    // Constructor 1: All fields (master constructor)
    public Employee(String name, int empId, String department, double salary) {
        this.name = name;
        this.empId = empId;
        this.department = department;
        this.salary = salary;
        System.out.println("Master constructor called");
    }

    // Constructor 2: Chains to Constructor 1
    public Employee(String name, int empId, String department) {
        this(name, empId, department, 25000.0);  // chain → default salary
        System.out.println("3-param constructor called");
    }

    // Constructor 3: Chains to Constructor 2
    public Employee(String name, int empId) {
        this(name, empId, "General");  // chain → default department
        System.out.println("2-param constructor called");
    }

    // Constructor 4: Chains to Constructor 3
    public Employee() {
        this("New Employee", 0);  // chain → default name & id
        System.out.println("Default constructor called");
    }

    void display() {
        System.out.println(name + " | ID: " + empId + " | " + department + " | ₹" + salary);
    }

    public static void main(String[] args) {
        System.out.println("--- Creating default employee ---");
        Employee e1 = new Employee();
        e1.display();
    }
}

6. Methods — Instance vs Static

Methods define the behaviour of objects. There are two types:

Java
public class Counter {
    // Instance variable — each object gets its own copy
    int instanceCount = 0;

    // Static variable — shared among ALL objects
    static int totalCount = 0;

    // Instance method
    void increment() {
        instanceCount++;
        totalCount++;
    }

    // Static method
    static void showTotal() {
        System.out.println("Total across all objects: " + totalCount);
        // System.out.println(instanceCount); ❌ ERROR — can't access instance var
    }

    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();

        c1.increment();
        c1.increment();
        c2.increment();

        System.out.println("c1 instance count: " + c1.instanceCount);
        System.out.println("c2 instance count: " + c2.instanceCount);
        Counter.showTotal();
    }
}

7. Method Overloading

Method overloading means having multiple methods with the same name but different parameter lists (different number, type, or order of parameters). The return type alone is NOT sufficient for overloading.

Java
public class Calculator {
    // Overloaded add() — 4 versions

    int add(int a, int b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }

    double add(double a, double b) {
        return a + b;
    }

    String add(String a, String b) {
        return a + b;  // String concatenation
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(10, 20));
        System.out.println(calc.add(10, 20, 30));
        System.out.println(calc.add(3.5, 4.5));
        System.out.println(calc.add("Edu", "Artha"));
    }
}

8. The this Keyword — 5 Uses

The this keyword is a reference to the current object — the object on which the method is being called. It has 5 distinct uses:

Java
public Student(String name, int rollNo) {
    this.name = name;      // this.name → field, name → parameter
    this.rollNo = rollNo;
}

Java
public Student() {
    this("Unknown", 0);  // calls parameterized constructor
}

Java
void enroll(Course course) {
    course.addStudent(this);  // pass this Student object to the course
}

Java
Student setName(String name) {
    this.name = name;
    return this;  // enables: s.setName("A").setRoll(1)
}

Java
class Outer {
    int x = 10;
    class Inner {
        int x = 20;
        void show() {
            System.out.println(this.x);        // 20 — Inner's x
            System.out.println(Outer.this.x);  // 10 — Outer's x
        }
    }
}

Full example combining multiple uses:

Java
public class Pizza {
    String size;
    String crust;
    String topping;

    public Pizza() {
        this("Medium", "Thin", "Cheese");  // Use 2: this()
    }

    public Pizza(String size, String crust, String topping) {
        this.size = size;       // Use 1: this.field
        this.crust = crust;
        this.topping = topping;
    }

    Pizza setSize(String size) {
        this.size = size;
        return this;  // Use 4: return this for chaining
    }

    Pizza setCrust(String crust) {
        this.crust = crust;
        return this;
    }

    Pizza setTopping(String topping) {
        this.topping = topping;
        return this;
    }

    void display() {
        System.out.println(size + " | " + crust + " | " + topping);
    }

    public static void main(String[] args) {
        // Method chaining using return this
        Pizza myPizza = new Pizza()
            .setSize("Large")
            .setCrust("Stuffed")
            .setTopping("Paneer Tikka");
        myPizza.display();
    }
}

9. Initializer Blocks

Java has two types of initializer blocks that run before or during object creation:

Java
public class InitDemo {
    int x;

    // Static initializer block — runs ONCE when class loads
    static {
        System.out.println("1. Static block executed");
    }

    // Instance initializer block — runs EVERY TIME before constructor
    {
        x = 10;
        System.out.println("2. Instance block executed (x = " + x + ")");
    }

    // Constructor
    public InitDemo() {
        x = 20;
        System.out.println("3. Constructor executed (x = " + x + ")");
    }

    public static void main(String[] args) {
        System.out.println("--- Creating first object ---");
        InitDemo obj1 = new InitDemo();
        System.out.println("--- Creating second object ---");
        InitDemo obj2 = new InitDemo();
    }
}

10. Access Modifiers in OOP

Encapsulation pattern — private fields + public getters/setters:

Java
public class AadhaarCard {
    private String aadhaarNumber;  // private — no direct access
    private String holderName;

    public AadhaarCard(String aadhaarNumber, String holderName) {
        this.aadhaarNumber = aadhaarNumber;
        this.holderName = holderName;
    }

    // Public getter — controlled read access
    public String getMaskedAadhaar() {
        return "XXXX-XXXX-" + aadhaarNumber.substring(8);
    }

    // Public getter
    public String getHolderName() {
        return holderName;
    }

    // No setter for aadhaarNumber — it should never change!
}

11. Object Lifecycle

12. Full Industry Code — ZomatoOrder Class

Java
public class ZomatoOrder {
    private String orderId;
    private String customerName;
    private String restaurant;
    private String[] items;
    private double totalAmount;
    private String status;
    private String deliveryAddress;
    private static int orderCount = 0;

    // Default Constructor
    public ZomatoOrder() {
        orderCount++;
        this.orderId = "ZMT-" + System.currentTimeMillis();
        this.status = "CREATED";
    }

    // Parameterized Constructor — chains to default
    public ZomatoOrder(String customerName, String restaurant,
                       String[] items, double totalAmount, String deliveryAddress) {
        this();  // Constructor chaining!
        this.customerName = customerName;
        this.restaurant = restaurant;
        this.items = items;
        this.totalAmount = totalAmount;
        this.deliveryAddress = deliveryAddress;
    }

    // Copy Constructor (for reorder feature)
    public ZomatoOrder(ZomatoOrder previousOrder) {
        this();  // new orderId & status
        this.customerName = previousOrder.customerName;
        this.restaurant = previousOrder.restaurant;
        this.items = previousOrder.items.clone();
        this.totalAmount = previousOrder.totalAmount;
        this.deliveryAddress = previousOrder.deliveryAddress;
    }

    // Place order
    public void placeOrder() {
        if (items != null && items.length > 0) {
            this.status = "PLACED";
            System.out.println("✅ Order " + orderId + " placed at " + restaurant);
            System.out.println("   Items: " + String.join(", ", items));
            System.out.println("   Total: ₹" + totalAmount);
        } else {
            System.out.println("❌ Cannot place order — no items!");
        }
    }

    // Overloaded placeOrder with delivery instructions
    public void placeOrder(String instructions) {
        placeOrder();
        System.out.println("   Instructions: " + instructions);
    }

    // Cancel order
    public void cancelOrder() {
        if (status.equals("PLACED") || status.equals("CREATED")) {
            this.status = "CANCELLED";
            System.out.println("🚫 Order " + orderId + " cancelled. Refund: ₹" + totalAmount);
        } else {
            System.out.println("❌ Cannot cancel — order is " + status);
        }
    }

    // Track delivery
    public void trackDelivery() {
        System.out.println("📍 Order: " + orderId + " | Status: " + status);
        System.out.println("   Delivering to: " + deliveryAddress);
    }

    // Display order summary
    public void displayOrderSummary() {
        System.out.println("===== ORDER SUMMARY =====");
        System.out.println("Order ID    : " + orderId);
        System.out.println("Customer    : " + customerName);
        System.out.println("Restaurant  : " + restaurant);
        System.out.println("Items       : " + String.join(", ", items));
        System.out.println("Amount      : ₹" + totalAmount);
        System.out.println("Status      : " + status);
        System.out.println("Address     : " + deliveryAddress);
        System.out.println("=========================");
    }

    // Static method — total orders
    public static int getOrderCount() {
        return orderCount;
    }
}

public class ZomatoDemo {
    public static void main(String[] args) {
        // Create an order
        String[] items1 = {"Butter Chicken", "Naan", "Dal Makhani"};
        ZomatoOrder order1 = new ZomatoOrder(
            "Aarav Sharma", "Punjab Grill", items1, 850.0, "Sector 21, Dwarka, Delhi"
        );

        order1.placeOrder("Extra butter in naan please");
        order1.trackDelivery();

        // Reorder using copy constructor
        System.out.println("\n--- REORDER ---");
        ZomatoOrder reorder = new ZomatoOrder(order1);
        reorder.placeOrder();
        reorder.displayOrderSummary();

        System.out.println("\nTotal orders today: " + ZomatoOrder.getOrderCount());
    }
}

Learn by Doing — 3-Tier Lab Structure

Java
public class ZomatoOrderTier1 {
    String orderId;
    String customerName;
    String restaurant;
    String[] items;
    double totalAmount;
    String status;

    // Default Constructor
    public ZomatoOrderTier1() {
        this.orderId = "ZMT-001";
        this.status = "CREATED";
        this.customerName = "Guest";
        this.restaurant = "Unknown";
        this.items = new String[]{};
        this.totalAmount = 0.0;
    }

    // Parameterized Constructor
    public ZomatoOrderTier1(String customerName, String restaurant,
                            String[] items, double totalAmount) {
        this();  // chain to default
        this.customerName = customerName;
        this.restaurant = restaurant;
        this.items = items;
        this.totalAmount = totalAmount;
    }

    void placeOrder() {
        this.status = "PLACED";
        System.out.println("Order " + orderId + " placed at " + restaurant);
        for (String item : items) {
            System.out.println("  - " + item);
        }
        System.out.println("Total: ₹" + totalAmount);
    }

    void cancelOrder() {
        if (status.equals("PLACED")) {
            this.status = "CANCELLED";
            System.out.println("Order " + orderId + " cancelled.");
        } else {
            System.out.println("Cannot cancel — status is " + status);
        }
    }

    void display() {
        System.out.println("ID: " + orderId + " | Customer: " + customerName +
                           " | Restaurant: " + restaurant + " | Status: " + status);
    }

    public static void main(String[] args) {
        String[] myItems = {"Paneer Tikka", "Garlic Naan", "Lassi"};
        ZomatoOrderTier1 order = new ZomatoOrderTier1("Ravi Kumar", "Bikanervala", myItems, 520.0);
        order.placeOrder();
        order.display();
        order.cancelOrder();
        order.display();
    }
}

Problem Set — Syntax, Programming & Industry

Syntax / Trace Questions (5)

Q1. What is the output?

Java
class Chain {
    Chain() { this(10); System.out.println("A"); }
    Chain(int x) { this(10, 20); System.out.println("B" + x); }
    Chain(int x, int y) { System.out.println("C" + (x+y)); }
}
// new Chain(); prints → ?

Answer: C30, B10, A (constructors chain bottom-up, then print top-down on return)

Q2. Find the error:

Java
class Box {
    int length, width;
    Box(int length, int width) {
        length = length;  // ← WHAT'S WRONG?
        width = width;
    }
}

Answer: Missing this. — the parameters shadow the fields. Should be this.length = length; and this.width = width;. Without this, the parameter is assigned to itself, and the field remains 0.

Q3. What is the output?

Java
class Overload {
    void show(int a) { System.out.println("int: " + a); }
    void show(double a) { System.out.println("double: " + a); }
    void show(String a) { System.out.println("String: " + a); }
}
// new Overload().show(5);      → ?
// new Overload().show(5.5);    → ?
// new Overload().show("five"); → ?

Answer: int: 5, double: 5.5, String: five — Java resolves by matching argument type to parameter type.

Q4. Find the error:

Java
class Test {
    int x;
    Test() {
        System.out.println("Hello");
        this(10);  // ← WHAT'S WRONG?
    }
    Test(int x) { this.x = x; }
}

Answer: this() must be the first statement in the constructor. System.out.println("Hello") comes before this(10), causing a compilation error.

Q5. What is the output?

Java
class Demo {
    static int count = 0;
    int id;
    Demo() { count++; id = count; }
    static void showCount() { System.out.println("Count: " + count); }
    void showId() { System.out.println("ID: " + id); }
}
// Demo d1 = new Demo(); Demo d2 = new Demo(); Demo d3 = new Demo();
// d2.showId(); Demo.showCount(); → ?

Answer: ID: 2, Count: 3 — static count is shared; d2 was created second (id=2); after d3, count=3.

Programming Questions (8)

P1. Write a Rectangle class with fields length and width, a parameterized constructor, and methods area() and perimeter(). Create 2 Rectangle objects and display their areas.

P2. Create a Book class with fields title, author, price, isbn. Write 3 overloaded constructors: (i) no parameters (ii) title + author (iii) all fields. Test all three.

P3. Implement method chaining in a PizzaBuilder class. Methods setSize(), setCrust(), addTopping() should return this. Final call: new PizzaBuilder().setSize("Large").setCrust("Stuffed").addTopping("Mushroom").build();

P4. Write a Student class with a static field totalStudents. Every time a Student is created, increment the counter. Add a static method getTotalStudents(). Create 5 students and print the total.

P5. Create a Time class with constructor overloading: (i) Time() → 00:00:00 (ii) Time(int hours) → hh:00:00 (iii) Time(int hours, int minutes) → hh:mm:00 (iv) Time(int hours, int minutes, int seconds) → hh:mm:ss. Use constructor chaining.

P6. Write an Employee class demonstrating all 5 uses of the this keyword in a single class.

P7. Build a Calculator class with 4 overloaded multiply() methods: (i) two ints (ii) three ints (iii) two doubles (iv) int and double.

P8. Create a MobilePhone class with fields brand, model, price, ram. Write a copy constructor. Create a phone object for "Samsung Galaxy S24" and clone it for "Samsung Galaxy S24 Ultra" (change only model and price).

Industry Questions — Ola Driver Class (3)

Interview Questions (3)

IQ1. "What happens if you don't write any constructor in a Java class?"

Answer: Java provides a default no-argument constructor automatically. It initialises all fields to their default values (0 for int, 0.0 for double, null for objects, false for boolean). However, if you write even ONE constructor (of any type), Java stops providing the default constructor.

IQ2. "Can a constructor be private? When is it useful?"

Answer: Yes! A private constructor prevents other classes from creating objects using new. This is used in the Singleton design pattern — ensuring only ONE instance of a class exists (e.g., a database connection pool, a logger). The class provides a static method like getInstance() to return the single instance.

IQ3. "What is the difference between this and this()?"

Answer: this is a reference variable pointing to the current object — used to access fields and methods. this() is a constructor call — used to invoke another constructor of the same class (constructor chaining). this() must be the first statement in a constructor.

MCQ Assessment Bank — 30 Questions (Bloom's Mapped)

Remember / Identify (Q1–Q5)

Understand / Explain (Q6–Q10)

Apply / Predict Output (Q11–Q15)

Apply / What Code (Q16–Q20)

Analyze / Debug (Q21–Q25)

Evaluate / Create (Q26–Q30)

Short Answer Questions (8)

SA1. Define a class and an object with a real-world analogy.

Answer: A class is a blueprint/template that defines the structure and behaviour of entities. An object is a specific instance of that class with actual values. Analogy: A class is like a DDA flat blueprint (defines 2BHK layout). An object is an actual flat (Flat #301 in Dwarka — with specific furniture, paint, and resident). One blueprint → many flats. One class → many objects.

SA2. What are the 3 types of constructors? Give syntax for each.

Answer:

1. Default Constructor: public Student() { name = "Unknown"; } — no parameters, sets defaults.

2. Parameterized Constructor: public Student(String name, int roll) { this.name = name; this.rollNo = roll; } — takes values at creation time.

3. Copy Constructor: public Student(Student other) { this.name = other.name; this.rollNo = other.rollNo; } — creates a duplicate of an existing object.

SA3. Explain 5 uses of the this keyword with one-line code examples.

Answer:

1. Distinguish field from parameter: this.name = name;

2. Constructor chaining: this(10, 20); — must be first statement

3. Pass current object: course.addStudent(this);

4. Return current object: return this; — enables method chaining

5. Access outer class from inner: Outer.this.x;

SA4. Differentiate between instance methods and static methods.

SA5. What is constructor chaining? How does this() work?

Answer: Constructor chaining is calling one constructor from another within the same class using this(). It avoids duplicating initialisation code. this() must be the first statement in the constructor. The chain flows to the target constructor, which executes first, then control returns. Example: A() → this(10) → A(int x) → this(10,20) → A(int x, int y). The deepest constructor executes first.

SA6. What is method overloading? Can we overload by return type only? Why?

Answer: Method overloading means having multiple methods with the same name but different parameter lists (different number, type, or order). No, we CANNOT overload by return type alone — because the compiler uses the method signature (name + parameters) to decide which method to call. If only return types differ, the compiler can't determine which version to invoke from the call site.

SA7. Explain access modifiers: public, private, protected, default.

Answer: public — accessible everywhere. private — accessible only within the declaring class. protected — accessible within the same package and subclasses in other packages. default (no keyword) — accessible only within the same package. Best practice: make fields private, methods public (encapsulation).

SA8. What is the object lifecycle in Java?

Answer: 1. Creation — new allocates heap memory, constructor initialises fields. 2. Usage — methods are called, fields are accessed. 3. Unreachable — when no reference points to the object (set to null, out of scope, or reassigned). 4. Garbage Collection — JVM's GC automatically reclaims memory. finalize() (deprecated) may run before destruction. You cannot force GC — System.gc() is only a request.

Long Answer Questions (3)

LA1. Explain constructors in Java in detail — types, rules, overloading, chaining. Write a complete Employee class demonstrating all concepts. (15 marks)

Answer:

A constructor is a special method in Java that is automatically called when an object is created using the new keyword. It initialises the object's state.

Rules of Constructors:

1. Must have the same name as the class
2. Has no return type (not even void)
3. Called only once — at object creation
4. Cannot be abstract, static, final, or synchronized
5. If no constructor is written, Java provides a default no-arg constructor
6. If any constructor is written, Java does NOT provide the default constructor

Types: (1) Default — no parameters. (2) Parameterized — accepts arguments. (3) Copy — takes object of same class.

Overloading: Multiple constructors with different parameter lists. Java picks the right one based on arguments.

Chaining: Using this() to call another constructor; must be the first statement.

Java
public class Employee {
    String name;
    int empId;
    String department;
    double salary;
    static int totalEmployees = 0;

    // Default Constructor
    public Employee() {
        this("Unknown", 0, "General", 25000.0);
    }

    // 2-param Constructor
    public Employee(String name, int empId) {
        this(name, empId, "General", 25000.0);
    }

    // Full Parameterized Constructor (master)
    public Employee(String name, int empId, String department, double salary) {
        this.name = name;
        this.empId = empId;
        this.department = department;
        this.salary = salary;
        totalEmployees++;
    }

    // Copy Constructor
    public Employee(Employee other) {
        this(other.name, other.empId + 1000, other.department, other.salary);
    }

    void display() {
        System.out.println(name + " | " + empId + " | " + department + " | ₹" + salary);
    }

    static int getTotalEmployees() { return totalEmployees; }
}

LA2. What is the this keyword? Explain all 5 uses with code examples. Why is it important in constructor overloading? (10 marks)

Answer:

The this keyword is a reference to the current object. It is used to resolve ambiguity, enable chaining, and pass the current object.

Use 1 — Resolve field/parameter ambiguity: When constructor parameters have the same name as fields, this.name = name; distinguishes the field from the parameter.

Use 2 — Constructor chaining: this(args) calls another constructor in the same class. Must be the first statement. Reduces code duplication when multiple constructors share logic.

Use 3 — Pass current object: someMethod(this); passes the current object to another method or class.

Use 4 — Return current object: return this; enables method chaining (Builder pattern): obj.setA(1).setB(2).setC(3);

Use 5 — Inner class access: OuterClass.this.field accesses the outer class's field from within an inner class.

Importance in constructor overloading: this() enables constructors to delegate to each other, avoiding repetition of initialisation logic. The simplest constructor chains to more complete ones, ensuring consistent initialisation.

LA3. Compare class vs object, instance vs static, overloading vs overriding. Write a BankAccount class showing all concepts. (15 marks)

Answer:

Class vs Object: A class is a logical blueprint (no memory); an object is a physical instance in heap memory. Class is defined once; many objects can be created.

Instance vs Static: Instance members belong to each object (separate copies). Static members belong to the class (shared). Instance methods can use this; static methods cannot. Static is called via ClassName; instance via objectReference.

Overloading vs Overriding: Overloading = same method name, different parameters, same class (compile-time polymorphism). Overriding = same method name + same parameters, subclass redefines parent method (runtime polymorphism — covered in Unit 7).

Java
public class BankAccount {
    private String accNo;
    private double balance;
    private static int totalAccounts = 0;  // static — shared

    public BankAccount(String accNo, double balance) {
        this.accNo = accNo;       // this — instance
        this.balance = balance;
        totalAccounts++;           // static — incremented for every object
    }

    // Overloaded deposit — 2 versions
    public void deposit(double amount) { balance += amount; }
    public void deposit(double amount, String note) {
        deposit(amount);
        System.out.println("Note: " + note);
    }

    public static int getTotalAccounts() { return totalAccounts; }  // static method
    public double getBalance() { return balance; }                    // instance method
}

Lab Programs — Lab 3 & Lab 5

Java
class Student {
    String name;
    int rollNo;
    double marks;
    String grade;

    void calculateGrade() {
        if (marks >= 90) grade = "A+";
        else if (marks >= 80) grade = "A";
        else if (marks >= 70) grade = "B";
        else if (marks >= 60) grade = "C";
        else grade = "F";
    }

    void display() {
        System.out.println("Name: " + name);
        System.out.println("Roll No: " + rollNo);
        System.out.println("Marks: " + marks);
        System.out.println("Grade: " + grade);
        System.out.println("---");
    }
}

public class Lab3a {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name = "Aarav Patel";
        s1.rollNo = 101;
        s1.marks = 92.5;
        s1.calculateGrade();

        Student s2 = new Student();
        s2.name = "Meera Singh";
        s2.rollNo = 102;
        s2.marks = 76.0;
        s2.calculateGrade();

        s1.display();
        s2.display();
    }
}

Java
class Rectangle {
    double length;
    double width;

    double area() {
        return length * width;
    }

    double perimeter() {
        return 2 * (length + width);
    }

    boolean isSquare() {
        return length == width;
    }

    boolean isLargerThan(Rectangle other) {
        return this.area() > other.area();
    }

    void display() {
        System.out.println("Rectangle [" + length + " x " + width + "]");
        System.out.println("  Area: " + area() + ", Perimeter: " + perimeter());
        System.out.println("  Is Square? " + isSquare());
    }
}

public class Lab3b {
    public static void main(String[] args) {
        Rectangle r1 = new Rectangle();
        r1.length = 10;
        r1.width = 5;

        Rectangle r2 = new Rectangle();
        r2.length = 7;
        r2.width = 7;

        r1.display();
        r2.display();

        System.out.println("r1 larger than r2? " + r1.isLargerThan(r2));
    }
}

Java
class BankAccount {
    String holderName;
    double balance;
    static int totalAccounts = 0;
    static double totalDeposits = 0;

    BankAccount(String name, double balance) {
        this.holderName = name;
        this.balance = balance;
        totalAccounts++;
        totalDeposits += balance;
    }

    void deposit(double amount) {
        balance += amount;
        totalDeposits += amount;
        System.out.println(holderName + ": Deposited ₹" + amount);
    }

    void displayAccount() {
        System.out.println(holderName + " — Balance: ₹" + balance);
    }

    static void displayBankStats() {
        System.out.println("Total Accounts: " + totalAccounts);
        System.out.println("Total Deposits: ₹" + totalDeposits);
    }
}

public class Lab3c {
    public static void main(String[] args) {
        BankAccount a1 = new BankAccount("Rahul", 50000);
        BankAccount a2 = new BankAccount("Priya", 75000);

        a1.deposit(10000);
        a2.deposit(25000);

        a1.displayAccount();
        a2.displayAccount();

        BankAccount.displayBankStats();
    }
}

Java
class Course {
    String courseName;
    String instructor;
    int credits;
    double fee;

    // Default Constructor
    Course() {
        courseName = "Elective";
        instructor = "TBA";
        credits = 3;
        fee = 5000.0;
        System.out.println("Default constructor → " + courseName);
    }

    // Parameterized Constructor
    Course(String courseName, String instructor, int credits, double fee) {
        this.courseName = courseName;
        this.instructor = instructor;
        this.credits = credits;
        this.fee = fee;
        System.out.println("Parameterized constructor → " + courseName);
    }

    // Copy Constructor
    Course(Course other) {
        this.courseName = other.courseName;
        this.instructor = other.instructor;
        this.credits = other.credits;
        this.fee = other.fee;
        System.out.println("Copy constructor → copied " + other.courseName);
    }

    void display() {
        System.out.println(courseName + " | " + instructor +
                           " | Credits: " + credits + " | Fee: ₹" + fee);
    }
}

public class Lab5a {
    public static void main(String[] args) {
        Course c1 = new Course();
        Course c2 = new Course("Data Structures", "Prof. Sharma", 4, 12000.0);
        Course c3 = new Course(c2);

        System.out.println("\n--- All Courses ---");
        c1.display();
        c2.display();
        c3.display();
    }
}

Java
class Laptop {
    String brand;
    String processor;
    int ram;
    double price;

    // Master constructor (all fields)
    Laptop(String brand, String processor, int ram, double price) {
        this.brand = brand;
        this.processor = processor;
        this.ram = ram;
        this.price = price;
        System.out.println("[Master] All fields set");
    }

    // 3-param — chains to master
    Laptop(String brand, String processor, int ram) {
        this(brand, processor, ram, 45000.0);
        System.out.println("[3-param] Default price ₹45000");
    }

    // 2-param — chains to 3-param
    Laptop(String brand, String processor) {
        this(brand, processor, 8);
        System.out.println("[2-param] Default RAM 8GB");
    }

    // Default — chains to 2-param
    Laptop() {
        this("HP", "i3");
        System.out.println("[Default] HP i3 8GB ₹45000");
    }

    void display() {
        System.out.println(brand + " | " + processor + " | " + ram + "GB | ₹" + price);
    }
}

public class Lab5b {
    public static void main(String[] args) {
        System.out.println("--- Creating default laptop ---");
        Laptop l1 = new Laptop();
        l1.display();

        System.out.println("\n--- Creating custom laptop ---");
        Laptop l2 = new Laptop("Dell", "i7", 16, 85000.0);
        l2.display();
    }
}

Java
class Printer {
    // Overloaded print() methods
    void print(String text) {
        System.out.println("String: " + text);
    }

    void print(int number) {
        System.out.println("Integer: " + number);
    }

    void print(double number) {
        System.out.println("Double: " + number);
    }

    void print(String text, int times) {
        for (int i = 0; i < times; i++) {
            System.out.print(text + " ");
        }
        System.out.println();
    }

    void print(String[] arr) {
        System.out.print("Array: ");
        for (String s : arr) {
            System.out.print(s + " ");
        }
        System.out.println();
    }
}

public class Lab5c {
    public static void main(String[] args) {
        Printer p = new Printer();
        p.print("Hello Java");
        p.print(42);
        p.print(3.14);
        p.print("OOP", 3);
        p.print(new String[]{"Java", "Python", "C++"});
    }
}

Industry Spotlight — A Day in the Life

Earn With It — OOP Desktop Apps ₹8K–₹25K/month

⏱️ Time to First Earning: 3–4 weeks (if you complete Lab 3, Lab 5, and build 1 portfolio project)

Chapter Summary

Earning & Learning Checkpoint

✅ Unit 6 complete. MCQs: 30. Labs 3, 5 covered. Ready for Unit 7 — Inheritance & Polymorphism!

[QR: Link to EduArtha video tutorial — Java OOP: Classes, Objects & Constructors]