Classes and Objects

In the previous course, all your methods were static and data traveled through parameters. Object-oriented programming (OOP) brings data and the operations that manipulate it together in one place.

• A class is a blueprint: “a bank account has a holder and a balance; you can deposit and withdraw money”.
• An object is a concrete instance built from that blueprint: Ada’s account, Linus’s account.

Declaring a class

class CompteBancaire {
    // Fields (the state of each object)
    String titulaire;
    int solde;               // in euros for simplicity

    // Constructor: same name as the class, no return type
    CompteBancaire(String titulaire, int soldeInitial) {
        this.titulaire = titulaire;     // this.titulaire = field; titulaire = parameter
        this.solde = soldeInitial;
    }

    // Instance methods (no static): they act on THIS object
    void deposer(int montant) {
        solde += montant;
    }

    boolean retirer(int montant) {
        if (montant > solde) {
            return false;               // refused: insufficient balance
        }
        solde -= montant;
        return true;
    }

    @Override
    public String toString() {
        return "Account of " + titulaire + ": " + solde + " EUR";
    }
}

Creating and using objects

public class Main {
    public static void main(String[] args) {
        CompteBancaire a = new CompteBancaire("Ada", 100);   // new calls the constructor
        CompteBancaire b = new CompteBancaire("Linus", 20);
        a.deposer(50);
        boolean ok = b.retirer(30);           // false
        System.out.println(a);                // Account of Ada: 150 EUR (toString called)
        System.out.println(b.solde);          // 20
    }
}

Each object has its own field values: depositing into a changes nothing for b. Several classes can live in the same file, but only one can be public and it must carry the file’s name. If you run the file directly with java Main.java, put the Main class first: Java’s launcher (including Java 25) runs the first class declared in the file. In a real project, each class has its own file.

Multiple constructors

CompteBancaire(String titulaire) {
    this(titulaire, 0);       // calls the other constructor
}

If you write no constructor, Java provides a no-parameter constructor; as soon as you write one, that default constructor disappears.

References and null

A class-typed variable does not hold the object itself but a reference to it:

CompteBancaire c = a;      // c and a refer to the SAME object
c.deposer(10);
System.out.println(a.solde);  // 160: modified through c

CompteBancaire d = null;   // no reference
d.deposer(5);              // NullPointerException at runtime!

This is why == between two objects compares references, not content (we will see equals in lesson 5).

toString()

Every class inherits a toString() method that by default prints something like CompteBancaire@6d06d69c. Overriding it (@Override annotation) makes display and debugging much more pleasant.

In this first lesson, the fields are directly accessible (b.solde). This is convenient but dangerous: nothing stops you from writing b.solde = -1000. The next lesson fixes this problem with encapsulation.