tp bd + tp5-6 dev3.2

Anglish/letters_to_an-internship.txt

@@ -0,0 +1,23 @@
+dear Madam,
+
+I am interested in applying to for a post of web developper for french school students.
+
+I am 19 years old and I am currently studying at the BUT Senart Fontainbleau.
+
+After that I hope to follow a career in the AT industry. During the last few summer holidays I have worked as an new website and I enjoyed the work very much. Next summer I would like to do something more varied and challenging, and for this reason I'm interrested in the job of web developper, taking students to London.
+
+I feel that I would be well suited for this job as I enjoy working with young people.I have a lot of energy and enthusiasm and am also responsible and reliable. I have attached my CV as this email.
+
+I am avalaible for interview in New York any weekday afternoon, and you can email me or telephone me on the number below. I look forward to hearing from you soon.
+
+Yours faithfully
+
+Wamster Alexis
+07 82 82 20 64
+wamsteralexis@gmail.com
+
+
+
+
+
+https://www.indeed.com/jobs?q=developer&l=New+York%2C+NY&sc=0kf%3Ajt%28internship%29%3B&vjk=ab35090a7f1582e1

BD/Lekpa/tp01.txt

@@ -0,0 +1,57 @@
+1|-------------------------------
+
+update ligne_commande l1
+set l1.prix_total =
+(select p.prix_unitaire * l2.quantite
+from produit p, ligne_commande l2
+where p.id = l2.produit_id and l2.id = l1.id);
+
+(verfification)
+select p.prix_unitaire * l.quantite, l.prix_total
+from ligne_commande l, produit p
+where l.produit_id = p.id;
+
+3|--------------------------------
+
+select c.id, c.nom, c.prenom, sum(l.prix_total)
+from client c, commande co, ligne_commande l
+where c.id = co.client_id and co.id = l.commande_id
+group by c.id, c.nom, c.prenom;
+
+4|--------------------------
+
+select c.id, c.nom, c.prenom, sum(l.prix_total)
+from client c, commande co, ligne_commande l
+where c.id = co.client_id and co.id = l.commande_id
+group by c.id, c.nom, c.prenom
+having sum(l.prix_total) > 2000;
+
+5|-----------------------------
+
+select to_char(co.date_achat, 'yy'), to_char(co.date_achat, 'mm'), sum(l.prix_total)
+from commande co, ligne_commande l
+where co.id = l.commande_id
+group by to_char(co.date_achat, 'yy'), to_char(co.date_achat, 'mm');
+
+(verification)
+la somme est egale a:
+select sum(prix_total) from  ligne_commande;
+
+6|------------------------------
+
+create sequence seq_tp
+start with 121;
+
+select seq_tp.currval from dual;
+select seq_tp.nextval from dual;
+
+7|------------------------------
+
+create or replace procedure sp_insert_ligne_commande(p_commande_id int, p_produit_id int, p_quantite int) is
+p_prix_total ligne_commande.prix_total%type;
+p_id ligne_commande.id%type;
+begin
+select seq_tp.nextval into p_id from dual;
+select p.prix_unitaire * l.quantite into p_prix_total from produit p, ligne_commande l where p.id = p_commande_id;
+insert into ligne_commande values (p_id,p_commande_id,p_produit_id,p_quantite,p_prix_total);
+end sp_insert_ligne_commande;

DEV/DEV3.2/TP05_Files/Action.java

@@ -0,0 +1,59 @@
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+
+public class Action implements KeyListener {
+
+    public static final Point HAUT=new Point(0,-1);
+    public static final Point BAS=new Point(0,1);
+    public static final Point GAUCHE=new Point(-1,0);
+    public static final Point DROITE=new Point(1,0);
+    public Serpent jeux;
+
+    public Action(Serpent jeux){
+        this.jeux = jeux;
+    }
+
+    @Override
+    public void keyPressed(KeyEvent e) {
+        int keyCode = e.getKeyCode();
+        if (this.jeux.isFreeze == false){
+            if (keyCode == KeyEvent.VK_UP){
+                if (this.jeux.derniereDirection != Action.BAS){
+                    this.jeux.derniereDirection = Action.HAUT;
+                    this.jeux.direction.offer(Action.HAUT);
+                }
+            }
+            if (keyCode == KeyEvent.VK_DOWN){
+                if (this.jeux.derniereDirection != Action.HAUT){
+                    this.jeux.derniereDirection = Action.BAS;
+                    this.jeux.direction.offer(Action.BAS);
+                }
+            }
+            if (keyCode == KeyEvent.VK_LEFT){
+                if (this.jeux.derniereDirection != Action.DROITE){
+                    this.jeux.derniereDirection = Action.GAUCHE;
+                    this.jeux.direction.offer(Action.GAUCHE);
+                }
+            }
+            if (keyCode == KeyEvent.VK_RIGHT){
+                if (this.jeux.derniereDirection != Action.GAUCHE){
+                    this.jeux.derniereDirection = Action.DROITE;
+                    this.jeux.direction.offer(Action.DROITE);
+                }
+            }
+        }
+        if (keyCode == KeyEvent.VK_SPACE){
+            this.jeux.isFreeze = !this.jeux.isFreeze;
+        }
+    }
+
+    @Override
+    public void keyTyped(KeyEvent e) {
+    }
+
+    @Override
+    public void keyReleased(KeyEvent e) {
+    }
+}

DEV/DEV3.2/TP05_Files/Dessin.java

@@ -0,0 +1,28 @@
+import javax.swing.*;
+import java.awt.*;
+ 
+public class Dessin extends JComponent {
+    public Color couleur;
+
+    public Dessin(Color couleur){
+		this.couleur = couleur;
+    }
+
+	public void setColor(Color couleur){
+		this.couleur = couleur;
+		this.repaint();
+    }
+    
+    @Override
+    protected void paintComponent(Graphics pinceau) {
+	Graphics secondPinceau = pinceau.create();
+	Color couleurFond = this.getBackground();
+	if (this.isOpaque()) {
+	    secondPinceau.setColor(couleurFond);
+	    secondPinceau.fillRect(0, 0, this.getWidth(), this.getHeight());
+	}
+	
+	secondPinceau.setColor(this.couleur);
+	secondPinceau.fillRect(2,2, this.getWidth()-2, this.getHeight()-2);
+    }
+}

DEV/DEV3.2/TP05_Files/Q4Main.java

@@ -0,0 +1,22 @@
+import java.util.*;
+
+public class Q4Main{
+
+    public static void main(String[] args){
+
+		Serpent jeux = new Serpent();
+
+        Timer boucle = new Timer(true);
+		Repetition iteration = new Repetition(jeux, boucle);
+        boucle.scheduleAtFixedRate(iteration, 1000, 100);
+        try {
+            while(true){
+                Thread.sleep(1000000);
+            }
+        }
+		catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        boucle.cancel();
+    }
+}

DEV/DEV3.2/TP05_Files/Repetition.java

@@ -0,0 +1,61 @@
+import javax.swing.*;
+import java.awt.*;
+import java.util.*;
+
+public class Repetition extends TimerTask{
+
+    public Serpent jeux;
+    public java.util.Timer boucle;
+
+    public Repetition(Serpent jeux, java.util.Timer boucle){
+        this.jeux = jeux;
+        this.boucle = boucle;
+    }
+
+    @Override
+    public void run(){
+        try{
+            if (this.jeux.isFreeze == false){
+                Point direction;
+                if (this.jeux.direction.isEmpty()){
+                    direction = this.jeux.derniereDirection;
+                }
+                else{
+                    direction = this.jeux.direction.poll();
+                }
+                this.jeux.tete = new Point(this.jeux.tete.x + direction.x, this.jeux.tete.y + direction.y);
+                if (this.jeux.serpent.contains(this.jeux.tete)){
+                    this.perdu();
+                }
+                this.jeux.serpent.offer(this.jeux.tete);
+                this.jeux.listeCase[this.jeux.tete.x][this.jeux.tete.y].setColor(Serpent.SERPENT);
+
+                int indicePomme = this.jeux.listePomme.indexOf(this.jeux.tete);
+                if (indicePomme == -1){
+                    Point queue = this.jeux.serpent.poll();
+                    this.jeux.listeCase[queue.x][queue.y].setColor(Serpent.FOND);
+                }
+                else{
+                    this.jeux.listePomme.remove(indicePomme);
+                    this.jeux.newPomme();
+                }
+            }
+        }
+        catch (ArrayIndexOutOfBoundsException e) {
+            this.perdu();
+        }
+    }
+
+    private void perdu(){
+        System.out.println("perdu");
+        this.jeux.isFreeze = false;
+        int fermeture = JOptionPane.showConfirmDialog(null,
+                "Score : " + (this.jeux.serpent.size()-3) + "\nVoulez vous rejouer ?");
+		if (fermeture == JOptionPane.YES_OPTION){
+            this.jeux.initialisation();
+        }
+        else{
+            this.boucle.cancel();
+        }
+    }
+}

DEV/DEV3.2/TP05_Files/Serpent.java

@@ -0,0 +1,85 @@
+import javax.swing.*;
+import java.awt.*;
+import java.util.*;
+
+public class Serpent{
+
+    public static final int LONGUEUR=25;
+    public static final int HAUTEUR=25;
+	public static final Color SERPENT=Color.ORANGE;
+	public static final Color FOND=Color.GREEN;
+	public static final Color POMME=Color.RED;
+
+    public JFrame fenetre;
+    public Queue<Point> serpent;
+    public Point tete;
+    public ArrayList<Point> listePomme;
+    public Dessin[][] listeCase;
+    public Queue<Point> direction;
+    public Point derniereDirection;
+    public boolean isFreeze;
+    public Random random;
+
+    public Serpent(){
+        this.fenetre = new JFrame("serpent");
+		this.fenetre.setSize(800, 800);
+		this.fenetre.setLocation(0, 0);
+		this.fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		GridLayout grille = new GridLayout(Serpent.HAUTEUR,Serpent.LONGUEUR);
+		this.fenetre.setLayout(grille);
+
+        this.listeCase = new Dessin[Serpent.LONGUEUR][Serpent.HAUTEUR];
+        int x,y;
+        for (y=0; y<Serpent.HAUTEUR; y++){
+            for (x=0; x<Serpent.LONGUEUR; x++){
+                this.listeCase[x][y] = new Dessin(Serpent.FOND);
+				this.fenetre.add(this.listeCase[x][y]);
+            }
+        }
+
+        this.random = new Random();
+        this.initialisation();
+        Action evenement = new Action(this);
+        this.fenetre.addKeyListener(evenement);
+        this.fenetre.setVisible(true);
+    }
+
+	public void initialisation(){
+        int x,y;
+        for (y=0; y<Serpent.HAUTEUR; y++){
+            for (x=0; x<Serpent.LONGUEUR; x++){
+                this.listeCase[x][y].setColor(Serpent.FOND);
+            }
+        }
+        this.direction = new LinkedList<>();
+        this.derniereDirection = Action.DROITE;
+        this.listePomme = new ArrayList<>();
+        this.serpent = new LinkedList<>();
+        this.tete = new Point(2,12);
+		this.serpent.offer(this.tete);
+		this.listeCase[this.tete.x][this.tete.y].setColor(Serpent.SERPENT);
+        this.tete = new Point(3,12);
+		this.serpent.offer(this.tete);
+		this.listeCase[this.tete.x][this.tete.y].setColor(Serpent.SERPENT);
+        this.tete = new Point(4,12);
+		this.serpent.offer(this.tete);
+		this.listeCase[this.tete.x][this.tete.y].setColor(Serpent.SERPENT);
+
+        this.listePomme.add(new Point(15,12));
+        this.listeCase[15][12].setColor(Serpent.POMME);
+        newPomme();
+        newPomme();
+        this.fenetre.repaint();
+        this.isFreeze = true;
+	}
+
+    public void newPomme(){
+        Point emplacement;
+        do{
+            emplacement = new Point(this.random.nextInt(Serpent.LONGUEUR), this.random.nextInt(Serpent.HAUTEUR));
+        } while (this.serpent.contains(emplacement) || this.listePomme.contains(emplacement));
+
+        this.listePomme.add(emplacement);
+		this.listeCase[emplacement.x][emplacement.y].setColor(Serpent.POMME);
+    }
+}

DEV/DEV3.2/TP05_Files/Test.java

@@ -0,0 +1,29 @@
+
+import java.util.Date;
+import java.util.Timer;
+import java.util.TimerTask;
+
+public class Test extends TimerTask {
+
+    @Override
+    public void run() {
+        System.out.println("hello");
+    }
+    
+    public static void main(String args[]){
+        Test timerTask = new Test();
+        //running timer task as daemon thread
+        Timer timer = new Timer(true);
+        timer.scheduleAtFixedRate(timerTask, 0, 1000);
+        try {
+            while(true){
+                Thread.sleep(1000);
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        timer.cancel();
+        System.out.println("TimerTask cancelled");
+    }
+
+}

DEV/DEV3.2/TP06_Dictionnaires/Q1Main.java

@@ -0,0 +1,19 @@
+import java.util.*;
+
+public class Q1Main{
+    public static void main(String args[]){
+        Map<Thread, StackTraceElement[]> listeThreadNul = Thread.getAllStackTraces();
+        Set<Map.Entry<Thread, StackTraceElement[]>> listeThread = listeThreadNul.entrySet();
+        for (Map.Entry<Thread, StackTraceElement[]> thread : listeThread) {
+            Thread clef = thread.getKey();
+            StackTraceElement[] valeur = thread.getValue();
+
+            System.out.println(clef.getName() + ":");
+
+            for (StackTraceElement item : valeur){
+                System.out.println("    " + item);
+            }
+            System.out.println();
+        }
+    }
+}

DEV/DEV3.2/TP06_Dictionnaires/Q2Main.java

@@ -0,0 +1,42 @@
+import java.util.*;
+
+public class Q1Main{
+    public static void main(String args[]){
+        String nomFichier = 'rgb.txt';
+        HashMap<String,Color> dicoCouleur;
+        try{
+            BufferedReader lecture = new BufferedReader(new FileReader("rgb.txt"));
+            String ligne;
+
+            try {
+                while ((ligne = lecture.readLine()) != null) {
+                    String[] donne = ligne.split("\\s+");
+                    int rouge = Integer.parseInt(data[0]);
+                    int vert = Integer.parseInt(data[1]);
+                    int bleu = Integer.parseInt(data[2]);
+                    Color couleur = Color(rouge, vert, bleu);
+                    String nom = data[3];
+
+                    dicoCouleur.put(nom, couleur);
+                }
+            } catch (IOException e) {
+                System.err.println("Erreur de lecture dans rgb.txt !");
+            }
+
+            try {
+                lecture.close();
+            } catch(IOException e) {
+                System.err.println("Erreur de fermeture de rgb.txt !");
+            }
+
+            JFrame fenetre = new JFrame();
+            fenetre.setSize(700, 300);
+            fenetre.setLocation(0, 0);
+            fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+            fenetre.setVisible(true);
+
+        } catch(FileNotFoundException e) {
+            System.err.println("Erreur d'ouverture de rgb.txt !");
+        }
+    }
+}

DEV/DEV_Madelaine/TD4/0Bad/Base.java

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

DEV/DEV_Madelaine/TD4/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();
+        }
+    }
+}

DEV/DEV_Madelaine/TD4/0Bad/MonBrin.java

@@ -0,0 +1,63 @@
+/** 
+    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;
+    private MonMaillon fin;
+
+    //Le constructeur fabrique un brin à partir du premier maillon p;
+    public MonBrin(MonMaillon p){
+        this.debut = p;
+        while (suivant=p.getSuiteMaillon() != null){
+            p = suivant;
+        }
+        this.fin = p;
+    }
+
+    public MonMaillon getDebut(){
+        return this.debut;
+    }
+
+    public MonMaillon getFin(){
+        return this.fin;
+    }
+
+    public void addDernier(MonMaillon dernier){
+        this.fin.setSuiteMaillon(dernier);
+        this.fin = dernier;
+    }
+
+    public void addPremier(MonMaillon premier){
+        premier.setSuiteMaillon(this.debut);
+        this.debut = premier;
+    }
+
+    public void removePremier(){
+        MonMaillon maillonASupprimer = this.debut;
+        this.debut = this.debut.getSuiteMaillon();
+    }
+
+    public void removeDernier(){ // pas efficace
+        MonMaillon current = this.debut;
+        while (suivant=current.getSuiteMaillon() != this.fin){
+            current = suivant;
+        }
+        current.setSuiteMaillon(null);
+        this.fin = current;
+    }
+    
+    /** et pour naviguer? 
+        On pourrait implémenter l'interface iterator de java.util ici
+    **/
+       
+
+}
+
+

DEV/DEV_Madelaine/TD4/0Bad/MonMaillon.java

@@ -0,0 +1,41 @@
+/** 
+    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 MonMaillon suivant;
+    private Base valeur;
+
+    //Le constructeur de base retourne un brin à une base;
+    public MonMaillon(Base b){
+        this.valeur = b;
+    }
+
+    // Le constructeur évolué ajoute une base à un brin.
+    public MonMaillon(Base b, MonMaillon l){
+        this.valeur = b;
+        this.suivant = l;
+    }
+
+    public setBase(Base b){
+        this.valeur = b;
+    }
+
+    public setSuiteMaillon(MonMaillon l){
+        this.suivant = l;
+    }
+
+    public Base getBase(){
+        return this.valeur;
+    }
+
+    public MonMaillon getSuiteMaillon(){
+        return this.suivant;
+    }
+    
+}
+
+

DEV/DEV_Madelaine/TD4/1Iterable/Base.java

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

DEV/DEV_Madelaine/TD4/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)
+    }
+
+}

DEV/DEV_Madelaine/TD4/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<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");
+    }
+    
+
+    // 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();
+
+    }
+
+}
+
+
+
+

DEV/DEV_Madelaine/TD4/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");
+    }
+    
+}
+
+

DEV/DEV_Madelaine/TD4/2Iterator/Base.java

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

DEV/DEV_Madelaine/TD4/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);
+        }
+    }
+
+}

DEV/DEV_Madelaine/TD4/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");
+    }
+}

DEV/DEV_Madelaine/TD4/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");
+    }
+ 
+}
+
+

DEV/DEV_Madelaine/TD4/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");
+    }
+    
+}
+
+

DEV/DEV_Madelaine/TD4/3IteratorDifferentInnerStructure/Base.java

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

DEV/DEV_Madelaine/TD4/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);
+        }
+    }
+
+}

DEV/DEV_Madelaine/TD4/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");
+    }
+    
+
+}
+
+

DEV/DEV_Madelaine/TD4/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");
+    }
+ 
+}
+
+

DEV/DEV_Madelaine/TD4/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     |
+        |          |
+        +----+-----+

DEV/DEV_Madelaine/TD4/stub/0Bad/MonBrin.java

@@ -0,0 +1,62 @@
+/** 
+    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;
+    private MonMaillon fin;
+
+    //Le constructeur fabrique un brin à partir du premier maillon p;
+    public MonBrin(MonMaillon p){
+        this.debut = p;
+        while (suivant=p.getSuiteMaillon() != null){
+            p = suivant;
+        }
+        this.fin = p;
+    }
+
+    public MonMaillon getDebut(){
+        return this.debut;
+    }
+
+    public MonMaillon getFin(){
+        return this.fin;
+    }
+
+    public void addDernier(MonMaillon dernier){
+        this.fin.setSuiteMaillon(dernier);
+        this.fin = dernier;
+    }
+
+    public void addPremier(MonMaillon premier){
+        premier.setSuiteMaillon(this.debut);
+        this.debut = premier;
+    }
+
+    public void removePremier(){
+        MonMaillon maillonASupprimer = this.debut;
+        this.debut = this.debut.getSuiteMaillon();
+    }
+
+    public void removeDernier(){
+        MonMaillon current = this.debut;
+        while (suivant=current.getSuiteMaillon() != this.fin){
+            current = suivant;
+        }
+        this.fin = this.debut.getSuiteMaillon();
+    }
+    
+    /** et pour naviguer? 
+        On pourrait implémenter l'interface iterator de java.util ici
+    **/
+       
+
+}
+
+