Ch. 1-2 — Bases de l'objet et références

De l'impératif à l'objet

En iJava, les traitements vivaient à côté des structures : une fonction externe isBefore(c1, c2) prenait deux dates en paramètres. En objet, le traitement s'intègre à la structure : c1.isBefore(c2) — la donnée et les opérations qui la concernent forment une seule entité. C'est tout le changement de paradigme du semestre.

Le point d'entrée reste le même :

public static void main(String[] args) {
    System.out.println("Bonjour objet");
}

Une classe se décrit en UML en trois compartiments — nom, attributs, méthodes — et une classe Java par fichier, au nom identique.

Constructeur et instanciation

L'instanciation passe par new suivi d'un constructeur : une méthode spéciale qui porte le nom de la classe et n'a aucun type de retour (même pas void).

public class Book {
    private String author;
    private String title;
    private int year;

    public Book(String author, String title, int year) {
        this.author = author;
        this.title = title;
        this.year = year;
    }
}

Sans affectation explicite, les attributs prennent une valeur par défaut : 0 pour les nombres, false pour les booléens, null pour les références — d'où la NullPointerException dès qu'on sollicite une référence non initialisée. Les types primitifs ont leurs classes Wrappers (Integer, Double…) avec auto-boxing/unboxing : une List<Integer> accepte un int tout seul.

Références : la mécanique de la mémoire

Book b1; crée une variable, pas un objet — la mémoire n'existe qu'après new, et elle est libérée par le Garbage Collector quand plus aucune référence n'y accède. Un tableau d'objets est rempli de null avant initialisation : il faut créer chaque élément.

Le passage par valeur est le piège classique du chapitre : réaffecter un paramètre ne change rien à l'extérieur (param = new Book(...) n'a aucun effet visible), mais param.setPrice(5.0) modifie bien l'objet partagé — les trois traces d'exécution du cours le démontrent pas à pas.

this lève l'ambiguïté paramètre/attribut et permet à une méthode de retourner sa propre référence. Et surtout : == compare les références, equals() compare les attributs.

@Override
public boolean equals(Object other) {
    if (this == other) return true;
    if (other == null) return false;
    if (getClass() != other.getClass()) return false;
    Book book = (Book) other;
    return year == book.year
        && author.equals(book.author)
        && title.equals(book.title);
}

Les String sont immuables — chaque « modification » crée un nouvel objet ; StringBuilder est la version mutable pour assembler du texte.

Encapsulation et visibilité

Trois niveaux au menu du chapitre : private (-, accessible dans la classe), default (~, accessible dans le paquetage), public (+, accessible partout). Encapsuler, c'est pouvoir changer l'interne sans casser les clients — par exemple stocker un prix HT et calculer le TTC dans l'accesseur — et décomposer le travail avec des méthodes private sans enrichir l'interface publique.

En UML, les multiplicités d'association (1, 0..1, 1..*, *, n..m) et la navigabilité (un attribut unilatéral pour Theater → Film) précisent les relations entre classes.

A retenir

• classe = attributs + méthodes ; constructeur sans type de retour ;
• == compare les références, equals() compare les attributs ;
• l'objet est partagé, la référence est copiée ;
• encapsuler pour se protéger de l'extérieur, pas pour s'isoler.