oups

DEV3.2/Arbre/Repertoires/src/Noeud.java

@@ -0,0 +1,50 @@
+import java.util.ArrayList;
+
+/**
+ * La classe Noeud représente un nœud dans une structure d'arbre.
+ * Chaque nœud possède un identifiant unique (ID), un nom, un rang, et une liste d'enfants.
+ */
+public class Noeud {
+
+
+    /** Le nom du nœud */
+    public String name;
+
+    /** La liste des enfants du nœud */
+    public ArrayList<Noeud> enfants;
+
+   
+    public Noeud(String nom) {
+        this.name = nom;
+        this.enfants = new ArrayList<>();
+    }
+
+    /**
+     * Ajoute un nœud en tant qu'enfant du nœud actuel.
+     *
+     * @param enfant Le nœud à ajouter en tant qu'enfant.
+     */
+    public void ajouterEnfant(Noeud enfant) {
+        this.enfants.add(enfant);
+    }
+
+    /**
+     * Obtient la liste des enfants du nœud.
+     *
+     * @return La liste des enfants du nœud.
+     */
+    public ArrayList<Noeud> getEnfants() {
+        return enfants;
+    }
+
+
+    /**
+     * Obtient une représentation textuelle du nœud (son nom).
+     *
+     * @return Le nom du nœud.
+     */
+    @Override
+    public String toString() {
+        return name;
+    }
+}

DEV3.2/Arbre/Repertoires/src/repertoires.java

@@ -0,0 +1,52 @@
+import java.io.*; 
+  
+public class repertoires { 
+    public static void main(String args[]) 
+    { 
+  
+        try { 
+  
+            File f = new File(args[0]); 
+            System.out.println("Files are:"); 
+  
+            Noeud test = explo(f);
+            afficherArbre(test);
+        } 
+        catch (Exception e) { 
+            System.err.println(e.getMessage()); 
+        } 
+    } 
+
+    private static Noeud explo(File f)
+    {
+        File[] files = f.listFiles();
+        Noeud root = new Noeud(f.getName());
+        if (files != null) {
+            for (File fi : files) {
+                Noeud node = new Noeud(fi.getName());
+                node.ajouterEnfant(explo(fi));
+                root.ajouterEnfant(root);
+            }
+        }
+        
+        return root;
+    }
+
+    public static void afficherArbre(Noeud racine) {
+        afficherArbre(racine, 0);
+    }
+
+    private static void afficherArbre(Noeud noeud, int niveau) {
+        // Affiche le nœud actuel avec une indentation basée sur le niveau
+        StringBuilder indentation = new StringBuilder();
+        for (int i = 0; i < niveau; i++) {
+            indentation.append("  "); // Deux espaces par niveau pour l'indentation
+        }
+        System.out.println(indentation.toString() + noeud);
+
+        // Appelle récursivement la méthode pour chaque enfant du nœud actuel
+        for (Noeud enfant : noeud.getEnfants()) {
+            afficherArbre(enfant, niveau + 1);
+        }
+    }
+} 

DEV3.2/Florent/TD5/stub/exo3/Chef.java

@@ -0,0 +1,75 @@
+import java.util.ArrayList;
+import java.util.List;
+
+/** feuille du motif composite */
+public class Chef extends Person {
+
+    private List<Person> subalternes = new ArrayList<Person>(); 
+
+    public boolean addSubalterne(Person p){
+        return subalternes.add(p);
+    }
+
+
+    
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Chef(int n){
+        super(n);
+        // d'autres choses peut-être.
+    }
+
+    
+    /** 
+     * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     *
+     */ 
+    public int bestPartyWithoutMe(){
+        int output = 0;
+        for (Person person : subalternes) {
+            output += person.bestParty();
+        }
+        return output;
+    }
+
+    /** 
+     * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     *
+     */ 
+    private int bestPartyWithMe(){
+        int output = getFunFactor();
+        for (Person person : subalternes) {
+            output += person.bestPartyWithoutMe();
+        }
+        return output; 
+    }
+
+    /**
+     *  La meilleure fête est soit sans moi (c'est l'union des meilleures fêtes de mes subalternes). 
+     *  soit c'est la meilleure fête avec moi.
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     *
+     */ 
+    public int bestParty(){
+        int avec,sans;
+        avec = this.bestPartyWithMe();
+        sans = this.bestPartyWithoutMe();
+        System.err.println("avec:"+avec+"\nsans:"+sans);
+        if (avec > sans) {
+            return avec;
+        } else {
+            return sans;
+        }
+    }
+    
+}
+
+

DEV3.2/Florent/TD5/stub/exo3/Exemple.java

@@ -0,0 +1,36 @@
+public class Exemple {
+     public static void main(String[] args) {
+         // bar 2
+         //   foo 5
+         //     titi 4
+         //     tata 4
+         //     toto 6
+         //   tete 6
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         System.out.println(foo.bestParty());
+         System.out.println(foo.bestPartyWithoutMe());
+         
+         Travailleur tete = new Travailleur(6);
+         // System.out.println(tete.bestParty());
+         // System.out.println(tete.bestPartyWithoutMe());
+
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         bar.addSubalterne(tete);
+         System.out.println(bar.bestParty());
+         //System.out.println(bar.bestPartyWithoutMe());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo3/Exemple2.java

@@ -0,0 +1,33 @@
+public class Exemple2 {
+     public static void main(String[] args) {
+         // Exemple inspiré question Thibault B.
+         // 1
+         //   10
+         //       1
+         //         1
+         //           10
+         //              3
+         //              4
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+         
+         System.out.println(g.bestParty());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo3/Exemple3.java

@@ -0,0 +1,43 @@
+public class Exemple3 {
+     public static void main(String[] args) {
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         Travailleur tete = new Travailleur(6);
+         bar.addSubalterne(tete);
+         
+         Chef x = new Chef(2);
+         x.addSubalterne(g);
+         x.addSubalterne(bar);
+         Chef y = new Chef(39);
+         y.addSubalterne(x);
+         
+         System.out.println(y.bestParty());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo3/Person.java

@@ -0,0 +1,44 @@
+
+/** "Les personnes sont soit des chefs, soit des travailleurs" */
+public abstract class  Person{
+    /**
+    * valeur indiquant le niveau de coolitude de la personne
+    */
+    private int funFactor;
+
+    /**
+     * @return  la valeur indiquant le niveau de coolitude de la personne. plus cete valeur est grande, plus la personne contribue à améliorer l'ambiance dans une fête.
+     *
+     */
+    public int getFunFactor(){
+        return this.funFactor;
+    }
+
+    /**
+     * constructeur 
+     *
+     * <b>NB</b>. Cette méthode ne peut pas être appelé directement pour instancier un objet car la classe est abstraite, mais sert dans les constructeurs de classes dérivées.
+     *
+     * @see Travailleur, Chef
+     */
+    // 
+    public Person(int n){
+        if (n < 0)
+            throw new IllegalArgumentException("Le fun facteur est positif ou nul, vous avez proposé " + n);
+        this.funFactor = n;
+    }
+        
+    /** 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     */ 
+    public abstract int bestPartyWithoutMe();
+
+
+    /** 
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     */ 
+    public abstract int bestParty();
+}
+

DEV3.2/Florent/TD5/stub/exo3/Travailleur.java

@@ -0,0 +1,31 @@
+/** feuille du motif composite */
+public class Travailleur extends Person {
+
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Travailleur(int n){
+        super(n);
+    }
+    
+    /** 
+     *
+     * @return fête sans le travailleur
+     */ 
+    public int bestPartyWithoutMe(){
+        return 0;
+    }
+    
+    /**
+     * @return fête avec le travailleur
+     */
+    public int bestParty(){
+        return getFunFactor();
+    }
+    
+    
+}
+
+

DEV3.2/Florent/TD5/stub/exo4/Chef.java

@@ -0,0 +1,89 @@
+import java.util.ArrayList;
+import java.util.List;
+
+/** feuille du motif composite */
+public class Chef extends Person {
+
+    private List<Person> subalternes = new ArrayList<Person>(); 
+    private Integer avec,sans = null;
+
+    public boolean addSubalterne(Person p){
+        return subalternes.add(p);
+    }
+
+
+    
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Chef(int n){
+        super(n);
+        // d'autres choses peut-être.
+    }
+
+    
+    /** 
+     * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     *
+     */ 
+    public int bestPartyWithoutMe(){
+        if (this.sans != null) {
+            return this.sans;
+        }
+        int output = 0;
+        for (Person person : subalternes) {
+            output += person.bestParty();
+        }
+        this.sans = output;
+        return output;
+    }
+
+    /** 
+     * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     *
+     */ 
+    private int bestPartyWithMe(){
+        if (this.avec != null) {
+            return this.avec;
+        }
+        int output = getFunFactor();
+        for (Person person : subalternes) {
+            output += person.bestPartyWithoutMe();
+        }
+        this.avec = output;
+        return output; 
+    }
+
+    /**
+     *  La meilleure fête est soit sans moi (c'est l'union des meilleures fêtes de mes subalternes). 
+     *  soit c'est la meilleure fête avec moi.
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     *
+     */ 
+    public int bestParty(){
+        if (this.avec != null && this.sans != null) {
+            if (this.avec > sans) {
+                return this.avec;
+            } else {
+                return this.sans;
+            }
+        }
+        this.avec = this.bestPartyWithMe();
+        this.sans = this.bestPartyWithoutMe();
+        if (this.avec > this.sans) {
+            return this.avec;
+        } else {
+            return this.sans;
+        }
+        
+    }
+}
+
+

DEV3.2/Florent/TD5/stub/exo4/Exemple.java

@@ -0,0 +1,36 @@
+public class Exemple {
+     public static void main(String[] args) {
+         // bar 2
+         //   foo 5
+         //     titi 4
+         //     tata 4
+         //     toto 6
+         //   tete 6
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         System.out.println(foo.bestParty());
+         System.out.println(foo.bestPartyWithoutMe());
+         
+         Travailleur tete = new Travailleur(6);
+         // System.out.println(tete.bestParty());
+         // System.out.println(tete.bestPartyWithoutMe());
+
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         bar.addSubalterne(tete);
+         System.out.println(bar.bestParty());
+         //System.out.println(bar.bestPartyWithoutMe());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo4/Exemple2.java

@@ -0,0 +1,33 @@
+public class Exemple2 {
+     public static void main(String[] args) {
+         // Exemple inspiré question Thibault B.
+         // 1
+         //   10
+         //       1
+         //         1
+         //           10
+         //              3
+         //              4
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+         
+         System.out.println(g.bestParty());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo4/Exemple3.java

@@ -0,0 +1,43 @@
+public class Exemple3 {
+     public static void main(String[] args) {
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         Travailleur tete = new Travailleur(6);
+         bar.addSubalterne(tete);
+         
+         Chef x = new Chef(2);
+         x.addSubalterne(g);
+         x.addSubalterne(bar);
+         Chef y = new Chef(39);
+         y.addSubalterne(x);
+         
+         System.out.println(y.bestParty());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo4/Person.java

@@ -0,0 +1,44 @@
+
+/** "Les personnes sont soit des chefs, soit des travailleurs" */
+public abstract class  Person{
+    /**
+    * valeur indiquant le niveau de coolitude de la personne
+    */
+    private int funFactor;
+
+    /**
+     * @return  la valeur indiquant le niveau de coolitude de la personne. plus cete valeur est grande, plus la personne contribue à améliorer l'ambiance dans une fête.
+     *
+     */
+    public int getFunFactor(){
+        return this.funFactor;
+    }
+
+    /**
+     * constructeur 
+     *
+     * <b>NB</b>. Cette méthode ne peut pas être appelé directement pour instancier un objet car la classe est abstraite, mais sert dans les constructeurs de classes dérivées.
+     *
+     * @see Travailleur, Chef
+     */
+    // 
+    public Person(int n){
+        if (n < 0)
+            throw new IllegalArgumentException("Le fun facteur est positif ou nul, vous avez proposé " + n);
+        this.funFactor = n;
+    }
+        
+    /** 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     */ 
+    public abstract int bestPartyWithoutMe();
+
+
+    /** 
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     */ 
+    public abstract int bestParty();
+}
+

DEV3.2/Florent/TD5/stub/exo4/Travailleur.java

@@ -0,0 +1,31 @@
+/** feuille du motif composite */
+public class Travailleur extends Person {
+
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Travailleur(int n){
+        super(n);
+    }
+    
+    /** 
+     *
+     * @return fête sans le travailleur
+     */ 
+    public int bestPartyWithoutMe(){
+        return 0;
+    }
+    
+    /**
+     * @return fête avec le travailleur
+     */
+    public int bestParty(){
+        return getFunFactor();
+    }
+    
+    
+}
+
+

DEV3.2/Florent/TD5/stub/exo5/Chef.java

@@ -0,0 +1,48 @@
+import java.util.LinkedHashSet;
+import java.util.Objects;
+
+/** feuille du motif composite */
+public class Chef extends Person {
+
+
+    public boolean addSubalterne(Person p){
+        
+    }
+
+
+    
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Chef(int n){
+        super(n);
+        // d'autres choses peut-être.
+    }
+
+    
+    /** 
+     * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     *
+     */ 
+    public int bestPartyWithoutMe(){
+        // to do
+    }
+
+    /**
+     *  La meilleure fête est soit sans moi (c'est l'union des meilleures fêtes de mes subalternes). 
+     *  soit c'est la meilleure fête avec moi.
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     *
+     */ 
+    public int bestParty(){
+        // to do
+    }
+    
+}
+
+

DEV3.2/Florent/TD5/stub/exo5/Exemple.java

@@ -0,0 +1,36 @@
+public class Exemple {
+     public static void main(String[] args) {
+         // bar 2
+         //   foo 5
+         //     titi 4
+         //     tata 4
+         //     toto 6
+         //   tete 6
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         System.out.println(foo.bestParty());
+         System.out.println(foo.bestPartyWithoutMe());
+         
+         Travailleur tete = new Travailleur(6);
+         // System.out.println(tete.bestParty());
+         // System.out.println(tete.bestPartyWithoutMe());
+
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         bar.addSubalterne(tete);
+         System.out.println(bar.bestParty());
+         //System.out.println(bar.bestPartyWithoutMe());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo5/Exemple2.java

@@ -0,0 +1,33 @@
+public class Exemple2 {
+     public static void main(String[] args) {
+         // Exemple inspiré question Thibault B.
+         // 1
+         //   10
+         //       1
+         //         1
+         //           10
+         //              3
+         //              4
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+         
+         System.out.println(g.bestParty());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo5/Exemple3.java

@@ -0,0 +1,43 @@
+public class Exemple3 {
+     public static void main(String[] args) {
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         Travailleur tete = new Travailleur(6);
+         bar.addSubalterne(tete);
+         
+         Chef x = new Chef(2);
+         x.addSubalterne(g);
+         x.addSubalterne(bar);
+         Chef y = new Chef(39);
+         y.addSubalterne(x);
+         
+         System.out.println(y.bestParty());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo5/Person.java

@@ -0,0 +1,44 @@
+
+/** "Les personnes sont soit des chefs, soit des travailleurs" */
+public abstract class  Person{
+    /**
+    * valeur indiquant le niveau de coolitude de la personne
+    */
+    private int funFactor;
+
+    /**
+     * @return  la valeur indiquant le niveau de coolitude de la personne. plus cete valeur est grande, plus la personne contribue à améliorer l'ambiance dans une fête.
+     *
+     */
+    public int getFunFactor(){
+        return this.funFactor;
+    }
+
+    /**
+     * constructeur 
+     *
+     * <b>NB</b>. Cette méthode ne peut pas être appelé directement pour instancier un objet car la classe est abstraite, mais sert dans les constructeurs de classes dérivées.
+     *
+     * @see Travailleur, Chef
+     */
+    // 
+    public Person(int n){
+        if (n < 0)
+            throw new IllegalArgumentException("Le fun facteur est positif ou nul, vous avez proposé " + n);
+        this.funFactor = n;
+    }
+        
+    /** 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     */ 
+    public abstract int bestPartyWithoutMe();
+
+
+    /** 
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     */ 
+    public abstract int bestParty();
+}
+

DEV3.2/Florent/TD5/stub/exo5/Travailleur.java

@@ -0,0 +1,31 @@
+/** feuille du motif composite */
+public class Travailleur extends Person {
+
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Travailleur(int n){
+        super(n);
+    }
+    
+    /** 
+     *
+     * @return fête sans le travailleur
+     */ 
+    public int bestPartyWithoutMe(){
+        // return null;
+    }
+    
+    /**
+     * @return fête avec le travailleur
+     */
+    public int bestParty(){
+        // return null;
+    }
+    
+    
+}
+
+