Programmation · Prog 7 · Les objets

Classes et objets

Un plan écrit une fois, des objets fabriqués à volonté : chacun avec ses données et ses gestes.

Déjà à l'aise ? Aller directement au quiz

Dans la vraie vie

Un architecte dessine le plan d’une maison une seule fois. Avec ce plan, on peut bâtir tout un quartier.

le plan 246 même plan, trois maisons

Même forme pour toutes ; chaque maison a sa couleur, ses habitants, son adresse.

Une classe, c’est ce plan. Un objet, c’est une maison.

La classe décrit les données (les attributs). Chaque objet fabriqué avec elle a ses propres valeurs.

class Maison couleur · numeroouvrir() Maisoncouleur = "rouge"numero = 2Maisoncouleur = "verte"numero = 4

Où l’image s’arrête

Un plan de maison ne sait rien faire. Une classe, si : elle range aussi des méthodes, des fonctions que tous ses objets partagent.

class Maison donnéescouleur, numero gestesouvrir(), fermer() objetobjetobjet partagés

Un plan. Autant d’objets que tu veux.

Au programme

  • 01des variables en vrac
  • 02classe et objet
  • 03ce qu’il y a dans un objet
  • 04le constructeur
  • 05self, l’objet en cours
  • 06les références
  • 07ce que tous partagent
  • 08un combat en objets

Neuf variables pour trois personnages

Dans la vraie vie

Autour d’une table de jeu de rôle, chaque joueur tient la fiche de son personnage : un nom, des points de vie, une attaque.

fichefichefiche Link10025Zelda9030Ganon20040 en vrac trois fiches, une même forme

Neuf post-it en vrac sur la table, et plus personne ne sait qui a combien de points de vie.

Sans classe, c’est le vrac.

Chaque donnée vit dans sa propre variable : joueur1_nom, joueur1_pv, joueur1_atk… Rien ne les relie, et rien n’empêche de mélanger le nom de l’un avec les points de vie de l’autre.

Trois personnages

Les neuf variables se rangent : en groupes, puis en objets, puis sous une seule classe.

Trois personnages9 variables
Neuf variables en vrac : le nom, les points de vie et l'attaque de trois personnages

En vrac. Neuf variables pour trois personnages. Pour deux cents ennemis, il en faudrait six cents.

Tu as vu ? La classe ne contient aucune valeur.

Où sont les valeurs, alors ?

Dans les objets. La classe décrit seulement leur forme, comme le plan de l’architecte.

Sans classe, les données et la fonction qui les manipule sont séparées :

Pythonvrac.py
joueur1_nom = "Link"
joueur1_pv = 100
joueur1_atk = 25
joueur2_nom = "Ganon"
joueur2_pv = 200
joueur2_atk = 40

def attaquer(atk, pv_cible):
    return pv_cible - atk

joueur2_pv = attaquer(joueur1_atk,
                      joueur2_pv)

Il faut passer chaque valeur à la main, et renvoyer le résultat dans la bonne variable.

Avec une classe, chaque objet transporte ses données et sait agir sur elles :

Pythonobjets.py
class Personnage:
    def __init__(self, nom, pv, atk):
        self.nom = nom
        self.pv = pv
        self.atk = atk

    def attaquer(self, cible):
        cible.pv -= self.atk

link = Personnage("Link", 100, 25)
ganon = Personnage("Ganon", 200, 40)
link.attaquer(ganon)   # ganon.pv : 175

Deux cents ennemis ? Deux cents appels à Personnage(...), souvent dans une boucle.

C’est la programmation orientée objet.

On organise le programme autour d’objets qui regroupent des données et les fonctions qui les manipulent. Python, Java, C#, JavaScript, Kotlin ou Swift permettent tous d’écrire des classes.

En Java, tout le code vit dans des classes, même main ; depuis Java 25, un petit programme peut omettre la déclaration de classe : le compilateur en crée une implicitement6.

Une classe, autant d’objets qu’on veut

Chien, pas à pas

Une classe, puis deux objets créés dans le tas. Les lignes s’allument au fil du défilement.

  1. class Chien:
  2. def __init__(self, nom, age):
  3. self.nom = nom
  4. self.age = age
  5. a = Chien("Rex", 3)
  6. b = Chien("Luna", 5)

1. Python lit la classe. Il crée l'objet classe Chien, avec sa méthode __init__. Aucun chien n'existe encore.

2. Chien("Rex", 3), à droite du =. Appeler la classe crée un objet vide, de type Chien, dans le tas.

3. Python appelle __init__. self désigne le nouvel objet ; les paramètres nom et age reçoivent les arguments "Rex" et 3.

4. self.nom = nom, puis self.age = age. Les attributs sont créés dans l'objet ; les paramètres disparaîtront à la fin de l'appel.

5. Fin de __init__, qui ne renvoie rien. a reçoit une référence vers l'objet (la flèche), pas une copie.

6. b = Chien("Luna", 5). Un second objet, avec ses valeurs. __init__ reste rangée une seule fois, dans la classe.

Classe

Le plan, écrit une seule fois : class Chien:

Objet, instance

Un exemplaire fabriqué avec ce plan : Chien("Rex", 3). Les deux mots désignent la même chose.

Attribut

Une donnée rangée dans l’objet : nom, age. Chaque objet a ses propres valeurs.

Méthode

Une fonction définie dans la classe, qui agit sur l’objet : anniversaire().

Référence

Ce que contient la variable a : le moyen de retrouver l’objet dans le tas, pas l’objet lui-même.

Les noms ont leurs conventions : PascalCase pour les classes, en Python comme en Java. Pour les attributs et les méthodes : snake_case en Python, camelCase en Java et en JavaScript.

CompteBancaire PascalCaseles classes subir_degats snake_caseen Python subirDegats camelCaseJava, JavaScript
Exercice 1

Attribut ou méthode ?

Une classe CompteBancaire. Fais glisser chaque étiquette dans sa case (ou touche l'étiquette, puis la case).

Attributune donnée que l'objet garde
Méthodeune action que l'objet sait faire

Démonter un objet

Dans la vraie vie

Chez le vétérinaire, Rex a une puce avec un numéro unique, une espèce, un âge et un poids.

puceun numéro unique espècechien âge, poids3 ans, 18 kg saitaboyer, s’asseoir

Et il sait aboyer, comme tous les chiens.

La documentation de Python le dit en une phrase : chaque objet a une identité, un type et une valeur, son état2.

la puceid(rex)identité l’espècetype(rex)type âge, poidsrex.__dict__état

Et le geste « aboyer » ? Il est rangé ailleurs. Démontons rex pour le voir.

L’objet rex

Il se démonte en quatre pièces, puis se remonte.

L'objet rexassemblé
L'objet rex et ses quatre pièces : identité, type, état, comportement

Un seul objet… mais plusieurs pièces. Fais défiler pour le démonter.

Python permet de voir ces pièces :

Pythonanatomie.py
rex = Chien("Rex", 3)
print(id(rex))
print(type(rex))
print(rex.__dict__)
Sortie
4372816976
<class '__main__.Chien'>
{'nom': 'Rex', 'age': 3}

Le premier nombre n’est qu’un exemple : il change d’une exécution à l’autre. __dict__ ne contient que l’état.

Où l’image s’arrête

Un vrai chien porte ses gestes en lui. Un objet, non.

class Chien anniversaire() rexnom = "Rex"age = 3lunanom = "Luna"age = 5 partagée

Ses méthodes sont rangées une seule fois, dans la classe, et tous les chiens les partagent.

is compare les identités.

a is b vaut True seulement si a et b désignent le même objet. On s’en sert au chapitre 6.

Chaque objet naît rempli

Dans la vraie vie

À la sortie de l’usine, chaque voiture reçoit sa marque, sa couleur, et un compteur à zéro.

marquecouleurcompteur Tesla 0 km

Toutes passent par la même étape ; chacune en sort avec ses réglages.

Le constructeur fait ce travail : il remplit les attributs d’un nouvel objet avec les valeurs données à la création. En Python, c’est __init__ ; en Java et en JavaScript, le constructeur.

voiture.py
class Voiture:
    def __init__(self, marque, couleur):
        self.marque = marque
        self.couleur = couleur
        self.vitesse = 0

ma_voiture = Voiture("Tesla", "rouge")

Trois attributs : deux viennent des arguments, le troisième démarre à 0.

Paramètres dans la définition, arguments dans l’appel, transmis dans l’ordre4. En Python, self reçoit l’objet tout seul : on ne l’écrit pas dans l’appel.

def __init__(self, nom, age): Chien("Rex", 3) nouvel objet self reçoit l’objet tout seul

La même voiture, cinq langages

Python, Java, JavaScript, C# et C++ : la même classe, la même sortie.

Pythonvoiture.py
class Voiture:
    def __init__(self, marque, couleur):
        # trois attributs, dont un qui part de 0
        self.marque = marque
        self.couleur = couleur
        self.vitesse = 0

    def accelerer(self, kmh):
        self.vitesse += kmh
        return f"Vitesse : {self.vitesse} km/h"

ma_voiture = Voiture("Tesla", "rouge")
print(ma_voiture.marque)
print(ma_voiture.accelerer(50))
JavaVoiture.java
public class Voiture {
    private String marque;
    private String couleur;
    private int vitesse = 0;

    // Constructeur : nom de la classe,
    // pas de type de retour
    public Voiture(String marque, String couleur) {
        this.marque = marque;
        this.couleur = couleur;
    }

    public String accelerer(int kmh) {
        this.vitesse += kmh;
        return "Vitesse : " + vitesse + " km/h";
    }

    public String getMarque() {
        return marque;
    }
}

// Ailleurs, par exemple dans main :
Voiture maVoiture = new Voiture("Tesla", "rouge");
System.out.println(maVoiture.getMarque());
System.out.println(maVoiture.accelerer(50));
JavaScriptvoiture.js
class Voiture {
    constructor(marque, couleur) {
        this.marque = marque;
        this.couleur = couleur;
        this.vitesse = 0;
    }

    accelerer(kmh) {
        this.vitesse += kmh;
        return `Vitesse : ${this.vitesse} km/h`;
    }
}

const maVoiture = new Voiture("Tesla", "rouge");
console.log(maVoiture.marque);
console.log(maVoiture.accelerer(50));
C#Voiture.cs
public class Voiture {
    // Propriétés
    public string Marque { get; set; }
    public string Couleur { get; set; }
    public int Vitesse { get; private set; } = 0;

    public Voiture(string marque, string couleur) {
        Marque = marque;
        Couleur = couleur;
    }

    public string Accelerer(int kmh) {
        Vitesse += kmh;
        return $"Vitesse : {Vitesse} km/h";
    }
}

// Ailleurs, par exemple dans Main :
var maVoiture = new Voiture("Tesla", "rouge");
Console.WriteLine(maVoiture.Marque);
Console.WriteLine(maVoiture.Accelerer(50));
C++voiture.cpp
class Voiture {
private:
    std::string marque;
    std::string couleur;
    int vitesse = 0;

public:
    Voiture(std::string m, std::string c)
        : marque(m), couleur(c) {}

    std::string accelerer(int kmh) {
        vitesse += kmh;
        return "Vitesse : " + std::to_string(vitesse) + " km/h";
    }

    std::string getMarque() const { return marque; }
};

// Ailleurs, par exemple dans main :
Voiture maVoiture("Tesla", "rouge");
std::cout << maVoiture.getMarque() << std::endl;
std::cout << maVoiture.accelerer(50) << std::endl;
Sortie (la même dans les cinq langages)
Tesla
Vitesse : 50 km/h

Python

On appelle la classe comme une fonction, sans new : Python crée l’objet, puis appelle __init__1, qui ne renvoie rien.

Java

Le constructeur porte le nom de la classe, sans type de retour. new réserve la place de l’objet. Sans constructeur écrit, le compilateur en fournit un sans paramètre5.

JavaScript

La méthode constructor, une seule par classe, appelée par new.

Une valeur par défaut, ou deux constructeurs

Python et JavaScript donnent une valeur par défaut au niveau ; Java écrit un second constructeur.

Pythonjoueur.py
class Joueur:
    # niveau vaut 1 si on ne le donne pas
    def __init__(self, nom, niveau=1):
        self.nom = nom
        self.niveau = niveau
        self.pv = 100
        self.inventaire = []
        print(f"{nom} créé, niveau {niveau}")

hero = Joueur("Link")
boss = Joueur("Ganon", 50)
JavaJoueur.java
public class Joueur {
    private String nom;
    private int niveau;
    private int pv = 100;

    public Joueur(String nom, int niveau) {
        this.nom = nom;
        this.niveau = niveau;
        System.out.println(nom + " créé, niveau " + niveau);
    }

    // Second constructeur (surcharge) :
    // il appelle le premier avec le niveau 1
    public Joueur(String nom) {
        this(nom, 1);
    }
}

Joueur hero = new Joueur("Link");
Joueur boss = new Joueur("Ganon", 50);
JavaScriptjoueur.js
class Joueur {
    constructor(nom, niveau = 1) {
        this.nom = nom;
        this.niveau = niveau;
        this.pv = 100;
        this.inventaire = [];
        console.log(`${nom} créé, niveau ${niveau}`);
    }
}

const hero = new Joueur("Link");
const boss = new Joueur("Ganon", 50);
Sortie (identique dans les trois langages)
Link créé, niveau 1
Ganon créé, niveau 50

Piège : oublier un argument.

__init__ attend nom et age, mais l’appel ne donne qu’un nom :

Python
rex = Chien("Rex")
TypeError: Chien.__init__() missing 1 required positional argument: 'age'

En Java, le programme ne compile même pas : aucun constructeur n’accepte un seul argument.

Exercice 2

Le bon mot, la bonne ligne

Touche la bonne réponse. L'explication s'affiche tout de suite.

Dans def __init__(self, nom, age):, que sont nom et age ?

Dans Chien("Luna", 5), que sont "Luna" et 5 ?

En Java, quelle ligne crée un objet ?

Que renvoie __init__ ?

Qui est self ?

Dans la vraie vie

Quand Léa dit « je », elle parle d’elle. Quand Tom dit « je », il parle de lui.

LéaTom « Je suis Léa. » « Je suis Tom. »

Le mot est le même ; la personne qu’il désigne dépend de celui qui parle.

self, c’est le « je » de l’objet. Dans une méthode, self désigne l’objet sur lequel on l’appelle.

a.anniversaire()selfChien « Rex » b.anniversaire()selfChien « Luna »

En Java et en JavaScript, ce « je » s’appelle this.

Un appel de méthode

a.anniversaire() se démonte : ce que Python exécute vraiment, puis ce que reçoit self.

Un appel de méthodea.anniversaire()
L'appel a.anniversaire() et la mémoire : a désigne Rex, b désigne Luna

Ce que tu écris. a.anniversaire() : on appelle la méthode sur l'objet désigné par a.

Python : self écrit

Premier paramètre de chaque méthode : a.anniversaire() équivaut à Chien.anniversaire(a)1. Le nom self n’est qu’une convention, que tout le monde suit.

Java, JavaScript : this

this désigne l’objet sans figurer dans les paramètres. En Java, age++ veut dire this.age++ ; on écrit this.nom = nom; quand un paramètre porte le nom d’un attribut.

Piège 1 : oublier self

def anniversaire(): puis rex.anniversaire() : TypeError, 0 argument attendu, 1 reçu. Python a transmis l’objet, mais rien ne le reçoit.

Piège 2 : oublier self.

Dans la méthode, age += 1 tout court désigne une variable locale qui n’existe pas : UnboundLocalError: cannot access local variable 'age'. Il faut self.age += 1.

Des méthodes qui changent l’objet

subir_degats et gagner_xp modifient les attributs du joueur : en Python, en Java et en JavaScript.

Pythonmethodes.py
class Joueur:
    def __init__(self, nom):
        self.nom = nom
        self.pv = 100
        self.xp = 0

    def subir_degats(self, degats):
        self.pv -= degats
        if self.pv <= 0:
            return f"{self.nom} est KO !"
        return f"{self.nom} : {self.pv} PV restants"

    def gagner_xp(self, points):
        self.xp += points
        return f"+{points} XP ! Total : {self.xp}"

hero = Joueur("Link")
print(hero.subir_degats(30))
print(hero.gagner_xp(100))
JavaJoueur.java
public class Joueur {
    private String nom;
    private int pv = 100;
    private int xp = 0;

    public Joueur(String nom) {
        this.nom = nom;
    }

    public String subirDegats(int degats) {
        // pv veut dire this.pv
        pv -= degats;
        if (pv <= 0) {
            return nom + " est KO !";
        }
        return nom + " : " + pv + " PV restants";
    }

    public String gagnerXp(int points) {
        xp += points;
        return "+" + points + " XP ! Total : " + xp;
    }
}
JavaScriptmethodes.js
class Joueur {
    constructor(nom) {
        this.nom = nom;
        this.pv = 100;
        this.xp = 0;
    }

    subirDegats(degats) {
        // en JavaScript, this est obligatoire
        this.pv -= degats;
        if (this.pv <= 0) {
            return `${this.nom} est KO !`;
        }
        return `${this.nom} : ${this.pv} PV restants`;
    }

    gagnerXp(points) {
        this.xp += points;
        return `+${points} XP ! Total : ${this.xp}`;
    }
}
Sortie de la version Python
Link : 70 PV restants
+100 XP ! Total : 100
Exercice 3

Remets le programme dans l'ordre

Touche les lignes dans l'ordre pour écrire un programme qui fonctionne. Regarde aussi le décalage (l'indentation) : il dit à quel bloc appartient chaque ligne.

  1. class Compte:
  2. def __init__(self, titulaire):
  3. self.titulaire = titulaire
  4. self.solde = 0
  5. def deposer(self, montant):
  6. self.solde += montant
  7. c = Compte("Léa")
  8. c.deposer(50)
  9. print(c.titulaire, c.solde)

Que se passe-t-il à la dernière ligne ?

class Chien:
    def __init__(self, nom):
        self.nom = nom
    def anniversaire():
        print("Un an de plus !")

rex = Chien("Rex")
rex.anniversaire()

Deux noms, un seul objet

Une question : deux variables désignent le même objet. On le modifie par la première. Que voit la seconde ?

L’ancienne valeur ?

Garde ta réponse en tête. On vérifie juste après.

Dans la vraie vie

Deux télécommandes pour une seule télé : change de chaîne avec l’une, l’écran change pour les deux.

3 7 ab a change de chaîne une seule télé

Il n’y a pas deux télés, mais deux façons de joindre la même.

Une variable ne contient pas l’objet : elle contient une référence, le moyen de le retrouver dans le tas. Avec b = a, deux variables désignent le même objet.

ab Chien nom = "Rex" nom = "Max" age = 3 b.nom = "Max" a.nom vaut "Max" aussi

Où l’image s’arrête : None, c’est une télécommande reliée à aucune télé. Appuyer sur un bouton provoque une erreur.

Références

Quatre situations : alias, == ou is, passage à une fonction, None. Le code s’exécute ligne par ligne.

Référencesligne 1

    Verdict : la seconde voit la modification. Il n’y a qu’un seul objet.

    Et pour avoir un vrai double ?

    Il faut créer un nouvel objet, ou utiliser copy.copy.

    Copier une référence

    Chien c = a; copie la référence, pas l’objet : même comportement qu’en Python.

    == et equals

    == compare les références. equals() compare le contenu seulement si la classe le redéfinit. Pour les String, on compare toujours avec equals.

    Tout par valeur

    Java passe tout par valeur : pour un objet, la valeur copiée est la référence4. La méthode peut modifier l’objet, pas la variable de l’appelant. Python fait pareil : passage par affectation3.

    null et None

    Lire un attribut sur null lève une NullPointerException ; en Python, sur None, une AttributeError.

    Modifier ou remplacer ?

    renommer modifie l’objet reçu ; remplacer ne change que sa variable locale.

    Pythonpassage.py
    def renommer(chien):
        # modifie l'objet reçu
        chien.nom = "Max"
    
    def remplacer(chien):
        # ne change que la variable locale
        chien = Chien("Max", 1)
    
    a = Chien("Rex", 3)
    remplacer(a)
    print(a.nom)    # Rex
    renommer(a)
    print(a.nom)    # Max
    JavaPassage.java
    static void renommer(Chien chien) {
        // modifie l'objet reçu
        chien.nom = "Max";
    }
    
    static void remplacer(Chien chien) {
        // ne change que la copie locale
        chien = new Chien("Max", 1);
    }
    
    Chien a = new Chien("Rex", 3);
    remplacer(a);
    System.out.println(a.nom);   // Rex
    renommer(a);
    System.out.println(a.nom);   // Max
    Exercice 4

    Prédis la sortie

    La classe Chien est celle de la notion 2. Que va afficher chaque programme ?

    a = Chien("Rex", 3)
    b = a
    b.age = 10
    print(a.age)
    x = Chien("Rex", 3)
    y = Chien("Rex", 3)
    print(x == y, x is x)
    def vieillir(chien):
        chien.age += 1
        chien = Chien("Bébé", 0)
    
    rex = Chien("Rex", 3)
    vieillir(rex)
    print(rex.nom, rex.age)

    Un seul exemplaire pour tous

    Dans la vraie vie

    À l’entrée d’un musée, un compteur au portique compte tous les visiteurs. Chaque visiteur, lui, a son propre billet.

    visiteurs 2 LéaTom un compteur pour tous un billet chacun

    Un compteur pour tout le monde, un billet par personne.

    Un attribut de classe existe en un seul exemplaire, partagé par tous les objets : c’est le compteur. Un attribut d’instance existe en un exemplaire par objet : c’est le billet.

    class Chien nb = 2 anom = "Rex"bnom = "Luna" un seul nb, partagé

    En Java, on le déclare static.

    Le compteur partagé

    On crée deux chiens, puis on tombe dans le piège de self.nb.

    Le compteur partagéChien.nb = 0
    1. class Chien:
    2. nb = 0
    3. def __init__(self, nom):
    4. self.nom = nom
    5. Chien.nb += 1
    6. a = Chien("Rex")
    7. b = Chien("Luna")

    nb est défini dans la classe. Il existe en un seul exemplaire, avant même qu'un chien soit créé.

    En Python et en Java

    Le même compteur, écrit dans les deux langages.

    Pythoncompteur.py
    class Chien:
        # attribut de classe : un seul exemplaire
        nb = 0
    
        def __init__(self, nom):
            # attribut d'instance : un par objet
            self.nom = nom
            Chien.nb += 1
    
    a = Chien("Rex")
    b = Chien("Luna")
    print(Chien.nb)   # 2
    JavaChien.java
    public class Chien {
        // attribut de classe
        static int nb = 0;
        // attribut d'instance
        String nom;
    
        Chien(String nom) {
            this.nom = nom;
            nb++;             // c'est Chien.nb
        }
    }
    
    Chien a = new Chien("Rex");
    Chien b = new Chien("Luna");
    System.out.println(Chien.nb);   // 2

    En Java, un attribut static appartient à la classe : tous les objets partagent le même, rangé à un seul endroit de la mémoire. On l’écrit de préférence Chien.nb, pour que ce soit clair.

    Piège : une liste en attribut de classe.

    Avec inventaire = [] écrit dans la classe, tous les joueurs partagent la même liste1.

    linkzelda une seule liste 'épée' link ramasse une épée zelda.inventaire : ['épée'] !

    Une liste propre à chaque objet se crée dans __init__ : self.inventaire = [].

    Tout assembler

    Dans la vraie vie

    Au festival, chacun porte un badge : « Link, guerrier ». Sans badge, on ne verrait qu’un numéro de bracelet.

    n° 0x7f3a sans badge Link, guerrier10 PV avec badge

    Le badge, c’est ce que la personne montre quand on lui demande qui elle est.

    Par défaut, print(hero) affiche quelque chose comme <__main__.Personnage object at 0x…> : le type et une adresse. Pour un affichage lisible, la classe définit __str__ en Python, toString() en Java et en JavaScript.

    sans __str__ <__main__.Personnage object at 0x10a…> avec __str__ Link (Guerrier) : 10 PV

    Un petit combat : un héros frappe un monstre. Suis-le ligne par ligne, et regarde qui est self.

    combat.pyPython
    class Personnage:    def __init__(self, nom):        self.nom = nom        self.pv = 100        self.attaque = 10    def attaquer(self, cible):        cible.subir_degats(self.attaque)    def subir_degats(self, degats):        self.pv = max(0, self.pv - degats)    def __str__(self):        return f"{self.nom} : {self.pv} PV" hero = Personnage("Link")monstre = Personnage("Gobelin")hero.attaquer(monstre)print(monstre)
    hero · Linkpv = 100selfmonstre · Gobelinpv = 100self

    Une classe, trois méthodes. attaquer agit sur une cible, subir_degats retire des points de vie, __str__ présente l’objet.

    Deux objets. hero et monstre sortent du même plan, avec 100 points de vie chacun.

    hero.attaquer(monstre). Dans attaquer, self désigne hero et cible désigne monstre.

    cible.subir_degats(10). Nouvelle méthode, nouvel objet : ici, self désigne monstre. Ses points de vie passent à 90.

    print(monstre). Python appelle __str__, avec self = monstre : la console affiche « Gobelin : 90 PV ».

    Le combat complet

    Les deux personnages s’attaquent jusqu’à ce que l’un tombe : en Python et en JavaScript.

    Pythoncombat.py
    class Personnage:
        def __init__(self, nom, classe):
            self.nom = nom
            self.classe = classe
            self.pv = 100
            self.attaque = 10
    
        def attaquer(self, cible):
            cible.subir_degats(self.attaque)
            return f"{self.nom} attaque {cible.nom} !"
    
        def subir_degats(self, degats):
            self.pv = max(0, self.pv - degats)
    
        def est_vivant(self):
            return self.pv > 0
    
        def __str__(self):
            return f"{self.nom} ({self.classe}) : {self.pv} PV"
    
    hero = Personnage("Link", "Guerrier")
    monstre = Personnage("Gobelin", "Monstre")
    
    while hero.est_vivant() and monstre.est_vivant():
        print(hero.attaquer(monstre))
        print(monstre)
        if monstre.est_vivant():
            print(monstre.attaquer(hero))
    print(hero)
    JavaScriptcombat.js
    class Personnage {
        constructor(nom, classe) {
            this.nom = nom;
            this.classe = classe;
            this.pv = 100;
            this.attaque = 10;
        }
    
        attaquer(cible) {
            cible.subirDegats(this.attaque);
            return `${this.nom} attaque ${cible.nom} !`;
        }
    
        subirDegats(degats) {
            this.pv = Math.max(0, this.pv - degats);
        }
    
        estVivant() {
            return this.pv > 0;
        }
    
        toString() {
            return `${this.nom} (${this.classe}) : ${this.pv} PV`;
        }
    }
    
    const hero = new Personnage("Link", "Guerrier");
    const monstre = new Personnage("Gobelin", "Monstre");
    
    while (hero.estVivant() && monstre.estVivant()) {
        console.log(hero.attaquer(monstre));
        console.log(String(monstre));
        if (monstre.estVivant()) {
            console.log(monstre.attaquer(hero));
        }
    }
    console.log(String(hero));
    Fin de la sortie
    Link attaque Gobelin !
    Gobelin (Monstre) : 0 PV
    Link (Guerrier) : 10 PV
    Exercice 5

    Qui frappe le dernier ?

    Dans le combat ci-dessus, pourquoi Link termine-t-il avec 10 PV ?

    Tes objets se parlent entre eux, maintenant.

    Et la suite ?

    L’héritage : une classe qui reprend tout d’une autre, et y ajoute ses propres gestes.

    La fiche en six cartes

    Classe et objet

    Une classe est un plan ; un objet (une instance) est un exemplaire de ce plan, avec ses propres valeurs.

    Dans un objet

    Une identité, un type et un état (ses attributs). Les méthodes sont rangées une seule fois, dans la classe.

    Le constructeur

    __init__ en Python initialise les attributs. Paramètres dans la définition, arguments dans l’appel.

    self

    a.methode() revient à Classe.methode(a) : self (this) désigne l’objet appelé.

    Références

    Une variable contient une référence : b = a ne copie pas l’objet. is (et == en Java) compare les identités.

    Attribut de classe

    Partagé par tous les objets (static en Java). Une liste propre à chaque objet se crée dans le constructeur.

    Dix questions, zéro faute

    Mode survie

    Dix questions tirées au hasard, de plus en plus difficiles. À la première erreur, la partie s’arrête : lis l’explication, puis relance.

    Avant de te lancer : pour chaque question de code, dessine mentalement les flèches entre variables et objets. C’est là que se cachent les pièges.

    10 questions · zéro faute · chronomètre

    Sources

    1. Python Software Foundation, Le tutoriel Python : Classes, documentation Python 3, consultée en 2026. docs.python.org
    2. Python Software Foundation, Référence du langage Python : Modèle de données, documentation Python 3, consultée en 2026. docs.python.org
    3. Python Software Foundation, FAQ de programmation (passage des arguments par affectation), documentation Python 3, consultée en 2026. docs.python.org
    4. Oracle, The Java Tutorials : Passing Information to a Method or a Constructor, consulté en 2026. docs.oracle.com
    5. Oracle, The Java Tutorials : Providing Constructors for Your Classes, consulté en 2026. docs.oracle.com
    6. OpenJDK, JEP 512 : Compact Source Files and Instance Main Methods, livrée avec Java 25, 2025. openjdk.org

    Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026. Les extraits de code ont été exécutés (Python 3.14, Java 21, Node 25, C++17).

    Glisser pour continuer vers Prog 8 : Héritage et polymorphisme
    Gymnase 1