diff --git a/TP2/TP2.png b/TP2/TP2.png
index 97188d7..287477c 100644
Binary files a/TP2/TP2.png and b/TP2/TP2.png differ
diff --git a/TP3/TP3-1.png b/TP3/TP3-1.png
index cfdc902..a190d3b 100644
Binary files a/TP3/TP3-1.png and b/TP3/TP3-1.png differ
diff --git a/TP3/TP3-2.png b/TP3/TP3-2.png
index 5820d26..2ca488a 100644
Binary files a/TP3/TP3-2.png and b/TP3/TP3-2.png differ
diff --git a/TP4/stub/0Bad/Base.class b/TP4/stub/0Bad/Base.class
new file mode 100644
index 0000000..729c95a
Binary files /dev/null and b/TP4/stub/0Bad/Base.class differ
diff --git a/TP4/stub/0Bad/Base.java b/TP4/stub/0Bad/Base.java
new file mode 100644
index 0000000..5e6a4cf
--- /dev/null
+++ b/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
+}
diff --git a/TP4/stub/0Bad/Exemple.class b/TP4/stub/0Bad/Exemple.class
new file mode 100644
index 0000000..1e92419
Binary files /dev/null and b/TP4/stub/0Bad/Exemple.class differ
diff --git a/TP4/stub/0Bad/Exemple.java b/TP4/stub/0Bad/Exemple.java
new file mode 100644
index 0000000..ae72d5c
--- /dev/null
+++ b/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();
+ }
+ }
+}
diff --git a/TP4/stub/0Bad/MonBrin.class b/TP4/stub/0Bad/MonBrin.class
new file mode 100644
index 0000000..f96221b
Binary files /dev/null and b/TP4/stub/0Bad/MonBrin.class differ
diff --git a/TP4/stub/0Bad/MonBrin.java b/TP4/stub/0Bad/MonBrin.java
new file mode 100644
index 0000000..e8ab155
--- /dev/null
+++ b/TP4/stub/0Bad/MonBrin.java
@@ -0,0 +1,32 @@
+/**
+ 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 {
+ MonMaillon p;
+ Base b;
+
+ //Le constructeur fabrique un brin à partir du premier maillon p;
+ public MonBrin(MonMaillon p){
+ this.p = p;
+ }
+
+ public MonMaillon getDebut(){
+ return this.p;
+ }
+
+ /** et pour naviguer?
+ On pourrait implémenter l'interface iterator de java.util ici
+ **/
+ Iterator index = b.iterator();
+
+
+
+}
+
+
diff --git a/TP4/stub/0Bad/MonMaillon.class b/TP4/stub/0Bad/MonMaillon.class
new file mode 100644
index 0000000..4d886e9
Binary files /dev/null and b/TP4/stub/0Bad/MonMaillon.class differ
diff --git a/TP4/stub/0Bad/MonMaillon.java b/TP4/stub/0Bad/MonMaillon.java
new file mode 100644
index 0000000..a0c3758
--- /dev/null
+++ b/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 content;
+ private MonMaillon next;
+
+
+ //Le constructeur de base retourne un brin à une base;
+ public MonMaillon(Base content){
+ this.content = content;
+ }
+
+ // Le constructeur évolué ajoute une base à un brin.
+ public MonMaillon(Base content, MonMaillon next){
+ this.content = content;
+ this.next = next;
+ }
+
+ public Base getBase(){
+ return this.content;
+ }
+
+ public MonMaillon getSuiteMaillon(){
+ return this.next;
+ }
+
+}
+
+
diff --git a/TP4/stub/1Iterable/Base.java b/TP4/stub/1Iterable/Base.java
new file mode 100644
index 0000000..5e6a4cf
--- /dev/null
+++ b/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
+}
diff --git a/TP4/stub/1Iterable/Exemple.java b/TP4/stub/1Iterable/Exemple.java
new file mode 100644
index 0000000..94a55a7
--- /dev/null
+++ b/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)
+ }
+
+}
diff --git a/TP4/stub/1Iterable/MonBrin.java b/TP4/stub/1Iterable/MonBrin.java
new file mode 100644
index 0000000..473e131
--- /dev/null
+++ b/TP4/stub/1Iterable/MonBrin.java
@@ -0,0 +1,42 @@
+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 structuration et la navigation sont dans la même classe.
+*/
+public class MonBrin implements Iterator{
+
+ 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");
+ }
+
+
+ // 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(){
+ 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");
+ throw new NoSuchElementException();
+
+ }
+
+}
+
+
+
+
diff --git a/TP4/stub/1Iterable/MonMaillon.java b/TP4/stub/1Iterable/MonMaillon.java
new file mode 100644
index 0000000..6f93fe5
--- /dev/null
+++ b/TP4/stub/1Iterable/MonMaillon.java
@@ -0,0 +1,28 @@
+/**
+ 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 MonMaillon(Base b){
+ throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+ }
+
+ 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");
+ }
+
+}
+
+
diff --git a/TP4/stub/2Iterator/Base.java b/TP4/stub/2Iterator/Base.java
new file mode 100644
index 0000000..5e6a4cf
--- /dev/null
+++ b/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
+}
diff --git a/TP4/stub/2Iterator/Exemple.java b/TP4/stub/2Iterator/Exemple.java
new file mode 100644
index 0000000..b48d0a7
--- /dev/null
+++ b/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);
+ }
+ }
+
+}
diff --git a/TP4/stub/2Iterator/MonBrin.java b/TP4/stub/2Iterator/MonBrin.java
new file mode 100644
index 0000000..b6782cc
--- /dev/null
+++ b/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 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{
+
+
+ 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 iterator() {
+ throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+ }
+}
diff --git a/TP4/stub/2Iterator/MonBrinIterator.java b/TP4/stub/2Iterator/MonBrinIterator.java
new file mode 100644
index 0000000..a2a85e7
--- /dev/null
+++ b/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 {
+
+ 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");
+ }
+
+}
+
+
diff --git a/TP4/stub/2Iterator/MonMaillon.java b/TP4/stub/2Iterator/MonMaillon.java
new file mode 100644
index 0000000..d5e4c66
--- /dev/null
+++ b/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");
+ }
+
+}
+
+
diff --git a/TP4/stub/3IteratorDifferentInnerStructure/Base.java b/TP4/stub/3IteratorDifferentInnerStructure/Base.java
new file mode 100644
index 0000000..5e6a4cf
--- /dev/null
+++ b/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
+}
diff --git a/TP4/stub/3IteratorDifferentInnerStructure/Exemple.java b/TP4/stub/3IteratorDifferentInnerStructure/Exemple.java
new file mode 100644
index 0000000..b4afd21
--- /dev/null
+++ b/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);
+ }
+ }
+
+}
diff --git a/TP4/stub/3IteratorDifferentInnerStructure/MonBrin.java b/TP4/stub/3IteratorDifferentInnerStructure/MonBrin.java
new file mode 100644
index 0000000..6cd0ad1
--- /dev/null
+++ b/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 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 {
+
+ /**
+ 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 iterator() {
+ throw new UnsupportedOperationException("cette méthode n'est pas implémentée");
+ }
+
+
+}
+
+
diff --git a/TP4/stub/3IteratorDifferentInnerStructure/MonBrinIterator.java b/TP4/stub/3IteratorDifferentInnerStructure/MonBrinIterator.java
new file mode 100644
index 0000000..363d355
--- /dev/null
+++ b/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 {
+
+ //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");
+ }
+
+}
+
+
diff --git a/TP4/stub/explication.txt b/TP4/stub/explication.txt
new file mode 100644
index 0000000..9254e46
--- /dev/null
+++ b/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 |
+ | |
+ +----+-----+
diff --git a/TP5/stub/exo3/Chef.java b/TP5/stub/exo3/Chef.java
new file mode 100644
index 0000000..38ed1b9
--- /dev/null
+++ b/TP5/stub/exo3/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
+ }
+
+}
+
+
diff --git a/TP5/stub/exo3/Exemple.java b/TP5/stub/exo3/Exemple.java
new file mode 100644
index 0000000..9a23013
--- /dev/null
+++ b/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());
+ }
+
+}
+
+
+
+
diff --git a/TP5/stub/exo3/Exemple2.java b/TP5/stub/exo3/Exemple2.java
new file mode 100644
index 0000000..808a518
--- /dev/null
+++ b/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());
+ }
+
+}
+
+
+
+
diff --git a/TP5/stub/exo3/Exemple3.java b/TP5/stub/exo3/Exemple3.java
new file mode 100644
index 0000000..55651c9
--- /dev/null
+++ b/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());
+ }
+
+}
+
+
+
+
diff --git a/TP5/stub/exo3/Person.java b/TP5/stub/exo3/Person.java
new file mode 100644
index 0000000..b4f1951
--- /dev/null
+++ b/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
+ *
+ * NB. 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();
+}
+
diff --git a/TP5/stub/exo3/Travailleur.java b/TP5/stub/exo3/Travailleur.java
new file mode 100644
index 0000000..7df408b
--- /dev/null
+++ b/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 null;
+ }
+
+ /**
+ * @return fête avec le travailleur
+ */
+ public int bestParty(){
+ // return null;
+ }
+
+
+}
+
+
diff --git a/TP5/stub/exo4/Chef.java b/TP5/stub/exo4/Chef.java
new file mode 100644
index 0000000..38ed1b9
--- /dev/null
+++ b/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
+ }
+
+}
+
+
diff --git a/TP5/stub/exo4/Exemple.java b/TP5/stub/exo4/Exemple.java
new file mode 100644
index 0000000..9a23013
--- /dev/null
+++ b/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());
+ }
+
+}
+
+
+
+
diff --git a/TP5/stub/exo4/Exemple2.java b/TP5/stub/exo4/Exemple2.java
new file mode 100644
index 0000000..808a518
--- /dev/null
+++ b/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());
+ }
+
+}
+
+
+
+
diff --git a/TP5/stub/exo4/Exemple3.java b/TP5/stub/exo4/Exemple3.java
new file mode 100644
index 0000000..55651c9
--- /dev/null
+++ b/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());
+ }
+
+}
+
+
+
+
diff --git a/TP5/stub/exo4/Person.java b/TP5/stub/exo4/Person.java
new file mode 100644
index 0000000..b4f1951
--- /dev/null
+++ b/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
+ *
+ * NB. 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();
+}
+
diff --git a/TP5/stub/exo4/Travailleur.java b/TP5/stub/exo4/Travailleur.java
new file mode 100644
index 0000000..7df408b
--- /dev/null
+++ b/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;
+ }
+
+
+}
+
+
diff --git a/TP5/stub/exo5/Chef.java b/TP5/stub/exo5/Chef.java
new file mode 100644
index 0000000..38ed1b9
--- /dev/null
+++ b/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
+ }
+
+}
+
+
diff --git a/TP5/stub/exo5/Exemple.java b/TP5/stub/exo5/Exemple.java
new file mode 100644
index 0000000..9a23013
--- /dev/null
+++ b/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());
+ }
+
+}
+
+
+
+
diff --git a/TP5/stub/exo5/Exemple2.java b/TP5/stub/exo5/Exemple2.java
new file mode 100644
index 0000000..808a518
--- /dev/null
+++ b/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());
+ }
+
+}
+
+
+
+
diff --git a/TP5/stub/exo5/Exemple3.java b/TP5/stub/exo5/Exemple3.java
new file mode 100644
index 0000000..55651c9
--- /dev/null
+++ b/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());
+ }
+
+}
+
+
+
+
diff --git a/TP5/stub/exo5/Person.java b/TP5/stub/exo5/Person.java
new file mode 100644
index 0000000..b4f1951
--- /dev/null
+++ b/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
+ *
+ * NB. 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();
+}
+
diff --git a/TP5/stub/exo5/Travailleur.java b/TP5/stub/exo5/Travailleur.java
new file mode 100644
index 0000000..7df408b
--- /dev/null
+++ b/TP5/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;
+ }
+
+
+}
+
+