Classes, Objects and Constructors

Java is an object-oriented language: real programs are built from objects that bundle data with the code that works on it. A bank account knows its balance and how to deposit; an order knows its items and how to calculate its total. A class is the blueprint; objects are the things built from it.

A class and its objects

public class Main {
    public static void main(String[] args) {
        BankAccount a = new BankAccount();    // create an object
        a.owner = "Asha";
        a.deposit(5000);

        BankAccount b = new BankAccount();
        b.owner = "Ben";
        b.deposit(1200);

        System.out.println(a.summary());
        System.out.println(b.summary());
    }
}

class BankAccount {
    String owner;          // fields: the object's data
    double balance;

    void deposit(double amount) {      // methods: what it can do
        balance += amount;
    }

    String summary() {
        return owner + ": ₹" + balance;
    }
}

Asha: ₹5000.0
Ben: ₹1200.0

Each object has its own copy of the fields. Methods without static are instance methods: they run on a particular object (a.deposit(...)) and use that object's fields.

Objects live on the heap

new BankAccount() creates the object on the heap and returns a reference to it. The variable a (on the stack) stores that reference.

public class Main {
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = c1;          // same object, two references
        c2.value = 10;
        System.out.println(c1.value);
        System.out.println(c1 == c2);
        Counter c3 = new Counter();
        System.out.println(c3.value + " " + (c1 == c3));   // fields get default values
    }
}

class Counter {
    int value;
}

10
true
0 false

Fields get default values (0, false, null), unlike local variables.

Constructors

Setting fields one by one after new is error-prone – you could forget one. A constructor runs automatically when an object is created and makes sure it starts in a valid state. It has the class's name and no return type.

public class Main {
    public static void main(String[] args) {
        Student s1 = new Student("Ira", 21, 8.9);
        Student s2 = new Student("Jay", 22);
        System.out.println(s1);       // println calls toString()
        System.out.println(s2);
    }
}

class Student {
    String name;
    int rollNo;
    double cgpa;

    Student(String name, int rollNo, double cgpa) {
        this.name = name;         // this.name = the field, name = the parameter
        this.rollNo = rollNo;
        this.cgpa = cgpa;
    }

    Student(String name, int rollNo) {   // overloaded constructor
        this(name, rollNo, 0.0);          // call the other constructor
    }

    @Override
    public String toString() {
        return "Student{" + rollNo + ", " + name + ", " + cgpa + "}";
    }
}

Student{21, Ira, 8.9}
Student{22, Jay, 0.0}

• this refers to the current object. this.name = name copies the parameter into the field with the same name.
• this(...) calls another constructor of the same class – it must be the first statement.
• Overriding toString() controls how the object prints – always worth doing for debugging.

Validation in the constructor

public class Main {
    public static void main(String[] args) {
        Product ok = new Product("Keyboard", 899);
        System.out.println(ok.name + " ₹" + ok.price);
        try {
            new Product("Mouse", -10);
        } catch (IllegalArgumentException e) {
            System.out.println("Rejected: " + e.getMessage());
        }
    }
}

class Product {
    final String name;
    final double price;

    Product(String name, double price) {
        if (name == null || name.isBlank()) throw new IllegalArgumentException("name required");
        if (price < 0) throw new IllegalArgumentException("price cannot be negative");
        this.name = name;
        this.price = price;
    }
}

Keyboard ₹899.0
Rejected: price cannot be negative

An object that can only be created in a valid state saves you from checking it everywhere else.

Practice

Summary