Les associations entre classes
Les associations permettent de décrire les relations entre différentes classes d’objets. Les associations sont des liens qui connectent des instances d’objets entre elles, permettant la collaboration et l’échange d’informations entre les objets concernés. Une association est une connexion logique entre deux classes, indiquant que les instances de ces classes sont liées d’une certaine manière. Les associations sont utiles pour modéliser des situations complexes et pour décrire les relations entre les éléments d’un système. Il existe principalement deux types d’associations : les associations simples et les associations multiples.
Les associations simples
Les associations simples sont des relations unidirectionnelles entre des objets de deux classes distinctes, où un objet de la première classe est associé à un unique objet de la seconde classe. Dans ce type d’association, chaque objet de la première classe possède une référence vers un objet de la seconde classe.
Pour implémenter une association simple, il est nécessaire de définir un attribut dans la classe source qui fera référence à l’objet de la classe cible. Vous devrez également prévoir la gestion des cas où l’association est facultative, en vous assurant que votre code gère correctement les situations où la référence n’est pas établie.
Prenons comme exemple notre classe Véhicule:
- Pour une association obligatoire, un véhicule ne peut pas exister sans être associé à un fabricant.
class Fabricant:
def __init__(self, nom):
self.nom = nom
class Vehicule:
def __init__(self, marque, modele, fabricant):
self.marque = marque
self.modele = modele
self.fabricant = fabricant
fabricant = Fabricant("Tesla")
vehicule = Vehicule("Model 3", "2023", fabricant)#include <iostream>
#include <string>
#include <memory>
class Fabricant {
public:
Fabricant(std::string nom) : nom(nom) {}
std::string nom;
};
class Vehicule {
public:
Vehicule(std::string marque, std::string modele, std::shared_ptr<Fabricant> fabricant)
: marque(marque), modele(modele), fabricant(fabricant) {}
std::string marque;
std::string modele;
std::shared_ptr<Fabricant> fabricant;
};
int main() {
std::shared_ptr<Fabricant> fabricant = std::make_shared<Fabricant>("Tesla");
Vehicule vehicule("Model 3", "2023", fabricant);
return 0;
}using System;
public class Fabricant
{
public string Nom { get; set; }
public Fabricant(string nom)
{
Nom = nom;
}
}
public class Vehicule
{
public string Marque { get; set; }
public string Modele { get; set; }
public Fabricant Fabricant { get; set; }
public Vehicule(string marque, string modele, Fabricant fabricant)
{
Marque = marque;
Modele = modele;
Fabricant = fabricant;
}
}
public class Program
{
public static void Main()
{
Fabricant fabricant = new Fabricant("Tesla");
Vehicule vehicule = new Vehicule("Model 3", "2023", fabricant);
}
}- Pour une association facultative, un véhicule peut ou peut ne pas avoir de propriétaire.
class Proprietaire:
def __init__(self, nom, prenom):
self.nom = nom
self.prenom = prenom
class Vehicule:
def __init__(self, marque, modele, proprietaire=None):
self.marque = marque
self.modele = modele
self.proprietaire = proprietaire
proprietaire = Proprietaire("Dupont", "Pierre")
vehicule1 = Vehicule("Model 3", "2023", proprietaire)
vehicule2 = Vehicule("Model S", "2023")
#include <iostream>
#include <memory>
#include <string>
class Proprietaire {
public:
Proprietaire(const std::string& nom, const std::string& prenom)
: nom(nom), prenom(prenom) {}
std::string nom;
std::string prenom;
};
class Vehicule {
public:
Vehicule(const std::string& marque, const std::string& modele, std::shared_ptr<Proprietaire> proprietaire = nullptr)
: marque(marque), modele(modele), proprietaire(proprietaire) {}
std::string marque;
std::string modele;
std::shared_ptr<Proprietaire> proprietaire;
};
int main() {
auto proprietaire = std::make_shared<Proprietaire>("Dupont", "Pierre");
Vehicule vehicule1("Model 3", "2023", proprietaire);
Vehicule vehicule2("Model S", "2023");
return 0;
}using System;
public class Proprietaire
{
public string Nom { get; set; }
public string Prenom { get; set; }
public Proprietaire(string nom, string prenom)
{
Nom = nom;
Prenom = prenom;
}
}
public class Vehicule
{
public string Marque { get; set; }
public string Modele { get; set; }
public Proprietaire Proprietaire { get; set; }
public Vehicule(string marque, string modele, Proprietaire proprietaire = null)
{
Marque = marque;
Modele = modele;
Proprietaire = proprietaire;
}
}
public class Program
{
public static void Main()
{
Proprietaire proprietaire = new Proprietaire("Dupont", "Pierre");
Vehicule vehicule1 = new Vehicule("Model 3", "2023", proprietaire);
Vehicule vehicule2 = new Vehicule("Model S", "2023");
}
}Les associations multiples
Les associations multiples sont des relations entre des objets de deux classes distinctes, où un objet de la première classe est associé à plusieurs objets de la seconde classe. Dans ce type d’association, chaque objet de la première classe possède un tableau de références vers les objets de la seconde classe.
Pour implémenter une association multiple, il est nécessaire de définir un attribut dans la classe source qui sera une collection statique si tous les éléments sont obligatoires; ou dynamique s’il est imprévisible d’en savoir le nombre. C’est cette collection (statique ou dynamique) qui contiendra des références aux objets de la classe cible. Les associations multiples facultatives sont des cas où l’association entre les objets n’est pas obligatoire, et il est possible qu’un objet de la première classe n’ait aucune référence vers un objet de la seconde classe. Dans ces situations, il est important, là aussi, de gérer correctement les cas où la collection est vide ou nulle, afin d’éviter des erreurs ou des comportements inattendus dans votre code.
