Classes et héritage

• La poo permet de modéliser les éléments qu'on veut traiter sous forme d'objets.
• Un objet contient des membres (propriétés et méthodes).
• Un objet peut être créé (ou instancié) de différentes façons:
  • Les techniques communes: à partir d'une classe ou objets littéraux.
  • Techniques avancées: Singletons, monteurs (Builders), Injection de dépendances.

Python

Définition d'une classe

class User:
    """CamelCase pour les noms de classes"""

    def __init__(self):
        """initialiseur ou constructeur.
        Son usage: Permet d'initialiser les propriétés"""
        self.first_name = "Naruto"
        self.last_name = "Uzumaki"
        self.birth_year = 1800

    def __str__(self) -> str:
        """Représentation textuelle. Utilisée surtout pour l'affichage dans les print"""
        return self.first_name + " " + self.last_name + " " + str(self.birth_year)

    def launch_attack(self):
        print(self.first_name, "launches an attack")


u1 = User()
u2 = User()
u3 = User()

print(u1, u1.first_name, u1.last_name)

u2.birth_year += 20
u2.first_name = "Boruto"
print(u2, u2.first_name, u2.birth_year)

u2.launch_attack()

Exercice

Dans le code donné plus haut, identifier avec des commentaires les parties qui effectuent les opération suivantes: instanciation d'objet, définition d'une classe, définition d'une propriété, définition d'une méthode et appel d'une méthode.

Solution

• Définition d'une classe: class Monster {}
• Instanciation d'objet: new Monster("Lapinou", 100); et new Monster("Chatounet", 0);
• Définition de propriétés: readonly name: string, readonly hp: number
• Appel d'une méthode: monster1.checkAlive(); et monster2.checkAlive();

Classes et héritage simple

• Une classe définit l'ensemble des membres ses instances auront.
• Une classe peut être définie:
  • A partir de zéro,
  • Ou à partie d'une autre classe. Cette technique s'appelle l'héritage simple,
  • Ou à partie de plusieurs classes. Cette technique s'appelle l'héritage multiple. Très peu de langages proposent cette option.
• Une classe peut aussi implémenter des interfaces.
• Le constructeur est la première fonction qui est appelée lors de l'instanciation d'un objet.
  • Certains constructeurs permettent d'initialiser les propriétés avec peu de code.
• Certains langages permettent de définir des modificateurs de visibilité pour ses membres.
  • Modificateurs de visibilité (non disponible en Python):
    • private: membre utilisable uniquement par sa classe.
    • protected: membre utilisable uniquement par sa classe ou celles qui en héritent.
    • public: membres utilisables depuis n'import où.
  • D'autres modificateur peuvent être proposés selon le langage:
    • abstract: rend le membre abstrait
    • readonly: propriété publique en lecture seule (comme un const)
  • static: le membre existera tout le temps en un exemplaire accessible avec le nom de la classe

Définition de deux classes dont une qui hérite de l'autre

class Ship {
  // En préfixant avec private, public ou protected, l'argument devient une propriété.
  constructor(protected speed: number) {}
  move() {
    console.log("Moving at speed", this.speed);
  }

  static staticValue = "Hello !";
}

// static members always exist
console.log(Ship.staticValue);

const ship = new Ship(200);
ship.move();

class SpaceShip extends Ship {
  constructor(speed: number, public staelliteCount: number) {
    super(speed);
  }
}

const spaceShip = new SpaceShip(1000, 5);
console.log("The space ship has ", spaceShip.staelliteCount, " sattelites");