Une heure immuable — exercice corrigé de programmation Java (école d'ingénieur) (chapitre 8)

Une heure immuable

Encapsulation, membres de classe et paquets · niveau 2

Énoncé

Écrire une classe immuable Heure représentant une heure de la journée (heures dans $[0, 24)$ , minutes dans $[0, 60)$ ), avec un constructeur qui refuse les valeurs invalides, une méthode plus(int n) qui retourne l'heure atteinte $n$ minutes plus tard (en passant minuit si nécessaire), et une méthode toString au format 22h45. Un train part à 22h45 pour un trajet de 150 minutes : à quelle heure arrive-t-il ?

Corrigé

On convertit en minutes depuis minuit, on ajoute, on réduit modulo $24 \times 60 = 1440$ , et le constructeur fabrique la nouvelle heure.


// Une heure de la journée, immuable.
final class Heure {
    private final int h;   // dans [0, 24)
    private final int m;   // dans [0, 60)

    Heure(int h, int m) {
        if (h < 0 || h >= 24 || m < 0 || m >= 60) {
            throw new IllegalArgumentException("heure invalide : " + h + ":" + m);
        }
        this.h = h;
        this.m = m;
    }

    public int getH() { return h; }
    public int getM() { return m; }

    // Retourne l'heure atteinte après n minutes (n >= 0), en passant minuit si besoin.
    public Heure plus(int n) {
        int total = (60 * h + m + n) % (24 * 60);
        return new Heure(total / 60, total % 60);
    }

    @Override
    public String toString() { return String.format("%02dh%02d", h, m); }
}

public class Ex4Heure {
    public static void main(String[] args) {
        Heure depart = new Heure(22, 45);
        Heure arrivee = depart.plus(150);
        System.out.println("départ " + depart + ", arrivée " + arrivee);
        System.out.println("départ inchangé : " + depart);
    }
}


départ 22h45, arrivée 01h15
départ inchangé : 22h45

$22 \times 60 + 45 + 150 = 1515$ minutes, et $1515 - 1440 = 75$ minutes, soit 1h15 le lendemain. L'objet depart n'a pas changé : plus a créé un nouvel objet. La méthode suppose $n \geq 0$ : pour $n$ négatif, l'opérateur % de Java pourrait donner un reste négatif, que le constructeur refuserait.