exercice générique CNAM

//class interface donc 100% abstraite
interface Mesurable {
    length: number;
    //nom: String;
}
//Trajet implémente l'interface Mesurable (créer/initialiser attr et corps de fonctions)
/*Son rôle est de crée un objet Trajet qui possède:
    -un nom et une distance en km
    -afficher en 'string' ces caractèristiques
*/
class Trajet implements Mesurable {
    //attribut propre à Trajet
    //nom: string;
    private nom: String;
    //crée attribut implémenté
    public length: number

    //on instancie nos attribut
    constructor(nom: string, length: number){
        this.nom = nom;
        //dont celui obligatoire (length)
        this.length = length;
    }

    //override de la méthode 'toString()'
    /*on retourne un string qui contient:
        -le nom et la taille de l'objet en cours d'utilisation
    */
    toString(): string {
        return "Trajet "+this.nom+" de "+this.length+" Km";
    }
}

//class qui possède une spécificité générique <T qui hérite de l'interface 'Mesurable'>
//si on avait hérité de Trajet, uniquement un Type Trajet aurait fonctionner donc pas String let chaineMinMax = new MinMax(chaines);
//Elle permet de gérer la distance max et min de l'interface Mesurable
class MinMax<T extends Mesurable> {
    //Objets 'min' et 'max' de type générique. Pourquoi ?
    //pour contenir le plus petit/grand élément dit 'Mesurable'
    private min: T;
    private max: T;

    /*Le constructeur recoit un paramètre générique qui est un tableau
    Tableau qui contient 3 objets Trajet ou String
    Sous la forme new Array( new instance Objet1, new instance Objet2, new instance Objet3)
    pour instancier (obligatoire) les attributs générique (min et max) de façon 'arbitraire'
    Pourquoi arbitraire ? car obligatoire (génériqueet permet d'être le point de départ de
    la comparaison avec computeMinMax
    */
    constructor(t: Array<T>) {
        /*contient:
        -un objet (Object { nom: "a", length: 271 }) car [0]
        -ou un String (chaineDe9) car [0]
        */
        this.min = t[0];
        this.max = t[0];
        //méthode qui recoit le tableau générique en paramètre
        this.computeMinMax(t);
    }

    //Méthode qui recoit un tableau générique
    /*Pour chaque élément (objet ou String) et ce graçe à l'attribut abstrait 'length'
    dans le tableau générique, on peut instancier les attributs min et max
    Si on avait eu 'nom' dans l'interface, on aurait pu en plus de e.length, faire e.nom
    */
    private computeMinMax(t: Array<T>){
        for (let e of t) {
            //e.length sera: 271, 161 et 314
            //e.nom aurait été: "a", "b" et "c"
            this.min = e.length < this.min.length?e:this.min;
            this.max = e.length > this.max.length?e:this.max;
        }
    }
    //Getters pour récupérer une valeur générique (objet ou string ici) de min et max
    getMin(): T{
        return this.min;
    }

    getMax(): T{
        return this.max;
    }

}
//Une variable reçoit un tableau qui contiendra des 3 objets comportant 2 attributs de type Trajet
let trajets: Array<Trajet> = new Array(new Trajet("a", 271), new Trajet("b", 161), new Trajet("c", 314));
//permet d'exécuter computeMinMax
let trajetMinMax = new MinMax(trajets);
//Trajet c de 314 Km
console.log("Le plus grand trajet est : "+trajetMinMax.getMax());
//Trajet b de 161 Km
console.log("Le plus petit trajet est : "+trajetMinMax.getMin());

//Une variable reçoit un tableau qui contiendra des 3 String
let chaines: Array<string> = new Array("chaineDe9", "chDe5", "grandeChaineDe16");
//permet d'exécuter computeMinMax
let chaineMinMax = new MinMax(chaines);
//grandeChaineDe16
console.log("La plus grande chaine est : "+chaineMinMax.getMax());
//chDe5
console.log("La plus petite chaine est : "+chaineMinMax.getMin());