15 Decembre

DEV3.4/TP4/stub/0Bad/Base.java

@@ -0,0 +1,4 @@
+// juste un type énuméré pour nommer les bases
+public enum Base {
+    A,C,G,T
+}

DEV3.4/TP4/stub/0Bad/Exemple.java

@@ -0,0 +1,31 @@
+// Fichier Exemple pour le premier exercice sur l'ADN
+
+public class Exemple{
+    public static void main(String[] args) {
+        // codon GCT code l'analine https://en.wikipedia.org/wiki/DNA_codon_table
+        // stop codon TAG, voir https://en.wikipedia.org/wiki/Stop_codon
+        
+        System.out.println("construction du brin GCTTAG");
+        MonMaillon l = new MonMaillon(Base.G);
+        l = new MonMaillon(Base.A,l);
+        l = new MonMaillon(Base.T,l);
+        l = new MonMaillon(Base.T,l);
+        l = new MonMaillon(Base.C,l);
+        l = new MonMaillon(Base.G,l);
+
+        MonBrin b = new MonBrin(l);
+        
+        System.out.println("l'affichage par défaut du brin ne va pas vous plaire");
+        System.out.println(b.toString());
+        
+
+        System.out.println("On peut afficher en avançant");
+        System.out.println("Il faut s'en inspirer pour implémenter l'interface iterator de Java.util");
+        MonMaillon actuel = b.getDebut();//NB: c'est comme l ci-dessus
+        
+        while (actuel != null){
+            System.out.println(actuel.getBase());
+            actuel = actuel.getSuiteMaillon();
+        }
+    }
+}

DEV3.4/TP4/stub/0Bad/MonBrin.java

@@ -0,0 +1,29 @@
+/** 
+    MonBrin code un brin d'ADN sous forme de liste simplement chaînée.
+
+    Plusieurs instances de MonMaillon reliées convenablement forment une structure de liste simplement chaînée contenant pour chaque maillon le nom de la base.
+
+    On n'utilise pas java.util et on recode tout.
+
+    Cette version a un problème : la navigation n'est pas raisonnable
+*/
+public class MonBrin {
+
+    private MonMaillon debut;
+    //Le constructeur fabrique un brin à partir du premier maillon p;
+    public MonBrin(MonMaillon p){
+        this.debut = p;
+    }
+
+    public MonMaillon getDebut(){
+        return this.debut;
+    }
+    
+    /** et pour naviguer? 
+        On pourrait implémenter l'interface iterator de java.util ici
+    **/
+       
+
+}
+
+

DEV3.4/TP4/stub/0Bad/MonMaillon.java

@@ -0,0 +1,33 @@
+/** 
+    MonMaillon code un maillon d'un brin d'ADN.
+    plusieurs instances reliées convenablement forment une structure de liste simplement chaînée contenant pour chaque maillon le nom de la base.
+    On n'utilise pas java.util et on recode tout.
+
+*/
+public class MonMaillon {
+
+    private Base b;
+    private MonMaillon suivant;
+    //Le constructeur de base retourne un brin à une base;
+    public MonMaillon(Base b){
+        this.b = b;
+        this.suivant = null;
+    }
+
+    // Le constructeur évolué ajoute une base à un brin.
+    public MonMaillon(Base b, MonMaillon l){
+        this.b = b;
+        this.suivant = l;
+    }
+
+    public Base getBase(){
+        return this.b;
+    }
+
+    public MonMaillon getSuiteMaillon(){
+        return this.suivant;
+    }
+    
+}
+
+

DEV3.4/TP4/stub/1Iterable/Base.java

@@ -0,0 +1,4 @@
+// juste un type énuméré pour nommer les bases
+public enum Base {
+    A,C,G,T
+}

DEV3.4/TP4/stub/1Iterable/Exemple.java

@@ -0,0 +1,34 @@
+// Fichier Exemple pour le second exercice sur l'ADN
+
+public class Exemple{
+    public static void main(String[] args) {
+        // codon GCT code l'analine https://en.wikipedia.org/wiki/DNA_codon_table
+        // stop codon TAG, voir https://en.wikipedia.org/wiki/Stop_codon
+
+        System.out.println("construction du brin GCTTAG");
+        MonMaillon l = new MonMaillon(Base.G);
+        l = new MonMaillon(Base.A,l);
+        l = new MonMaillon(Base.T,l);
+        l = new MonMaillon(Base.T,l);
+        l = new MonMaillon(Base.C,l);
+        l = new MonMaillon(Base.G,l);
+
+        MonBrin b = new MonBrin(l);
+        
+        System.out.println("l'affichage par défaut du brin ne va pas vous plaire");
+        System.out.println(b.toString());
+        
+        System.out.println("On peut maintenant afficher en itérant avec un while comme ceci");
+
+        while (b.hasNext()){
+            System.out.println(b.next());
+        }
+
+        // ajouter du code ici pour gérer les questions en plus
+        // (simulation de plusieurs navigations successives)
+
+
+        // (simulation de plusieurs navigations simultanées)
+    }
+
+}

DEV3.4/TP4/stub/1Iterable/MonBrin.java

@@ -0,0 +1,59 @@
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+/** 
+    MonBrin code un brin d'ADN sous forme de liste simplement chaînée.
+
+    Plusieurs instances de MonMaillon reliées convenablement forment une structure de liste simplement chaînée contenant pour chaque maillon le nom de la base.
+
+    On n'utilise pas java.util et on recode tout.
+
+    Cette version a un problème : la navigation n'est pas raisonnable
+*/
+public class MonBrin implements Iterator<Base>{
+
+    public MonMaillon debut;
+    public MonMaillon index;
+    //Le constructeur fabrique un brin à partir du premier maillon p;
+    public MonBrin(MonMaillon p){
+        this.debut = p;
+        this.index = p;
+    }
+
+    public MonMaillon getDebut(){
+        return this.debut;
+    }
+
+    public MonMaillon getIndex(){
+        return this.index;
+    }    
+
+    // rappel : on met @Override pour dire au compilateur qu'on veut surcharger (en particulier c'est le cas quand on implémente une interface)
+    // ce n'est pas nécessaire dans ce cas mais ça permet d'avoir des messages d'alerte si on se trompe (typo dans le nom de la méthode ...)
+    // voir https://stackoverflow.com/questions/94361/when-do-you-use-javas-override-annotation-and-why
+    @Override
+    public boolean hasNext(){
+        if (this.index.suivant==null){
+            return false;
+        }
+        else{
+            return true;
+        }
+    }
+
+    @Override
+    public Base next() {
+        if (this.hasNext()){
+            this.index = this.index.suivant;
+            return this.index.b;
+        }
+        else{
+            throw new NoSuchElementException();
+        }
+
+    }
+
+}
+
+
+
+

DEV3.4/TP4/stub/1Iterable/MonMaillon.java

@@ -0,0 +1,33 @@
+/** 
+    MonMaillon code un maillon d'un brin d'ADN.
+    plusieurs instances reliées convenablement forment une structure de liste simplement chaînée contenant pour chaque maillon le nom de la base.
+    On n'utilise pas java.util et on recode tout.
+
+*/
+public class MonMaillon {
+
+    public Base b;
+    public MonMaillon suivant;
+    //Le constructeur de base retourne un brin à une base;
+    public MonMaillon(Base b){
+        this.b = b;
+        this.suivant = null;
+    }
+
+    // Le constructeur évolué ajoute une base à un brin.
+    public MonMaillon(Base b, MonMaillon l){
+        this.b = b;
+        this.suivant = l;
+    }
+
+    public Base getBase(){
+        return this.b;
+    }
+
+    public MonMaillon getSuiteMaillon(){
+        return this.suivant;
+    }
+    
+}
+
+

DEV3.4/TP4/stub/2Iterator/Base.java

@@ -0,0 +1,4 @@
+// juste un type énuméré pour nommer les bases
+public enum Base {
+    A,C,G,T
+}

DEV3.4/TP4/stub/2Iterator/Exemple.java

@@ -0,0 +1,35 @@
+// Fichier Exemple pour le dernier exercice sur l'ADN (Iterable)
+
+public class Exemple{
+
+        public static void main(String[] args) {
+        
+        // codon GCT code l'analine https://en.wikipedia.org/wiki/DNA_codon_table
+        // stop codon TAG, voir https://en.wikipedia.org/wiki/Stop_codon
+            
+        System.out.println("construction du brin GCTTAG");
+        MonMaillon l = new MonMaillon(Base.G);
+        l = new MonMaillon(Base.A,l);
+        l = new MonMaillon(Base.T,l);
+        l = new MonMaillon(Base.T,l);
+        l = new MonMaillon(Base.C,l);
+        l = new MonMaillon(Base.G,l);
+
+        MonBrin m = new MonBrin(l);
+        
+        System.out.println("l'affichage par défaut du brin ne va pas vous plaire");
+        System.out.println(m.toString());
+        
+        System.out.println("On peut afficher en itérant avec forEach (une méthode proposée par Iterable, regardez la doc)");
+        m.forEach(b -> System.out.println(b));
+
+        System.out.println("On a découplé la navigation de la structuration en implémentant iterable plutôt que iterator. On peut maintenant naviguer 2 fois facilement, c'est vraiment trop fort.");
+        m.forEach(b -> System.out.println(b));
+
+        System.out.println("On peut même utiliser les boucles avancées de Java 8 et notre code en devient presque pythonesque");
+        for(Base b: m){
+            System.out.println(b);
+        }
+    }
+
+}

DEV3.4/TP4/stub/2Iterator/MonBrin.java

@@ -0,0 +1,37 @@
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+/** 
+    MonBrin code un brin d'ADN sous forme de liste simplement chaînée.
+
+    Plusieurs instances de MonMaillon reliées convenablement forment une structure de liste simplement chaînée contenant pour chaque maillon le nom de la base.
+
+    On n'utilise pas java.util et on recode tout.
+
+    Cette version est correcte : la structuration et la navigation sont dans 2 classes séparées.
+La classe MonBrin implémente Iterable au sens où elle peut générer à la demande un objet Iterator.
+
+NB : Notez que j'implémente Iterable<Base> plutôt que Iterable qui n'était pas tout à fait propre
+c'est un peu technique et c'est lié aux types génériques.
+ Il y a des détails ici 
+https://stackoverflow.com/questions/20790770/why-cant-i-assign-a-raw-type-to-a-parameterized-type-java?rq=1
+*/
+public class MonBrin implements Iterable<Base>{
+
+
+    public MonBrin(MonMaillon p){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+
+    public MonMaillon getDebut(){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+           
+    /** Pour naviguer? 
+        On implémente l'interface iterator de java.util ici
+        L'avantage c'est que c'est standard et tout le monde comprendra sans trop de mal comment la navigation fonctionne.
+    **/
+    @Override
+    public Iterator<Base> iterator() {
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+}

DEV3.4/TP4/stub/2Iterator/MonBrinIterator.java

@@ -0,0 +1,32 @@
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/** 
+MonBrinIterator 
+
+gère la navigation dans un Brin d'ADN
+
+*/
+public class MonBrinIterator implements Iterator<Base> {
+    
+    public MonBrinIterator(MonMaillon m){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+    
+    /** Pour naviguer? 
+        On implémente l'interface iterable de java.util ici
+        L'avantage c'est que c'est standard et tout le monde comprendra sans trop de mal comment la navogation fonctionne.
+    **/
+    @Override
+    public boolean hasNext(){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+
+    @Override
+    public Base next() {
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+ 
+}
+
+

DEV3.4/TP4/stub/2Iterator/MonMaillon.java

@@ -0,0 +1,29 @@
+/** 
+    MonMaillon code un maillon d'un brin d'ADN.
+    plusieurs instances reliées convenablement forment une structure de liste simplement chaînée contenant pour chaque maillon le nom de la base.
+    On n'utilise pas java.util et on recode tout.
+
+*/
+public class MonMaillon {
+
+    //Le constructeur de base retourne un brin à une base;
+    public MonMaillon(Base b){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+
+    // Le constructeur évolué ajoute une base à un brin.
+    public MonMaillon(Base b, MonMaillon l){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+
+    public Base getBase(){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+
+    public MonMaillon getSuiteMaillon(){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+    
+}
+
+

DEV3.4/TP4/stub/3IteratorDifferentInnerStructure/Base.java

@@ -0,0 +1,4 @@
+// juste un type énuméré pour nommer les bases
+public enum Base {
+    A,C,G,T
+}

DEV3.4/TP4/stub/3IteratorDifferentInnerStructure/Exemple.java

@@ -0,0 +1,58 @@
+// Fichier Exemple pour le dernier exercice sur l'ADN (Iterable)
+
+public class Exemple{
+
+        public static void main(String[] args) {
+        
+        // codon GCT code l'analine https://en.wikipedia.org/wiki/DNA_codon_table
+        // codon CAT code Histidine
+        // codon CGT code Arginine
+        // codon GCC code Analine
+        // stop codon TAG, voir https://en.wikipedia.org/wiki/Stop_codon
+        
+        System.out.println("construction du brin CGT CAT CGT GCC CAT GCT TAG");
+        MonBrin l = new MonBrin(Base.G);
+        l = new MonBrin(Base.A,l);
+        l = new MonBrin(Base.T,l);
+        //
+        l = new MonBrin(Base.T,l);
+        l = new MonBrin(Base.C,l);
+        l = new MonBrin(Base.G,l);
+        //
+        l = new MonBrin(Base.T,l);
+        l = new MonBrin(Base.A,l);
+        l = new MonBrin(Base.C,l);
+        //
+        l = new MonBrin(Base.C,l);
+        l = new MonBrin(Base.C,l);
+        l = new MonBrin(Base.G,l);
+        //
+        l = new MonBrin(Base.T,l);
+        l = new MonBrin(Base.G,l);
+        l = new MonBrin(Base.C,l);
+        //
+        l = new MonBrin(Base.T,l);
+        l = new MonBrin(Base.A,l);
+        l = new MonBrin(Base.C,l);
+        //
+        l = new MonBrin(Base.T,l);
+        l = new MonBrin(Base.G,l);
+        l = new MonBrin(Base.C,l);
+        //
+
+        System.out.println("l'affichage par défaut ne va toujours pas vous plaire");
+        System.out.println(l.toString());
+
+        System.out.println("On peut afficher en itérant avec forEach (une méthode proposée par Iterable, regardez la doc)");
+        l.forEach(b -> System.out.println(b));
+
+        System.out.println("On a découplé la navigation de la structuration en implémentant iterable plutôt que iterator. On peut maintenant naviguer 2 fois facilement, c'est vraiment trop fort.");
+        l.forEach(b -> System.out.println(b));
+
+        System.out.println("On peut même utiliser les boucles avancées de Java 8 et notre code en devient presque pythonesque");
+        for(Base b: l){
+            System.out.println(b);
+        }
+    }
+
+}

DEV3.4/TP4/stub/3IteratorDifferentInnerStructure/MonBrin.java

@@ -0,0 +1,83 @@
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/** 
+MonBrin code un brin d'ADN sous forme de tableaux. Dynamiquement, la taille du tableau est augmentée en cas de besoin (la taille est initialement 3*4 elle est multipliée ensuite pour être toujours de la forme 3*2^n). 
+On utilise System.arraycopy et java.util.Arrays.copyOfRange pour faire ça efficacement.
+voir 
+https://docs.oracle.com/javase/8/docs/api/java/lang/System.html#arraycopy-java.lang.Object-int-java.lang.Object-int-int-
+https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#copyOfRange-T:A-int-int-
+
+Cette version est correcte : la structuration et la navigation sont dans 2 classes séparées.
+La classe MonBrin implémente Iterable au sens où elle peut générer à la demande un objet Iterator.
+
+NB : Notez que j'implémente Iterable<Base> plutôt que Iterable qui n'était pas tout à fait propre
+c'est un peu technique et c'est lié aux types génériques.
+ Il y a des détails ici 
+https://stackoverflow.com/questions/20790770/why-cant-i-assign-a-raw-type-to-a-parameterized-type-java?rq=1
+*/
+
+public class MonBrin implements Iterable<Base> {
+    
+    /**
+      C'est le constructeur de base (pun intended) qui construit un brin à une base
+
+      @param b : la base
+
+      Ici je pourrais mettre un commentaire plus long sur le fonctionement détaillé de mon super constructeur.
+      
+    */
+    public MonBrin(Base b){
+
+    }
+
+    /**
+       C'est le constructeur évolué qui construit un brin en ajoutant la base donnée en argument devant le brin donné en argument.
+       
+       @param b : la base qui va aller devant
+       @param l : le brin qui sera à la suite
+
+       NB. Ce constructeur est un peu obsolète avec la nouvelle structure interne.
+       On devrait en ajouter un qui prend en paramètre un tableau de bases.
+    */
+    public MonBrin(Base b, MonBrin l){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+
+    public Base getBase(){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+
+    public int length(){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+
+    public int limit(){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+
+    public int capacity(){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+    
+    public Base getBase(int i){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }    
+    
+    public Base[] getBases(){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+    
+    /** Pour naviguer? 
+        On implémente l'interface iterator de java.util ici
+        L'avantage c'est que c'est standard et tout le monde comprendra sans trop de mal comment la navigation fonctionne.
+    **/
+    @Override
+    public Iterator<Base> iterator() {
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+    
+
+}
+
+

DEV3.4/TP4/stub/3IteratorDifferentInnerStructure/MonBrinIterator.java

@@ -0,0 +1,33 @@
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/** 
+MonBrinIterator 
+
+gère la navigation dans un Brin d'ADN
+
+*/
+public class MonBrinIterator implements Iterator<Base> {
+
+    //Le constructeur de base retourne un brin à une base;
+    public MonBrinIterator(MonBrin brin){
+    }
+    
+    /** Pour naviguer? 
+        On implémente l'interface iterable de java.util ici
+        L'avantage c'est que c'est standard et tout le monde comprendra sans trop de mal comment la navigation fonctionne.
+    **/
+    
+    @Override
+    public boolean hasNext(){
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+
+    @Override
+    public Base next() {
+        throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+    }
+ 
+}
+
+

DEV3.4/TP4/stub/explication.txt

@@ -0,0 +1,20 @@
+Les biologistes sont des gens étranges pour lesquels les string n'ont que 4 lettres : A,C,G ou T.
+Ils ne connaissent pas les String, ils parlent d'ADN.
+
+
+Le Brin est une succession de Maillons.
+Il suffit de connaître le premier maillon pour définir un brin d'ADN.
+
+        +----------+
+        | maillon  |
+        |          | _____ next __> autre Maillon
+        |          |
+        +----+-----+
+             |
+             | val
+            \|/
+        +----------+
+        | Base     |
+        |    A     |
+        |          |
+        +----+-----+

DEV3.4/TP5/stub/exo3/Chef.java

@@ -0,0 +1,62 @@
+import java.util.*;
+
+/** feuille du motif composite */
+public class Chef extends Person {
+
+    ArrayList<Person> subalternes;
+
+
+    public boolean addSubalterne(Person p){
+        return this.subalternes.add(p);
+    }
+
+
+    
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Chef(int n){
+        super(n);
+        this.subalternes = new ArrayList<Person>(100);
+        // 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 funParty = 0;
+        for(int i=0;i<this.subalternes.size();i++){
+            funParty += this.subalternes.get(i).bestParty();
+        }
+        return funParty;
+    }
+
+    /**
+     *  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(){
+        return Integer.max(this.bestPartyWithMe(),this.bestPartyWithoutMe());
+    }
+
+    private int bestPartyWithMe(){
+        int funParty = this.getFunFactor();
+        for(int i=0;i<this.subalternes.size();i++){
+            funParty += this.subalternes.get(i).bestPartyWithoutMe();
+        }
+        return funParty;
+    }
+    
+}
+
+

DEV3.4/TP5/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.4/TP5/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.4/TP5/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.4/TP5/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.4/TP5/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 this.getFunFactor();
+    }
+    
+    
+}
+
+

DEV3.4/TP5/stub/exo4/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.4/TP5/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.4/TP5/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.4/TP5/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.4/TP5/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.4/TP5/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 null;
+    }
+    
+    /**
+     * @return fête avec le travailleur
+     */
+    public int bestParty(){
+        // return null;
+    }
+    
+    
+}
+
+

DEV3.4/TP5/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.4/TP5/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.4/TP5/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.4/TP5/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.4/TP5/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();
+}
+