DEV 2.2 & TP14

APL2.1/TP14/Homotetie/Homotetie.java

@@ -0,0 +1,25 @@
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+
+public class Homotetie {
+    public static void main(String[] args) {
+        try {
+            FileInputStream fi = new FileInputStream("polygone.bin");
+            DataInputStream dis = new DataInputStream(fi);
+            FileOutputStream fo = new FileOutputStream("polygonex2.bin");
+            DataOutputStream dos = new DataOutputStream(fo);
+
+            int n = dis.available() / 8;
+            for (int i = 0; i < n; i++) {
+                dos.writeInt(dis.readInt() * 2);
+            }
+
+            dis.close();
+            dos.close();
+        } catch (Exception e) {
+
+        }
+    }
+}

APL2.1/TP14/Memoire/CloseListener.java

@@ -0,0 +1,78 @@
+import java.awt.Color;
+import java.awt.Point;
+import java.awt.event.*;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+
+import javax.swing.JFrame;
+
+public class CloseListener implements WindowListener {
+
+    @Override
+    public void windowActivated(WindowEvent arg0) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public void windowClosed(WindowEvent arg0) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public void windowClosing(WindowEvent arg0) {
+        JFrame window = (JFrame)arg0.getSource();
+
+        try (ObjectOutputStream f = new ObjectOutputStream(new FileOutputStream("save.dat"))) {
+            int width = window.getWidth();
+            int height = window.getHeight();
+            Point location = window.getLocation();
+            Color c = window.getBackground();
+            try {
+                f.writeInt(width);
+                f.writeInt(height);
+                f.writeInt((int)location.getX());
+                f.writeInt((int)location.getY());
+                f.writeInt(c.getRGB());
+                
+            } catch (IOException e) {
+                System.out.println(e);
+            }
+
+            try {
+                f.close();
+            } catch (IOException e) {
+                System.out.println(e);
+            }
+        } catch (IOException e) {
+            System.out.println(e);
+        }
+    }
+
+    @Override
+    public void windowDeactivated(WindowEvent arg0) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public void windowDeiconified(WindowEvent arg0) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public void windowIconified(WindowEvent arg0) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    @Override
+    public void windowOpened(WindowEvent arg0) {
+        // TODO Auto-generated method stub
+        
+    }
+    
+}

APL2.1/TP14/Memoire/Fond.java

@@ -0,0 +1,62 @@
+import java.awt.*;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+
+import javax.swing.*;
+
+public class Fond {
+    public static void main(String[] args) {
+        JFrame f = new JFrame("Fond");
+        f.setSize(200, 200);
+        f.setLocation(100, 100);
+        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        f.setLayout(new GridLayout(1, 3, 10, 10));
+
+        JButton b1 = new JButton("Jaune");
+        JButton b2 = new JButton("Cyan");
+        JButton b3 = new JButton("Magenta");
+
+        Observer observer = new Observer();
+
+        b1.addActionListener(observer);
+        b2.addActionListener(observer);
+        b3.addActionListener(observer);
+
+        f.add(b1);
+        f.add(b2);
+        f.add(b3);
+
+        f.setVisible(true);
+        Fond.restoreLastSettings(f);
+        f.addWindowListener(new CloseListener());
+        
+    }
+
+    public static void restoreLastSettings(JFrame f) {
+        try (ObjectInputStream fl = new ObjectInputStream(new FileInputStream("save.dat"))) {
+            try {
+                int x = fl.readInt();
+                int y = fl.readInt();
+                int w = fl.readInt();
+                int h = fl.readInt();
+                Color c = new Color(fl.readInt());
+
+                f.setSize(x, y);
+                f.setLocation(w, h);
+                f.setBackground(c);
+
+
+                try {
+                    fl.close();
+                } catch (IOException e) {
+                    System.out.println(e);
+                }
+            } catch (IOException e) {
+                System.out.println(e);
+            }
+        } catch (IOException e) {
+            System.out.println(e);
+        }
+    }
+}

APL2.1/TP14/Memoire/Observer.java

@@ -0,0 +1,24 @@
+import java.awt.Color;
+import java.awt.event.*;
+import javax.swing.JPanel;
+import javax.swing.JButton;
+
+class Observer implements ActionListener {
+    public Observer() {
+
+    }
+
+    public void actionPerformed(ActionEvent evt) {
+        String name = evt.getActionCommand();
+        JPanel f = (JPanel)((JButton)evt.getSource()).getParent();
+
+
+        if (name == "Jaune") {
+            f.setBackground(Color.YELLOW);
+        } else if (name == "Cyan") {
+            f.setBackground(Color.CYAN);
+        } else if (name == "Magenta") {
+            f.setBackground(Color.MAGENTA);
+        }
+    }
+}

APL2.1/TP14/Polygone/Polygone.java

@@ -0,0 +1,56 @@
+
+
+import javax.swing.*;
+import java.awt.*;
+import java.io.DataInputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+
+public class Polygone extends JPanel {
+    private int[] x;
+    private int[] y;
+
+    public Polygone() {
+        super();
+        
+        try {
+
+            FileInputStream fis = new FileInputStream("./polygone.bin");
+            DataInputStream b = new DataInputStream(fis);
+
+            x = new int[b.available() / 8];
+            y = new int[b.available() / 8];
+            
+            for (int i = 0; i < x.length; i++) {
+                x[i] = b.readInt() * 2;
+                y[i] = b.readInt() * 2;
+                System.out.println(x[i] + ", " + y[i]);
+            }
+
+            b.close();
+        } catch (IOException e) {
+            System.out.println(e);
+        }
+
+        this.repaint();
+    }
+
+    @Override
+    protected void paintComponent(Graphics g) {
+        // obligatoire : on crée un nouveau pinceau pour pouvoir le modifier plus tard
+        Graphics secondPinceau = g.create();
+        // obligatoire : si le composant n'est pas censé être transparent
+        if (this.isOpaque()) {
+        // obligatoire : on repeint toute la surface avec la couleur de fond
+        secondPinceau.setColor(this.getBackground());
+        secondPinceau.fillRect(0, 0, this.getWidth(), this.getHeight());
+        }
+        // maintenant on dessine ce que l'on veut
+        secondPinceau.setColor(Color.BLACK);
+        if (x != null) {
+            secondPinceau.fillPolygon(x, y, x.length);
+        }
+
+    }
+}

APL2.1/TP14/Polygone/Test.java

@@ -0,0 +1,17 @@
+
+import javax.swing.JFrame;
+
+public class Test {
+    public static void main(String[] args) {
+        JFrame j = new JFrame();
+        j.setLocation(100, 100);
+        j.setSize(500, 500);
+        j.setLayout(null);
+        Polygone p = new Polygone();
+        p.setLocation(0, 0);
+        p.setSize(400, 400);
+        j.add(p);
+        j.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        j.setVisible(true);
+    }
+}

DEV 2.2/TP01/MonInt/Ma-Touille-pour-les-tests.txt

@@ -0,0 +1,3 @@
+assert(this.valeur*c.getValeur() == avant); Seulement si -ea
+Objects.requireNonNull(c, "la classe denominateur ne peut pas être null");
+if (valeur == 13) throw new IllegalStateException("Comme disait Sacha Guitry, je ne suis pas superstitieux mais on ne sait jamais.");

DEV 2.2/TP01/MonInt/MonInt.java

@@ -0,0 +1,113 @@
+// notez le s après Object. Permet entre autre de stipuler qu'un objet o n'est pas null avec la méthode Objects.requireNonNull(o, "message d'erreur détaillé");
+import java.util.Objects;
+
+/*
+ * Sorte de Int du pauvre à laquelle on ajoute un nom sous forme textuelle.
+ * 
+ * Classe donnée à titre d'exemple pour illustrer les ingrédients techniques de la prog défensive.
+ * et les assertions java
+ */
+public class MonInt {
+
+    // un entier
+    private int valeur ;
+    // son nom sous forme textuelle
+    private String nom ;
+    
+    public MonInt(int n, String s){
+        this.valeur = n;
+        this.nom = s;
+    }
+
+    /**
+     * division du pauvre.
+     *
+     *
+     * @param c le diviseur par lequel on souhaite diviser this
+     */
+    public void divise (MonInt c){
+        Objects.requireNonNull(c, "la classe denominateur ne peut pas être null");
+
+        int avant = this.valeur;
+        
+        this.valeur = this.valeur / c.getValeur();
+        this.nom = "(" + this.nom + " divisé par " + c.getNom() +")";
+
+        assert(this.valeur*c.getValeur() == avant); // NB. un assert qui ne marche pas tout le temps.
+    }
+
+    /**
+     * Un getter superstitieux.
+     * retourne une exception si la valeur vaut 13.
+     */
+    public int getValeur(){
+        if (valeur == 13) throw new IllegalStateException("Comme disait Sacha Guitry, je ne suis pas superstitieux mais on ne sait jamais.");
+        return valeur;
+    }
+
+    public String getNom(){
+        return nom;
+    }
+
+    /**
+    * @return String representant l'entier.
+    */ 
+    public String toString(){
+        return this.getValeur() + " " + this.getNom();
+    }
+
+    /**
+     * C'est un peu moche mais on peut pour simplifier mettre des tests manuels dans un main dans chaque classe.
+     * C'est plutôt mieux que de mettre des print dans chaque méthode car vous êtes plus sûr de la stabilité de vos tests 
+     * (vous pouvez rejouer les tests plus tard).
+     *
+     * Idéalement on utilise un outil dédié comme JUnit qui favorise au maximum cette automatisation.
+     *
+     * @param args pas de paramètre en ligne de commande prévu.
+     */
+    public static void main(String[] args) {
+        MonInt c3 = new MonInt(3,"trois");
+        MonInt c4 = new MonInt(4,"quatre");
+        MonInt c9 = new MonInt(9,"neuf");
+        MonInt c13 = new MonInt(13,"treize");
+        System.out.println(c3.toString());
+        System.out.println(c4.toString());
+        System.out.println(c9.toString());
+
+
+        c9.divise(c3);
+        // 3
+        System.out.println(c9.toString());
+
+        c3.divise(c4);
+        // 0
+        System.out.println(c3.toString());
+
+        // tester des exceptions pas pratique
+        // Si on veut tester plusieurs exceptions
+        // il faut attraper et vérifier que c'est le bon type d'exception.
+        // ici manuellement en regardant le message.
+        try {
+            System.out.println(c13.toString()); // toucher au nbre 13 avec getValeur()
+        }
+        catch(Exception e){
+            System.out.println(e);
+        }
+        
+        try{
+            c9.divise(c3); //division par 0
+            }
+        catch(Exception e){
+            System.out.println(e);
+        }
+
+        try{
+            c9.divise(null); //division par null
+        }
+        catch(Exception e){
+            System.out.println(e);
+        }
+        
+
+    }
+}

DEV 2.2/TP01/v0/Carte.java

@@ -0,0 +1,148 @@
+import java.util.Objects;
+
+// Copyright Florent Madelaine, (3 juin 2020) 
+
+// florent.madelaine@u-pec.fr
+
+// Ce logiciel est un programme informatique simulant une petite partie du jeu de Memory
+
+// Ce logiciel est régi par la licence CeCILL soumise au droit français et
+// respectant les principes de diffusion des logiciels libres. Vous pouvez
+// utiliser, modifier et/ou redistribuer ce programme sous les conditions
+// de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA 
+// sur le site "http://www.cecill.info".
+
+// En contrepartie de l'accessibilité au code source et des droits de copie,
+// de modification et de redistribution accordés par cette licence, il n'est
+// offert aux utilisateurs qu'une garantie limitée.  Pour les mêmes raisons,
+// seule une responsabilité restreinte pèse sur l'auteur du programme,  le
+// titulaire des droits patrimoniaux et les concédants successifs.
+
+// A cet égard  l'attention de l'utilisateur est attirée sur les risques
+// associés au chargement,  à l'utilisation,  à la modification et/ou au
+// développement et à la reproduction du logiciel par l'utilisateur étant 
+// donné sa spécificité de logiciel libre, qui peut le rendre complexe à 
+// manipuler et qui le réserve donc à des développeurs et des professionnels
+// avertis possédant  des  connaissances  informatiques approfondies.  Les
+// utilisateurs sont donc invités à charger  et  tester  l'adéquation  du
+// logiciel à leurs besoins dans des conditions permettant d'assurer la
+// sécurité de leurs systèmes et ou de leurs données et, plus généralement, 
+// à l'utiliser et l'exploiter dans les mêmes conditions de sécurité. 
+
+// Le fait que vous puissiez accéder à cet en-tête signifie que vous avez 
+// pris connaissance de la licence CeCILL, et que vous en avez accepté les
+// termes.
+
+/**
+ * Classe représentant une carte de Memory
+ */
+public class Carte {
+    
+    /**
+     * Permet de savoir combien on a de cartes en tout.
+     * Pas vraiment clair qu'on veuille s'en servir ici. 
+     * C'est purement pour des raisons pédagogiques de rappel de ce que veut dire un attribut de classe.
+     * 
+     * Je ne rentre pas dans les détails de la destruction d'objets.
+     * Il faut lire la doc à propos de Objects.finalize()
+    */
+    static int nbreCarte;
+
+    /**
+     * False ssi caché
+     */
+    private boolean visible; 
+    
+    /**
+     * pour pouvoir apparier des cartes.
+     */
+    private int valeur;    
+
+    /** Constructeur de carte.
+    */
+    public Carte(int valeur){
+        Carte.nbreCarte++;
+        this.visible=false; // caché par défaut
+        this.valeur=valeur;
+    }
+
+    // NB. Moralement, les cartes ne devraient pas être cachées.
+    // dans cette version on ne fait rien mais on voudrait idéalement que ce ne soit pas possible
+    /**
+     *  Prédicat permettant de tester le fait que deux cartes ont la même valeur
+     * @param Carte la carte à comparer à this. 
+     * @return true si elles ont la même valeur. 
+     * @throws NullPointerException si la carte passée en paramètre ou this est null.
+     * @throws IllegalArgumentException si l'argument n'est pas visible
+     * @throws IllegalStateExeption si this n'est pas visible
+     */
+    public boolean egale(Carte c){
+        Objects.requireNonNull(c, "la carte à tester passée en paramètre ne peut pas être null");
+        Objects.requireNonNull(this, "la carte qu'on veut comparer (this) ne peut pas être null");
+        
+        if (!this.getVisible()) throw new IllegalStateException("Carte non visible.");
+        if (!c.getVisible()) throw new IllegalArgumentException("Carte paramètre non visible.");
+        return c.valeur == this.valeur;
+    }
+
+    public boolean getVisible(){
+        return visible;
+    }
+
+    /**
+     * Méthode inversant la visibilité d'une carte.
+     */
+    public void toggleVisible(){
+        this.visible = ! this.visible;
+    }
+
+  /**
+    * @return String representant la carte (version longue)
+    * @see toString
+    */ 
+    public String toStringLong(){
+        return  this.toString() + " parmi " + Carte.nbreCarte;
+    }
+
+    /**
+    * @return String representant la carte.
+    */ 
+    public String toString(){
+        return "une carte " + (this.visible ? "visible" + " de valeur " + this.valeur: "cachée");
+    }
+
+    /**
+     * C'est un peu moche mais on peut pour simplifier mettre des tests manuels dans un main dans chaque classe.
+     * C'est plutôt mieux que de mettre des print dans chaque méthode car vous êtes plus sûr de la stabilité de vos tests 
+     * (vous pouvez rejouer les tests plus tard).
+     *
+     * Idéalement on utilise un outil dédié comme JUnit qui favorise au maximum cette automatisation.
+     * @param args pas de paramètre en ligne de commande prévu.
+     */
+    public static void main(String[] args) {
+        Carte un = new Carte(1);
+        System.out.println(un.toString());
+        Carte deux = new Carte (2);
+        System.out.println(deux.toString());
+        Carte unBis = new Carte(1);
+        System.out.println(unBis.toString());
+
+        un.toggleVisible();
+        System.out.println(un.toString());
+        unBis.toggleVisible();
+        System.out.println(unBis.toString());
+        System.out.println(un.egale(unBis));
+        unBis.toggleVisible();//true
+        System.out.println(unBis.toString());
+
+        System.out.println(un.toString());
+        deux.toggleVisible();
+        System.out.println(deux.toString());
+        System.out.println(!un.egale(deux));//not false
+
+        Carte bad = null;
+        un.egale(bad);
+    }
+}
+
+

DEV 2.2/TP01/v0/EnsembleCarte.java

@@ -0,0 +1,142 @@
+import java.util.LinkedHashSet;
+
+// Copyright Florent Madelaine, (3 juin 2020) 
+
+// florent.madelaine@u-pec.fr
+
+// Ce logiciel est un programme informatique simulant une petite partie du jeu de Memory
+
+// Ce logiciel est régi par la licence CeCILL soumise au droit français et
+// respectant les principes de diffusion des logiciels libres. Vous pouvez
+// utiliser, modifier et/ou redistribuer ce programme sous les conditions
+// de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA 
+// sur le site "http://www.cecill.info".
+
+// En contrepartie de l'accessibilité au code source et des droits de copie,
+// de modification et de redistribution accordés par cette licence, il n'est
+// offert aux utilisateurs qu'une garantie limitée.  Pour les mêmes raisons,
+// seule une responsabilité restreinte pèse sur l'auteur du programme,  le
+// titulaire des droits patrimoniaux et les concédants successifs.
+
+// A cet égard  l'attention de l'utilisateur est attirée sur les risques
+// associés au chargement,  à l'utilisation,  à la modification et/ou au
+// développement et à la reproduction du logiciel par l'utilisateur étant 
+// donné sa spécificité de logiciel libre, qui peut le rendre complexe à 
+// manipuler et qui le réserve donc à des développeurs et des professionnels
+// avertis possédant  des  connaissances  informatiques approfondies.  Les
+// utilisateurs sont donc invités à charger  et  tester  l'adéquation  du
+// logiciel à leurs besoins dans des conditions permettant d'assurer la
+// sécurité de leurs systèmes et ou de leurs données et, plus généralement, 
+// à l'utiliser et l'exploiter dans les mêmes conditions de sécurité. 
+
+// Le fait que vous puissiez accéder à cet en-tête signifie que vous avez 
+// pris connaissance de la licence CeCILL, et que vous en avez accepté les
+// termes.
+
+
+
+/**
+ * classe abstraite pour gérer les opérations sur les ensembles de carte qu'on trouve au memory
+ * 
+ */
+public abstract class EnsembleCarte {
+    /**
+     * La structure de donnée utilisée pour stocker les cartes dans la partie Collection de java.util.
+     * En gros, c'est un ensemble (répétition interdite) qui liste les éléments dans un ordre stable.
+     * La doc de java.util a propos de AbstractSet (ancêtre de LinkedHashSet)
+     * (...) all of the methods and constructors in subclasses of this class must obey the additional
+     * constraints imposed by the Set interface (for instance, the add method must not permit addition 
+     * of multiple instances of an object to a set). 
+     */
+   	private LinkedHashSet<Carte> contenu = new LinkedHashSet<Carte>();
+    
+    /**
+     * nbre de Cartes de l'ensemble.
+     * 
+     */
+    private int nbreCarte;
+
+    /**
+    * Constructeur d'Ensemble vide.
+    */
+    public EnsembleCarte(){
+        this.nbreCarte=0;
+    }
+
+    /**
+     * Ajoute une carte à l'ensemble.
+     * @param  c une carte
+     * @return true si la carte est ajoutée à l'ensemble
+     * @throws NullPointerException si la carte est null
+     * @throws IllegalStateException si la carte ne peut pas être ajoutée car elle est déjà présente dans l'ensemble  
+     */
+    protected boolean add(Carte c){
+        this.nbreCarte++;
+        return contenu.add(c); 
+    }
+
+    /**
+     * Enlève une carte à l'ensemble.
+     * @param  c une carte
+     * @return true si la carte est retirée à l'ensemble
+     * @throws NullPointerException si la carte est null
+     * @throws IllegalStateException si la carte ne peut pas être enlevéé car elle n'est pas présente dans l'ensemble  
+     */
+    private boolean remove(Carte c){
+        this.nbreCarte++;
+        return contenu.remove(c); 
+    }
+
+    /**
+     * Permet de transférer une paire de carte (par exemple depuis la table vers un joueur)
+     * Si ces cartes sont toutes les deux visibles
+     * @param  target destination du transfert
+     * @param  c1     première carte
+     * @param  c2     seconde carte
+     * @return        true en cas de succès, false sinon
+     * @throws NullPointerException si un élément passé en paramètre est null.
+     * @throws IllegalArgumentException si les cartes ne sont pas toutes les deux visibles
+     * @throws IllegalStateException si this ne contient pas les deux cartes.
+     */
+    public boolean transfer(EnsembleCarte target, Carte c1, Carte c2){
+    	return this.contenu.contains(c1) && this.contenu.remove(c1) && target.add(c1) && this.contenu.contains(c2) && this.contenu.remove(c2) && target.add(c2);
+    }	
+
+
+    public String toString(){
+        // Stringbuilder is the most efficient method of building a String like datastructure incrementally. 
+        StringBuilder sb = new StringBuilder(" de taille " + this.contenu.size() + ", contenant : \n");
+        for (Carte c : this.contenu){
+            sb.append(" _ " + c.toString() +"\n");
+        }
+        return sb.toString();
+    }
+
+
+    // tests obsolètes [serait OK si classe n'était pas abstraite]
+    
+    // public static void main(String[] args) {
+        
+    //     Carte un = new Carte(1);
+    //     Carte deux = new Carte (2);
+    //     deux.toggleVisible();
+    //     Carte unBis = new Carte(1);
+
+    //     Carte deuxBis = new Carte(2);
+
+    //     EnsembleCarte e1 = new EnsembleCarte();
+    //     System.out.println(e1.add(un) && e1.add(deux));
+    //     System.out.println(e1.toString());
+
+    //     EnsembleCarte e2 = new EnsembleCarte();
+    //     System.out.println(e2.add(un) && e2.add(unBis));
+    //     System.out.println(e2.toString());
+        
+    //     e1.transfer(e2,un,deuxBis);
+    //     System.out.println(e1.toString());
+    //     System.out.println(e2.toString());   
+        
+    // }
+}
+
+

DEV 2.2/TP01/v0/Joueur.java

@@ -0,0 +1,96 @@
+import java.util.Objects;
+
+// Copyright Florent Madelaine, (3 juin 2020) 
+
+// florent.madelaine@u-pec.fr
+
+// Ce logiciel est un programme informatique simulant une petite partie du jeu de Memory
+
+// Ce logiciel est régi par la licence CeCILL soumise au droit français et
+// respectant les principes de diffusion des logiciels libres. Vous pouvez
+// utiliser, modifier et/ou redistribuer ce programme sous les conditions
+// de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA 
+// sur le site "http://www.cecill.info".
+
+// En contrepartie de l'accessibilité au code source et des droits de copie,
+// de modification et de redistribution accordés par cette licence, il n'est
+// offert aux utilisateurs qu'une garantie limitée.  Pour les mêmes raisons,
+// seule une responsabilité restreinte pèse sur l'auteur du programme,  le
+// titulaire des droits patrimoniaux et les concédants successifs.
+
+// A cet égard  l'attention de l'utilisateur est attirée sur les risques
+// associés au chargement,  à l'utilisation,  à la modification et/ou au
+// développement et à la reproduction du logiciel par l'utilisateur étant 
+// donné sa spécificité de logiciel libre, qui peut le rendre complexe à 
+// manipuler et qui le réserve donc à des développeurs et des professionnels
+// avertis possédant  des  connaissances  informatiques approfondies.  Les
+// utilisateurs sont donc invités à charger  et  tester  l'adéquation  du
+// logiciel à leurs besoins dans des conditions permettant d'assurer la
+// sécurité de leurs systèmes et ou de leurs données et, plus généralement, 
+// à l'utiliser et l'exploiter dans les mêmes conditions de sécurité. 
+
+// Le fait que vous puissiez accéder à cet en-tête signifie que vous avez 
+// pris connaissance de la licence CeCILL, et que vous en avez accepté les
+// termes.
+
+/**
+ * Classe servant à représenter le joueur dans le modèle.
+ * Pour l'instant juste un nom et un ensemble de cartes
+ */
+public class Joueur extends EnsembleCarte {
+    /**
+    * Nom du joueur
+    */
+    private String nom;
+    
+    /**
+     * Constructeur
+     * @param  nom Futur nom du joueur, ne doit pas être null
+     * @throws nullPointerException si nom est null.
+     */
+    public Joueur(String nom){
+        Objects.requireNonNull(nom);
+        this.nom=nom;
+    }
+
+    public String toString(){
+        return "Joueur " + this.nom + " " + super.toString();
+    }
+
+
+    public static void main(String[] args) {
+        // c'est un peu moche mais on peut pour simplifier mettre des tests manuels dans un main dans chaque classe.
+        // C'est plutôt mieux que de mettre des print dans chaque méthode car vous êtes plus sûr de la stabilité de vos tests (vous pouvez rejouer les tests plus tard).
+
+        // Les Joueurs
+        Joueur toto = new Joueur("Toto");
+        //Joueur titi = new Joueur("Titi");
+        //Joueur tata = new Joueur("Tata");
+        
+        // Les cartes
+        Carte un = new Carte(1);
+        Carte deux = new Carte (2);
+        Carte unBis = new Carte(1);
+        Carte deuxBis = new Carte(2);
+
+        // la Table
+        Table t = new Table();
+        t.add(un);
+        t.add(deux);
+        t.add(unBis);
+        t.add(deuxBis);
+
+        System.out.println(t);
+        System.out.println(toto);
+
+        t.reveler(un);
+        t.reveler(unBis);
+
+        t.transfer(toto,un,unBis);
+        
+        System.out.println(t);
+        System.out.println(toto);	
+    }
+}
+
+

DEV 2.2/TP01/v0/Table.java

@@ -0,0 +1,126 @@
+import java.util.LinkedHashSet;
+import java.util.Objects;
+
+// Copyright Florent Madelaine, (3 juin 2020) 
+
+// florent.madelaine@u-pec.fr
+
+// Ce logiciel est un programme informatique simulant une petite partie du jeu de Memory
+
+// Ce logiciel est régi par la licence CeCILL soumise au droit français et
+// respectant les principes de diffusion des logiciels libres. Vous pouvez
+// utiliser, modifier et/ou redistribuer ce programme sous les conditions
+// de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA 
+// sur le site "http://www.cecill.info".
+
+// En contrepartie de l'accessibilité au code source et des droits de copie,
+// de modification et de redistribution accordés par cette licence, il n'est
+// offert aux utilisateurs qu'une garantie limitée.  Pour les mêmes raisons,
+// seule une responsabilité restreinte pèse sur l'auteur du programme,  le
+// titulaire des droits patrimoniaux et les concédants successifs.
+
+// A cet égard  l'attention de l'utilisateur est attirée sur les risques
+// associés au chargement,  à l'utilisation,  à la modification et/ou au
+// développement et à la reproduction du logiciel par l'utilisateur étant 
+// donné sa spécificité de logiciel libre, qui peut le rendre complexe à 
+// manipuler et qui le réserve donc à des développeurs et des professionnels
+// avertis possédant  des  connaissances  informatiques approfondies.  Les
+// utilisateurs sont donc invités à charger  et  tester  l'adéquation  du
+// logiciel à leurs besoins dans des conditions permettant d'assurer la
+// sécurité de leurs systèmes et ou de leurs données et, plus généralement, 
+// à l'utiliser et l'exploiter dans les mêmes conditions de sécurité. 
+
+// Le fait que vous puissiez accéder à cet en-tête signifie que vous avez 
+// pris connaissance de la licence CeCILL, et que vous en avez accepté les
+// termes.
+
+
+
+/**
+ * Classe gérant la table de jeu du Memory dans le modèle
+ * Pour l'instant ne gère pas le tour des joueurs.
+ * Devrait probablement le faire un jour.
+ */
+public class Table extends EnsembleCarte {
+       
+    /**
+     * Constructeur de Table vide (seul constructeur pour l'instant)
+     */
+    public Table(){
+    }
+
+    /**
+     * Nécessaire de la rendre publique car on a un parti pris que on commence avec une table vide à laquelle on ajoute des cartes.
+     * On pourrait alternativement faire un constructeur qui fabrique les cartes ou bien qui prend une collection de cartes.
+     * Ça n'aurait pas la vertu pédagogique de montrer qu'on peut surcharger une méthode en élevant les droits en java.
+     * 
+     * Par délégation mais en rendant publique la méthode (pour l'initialisation en fait).
+     * @param  c Carte à ajouter
+     * @return true si la carte est ajoutée à l'ensemble
+     * @throws NullPointerException si la carte est null
+     * @throws IllegalStateException si la carte ne peut pas être ajoutée car elle est déjà présente dans l'ensemble  
+     */
+    @Override
+    public boolean add(Carte c){
+        return super.add(c);
+    }
+
+    /**
+     * révèle une carte.
+     * @param c une carte à révèler
+     * @throws NullPointerException si la carte est null
+     * @throws IllegalArgumentException si la carte n'est pas sur la table
+     * @throws IllegalStateException si la carte est déjà révélée 
+     */
+    public void reveler(Carte c){
+        Objects.requireNonNull(c);
+        c.toggleVisible(); 
+    }
+
+	/**
+     * cache une carte.
+     * @param c une carte à cacher
+     * @throws NullPointerException si la carte est null
+     * @throws IllegalArgumentException si la carte n'est pas sur la table
+     * @throws IllegalStateException si la carte est déjà cachée 
+     */
+    public void cacher(Carte c){
+        Objects.requireNonNull(c);
+        c.toggleVisible(); 
+    }
+
+
+    public String toString(){
+        return "Table " + super.toString();
+    }
+
+
+    public static void main(String[] args) {
+        // c'est un peu moche mais on peut pour simplifier mettre des tests manuels dans un main dans chaque classe.
+        // C'est plutôt mieux que de mettre des print dans chaque méthode car vous êtes plus sûr de la stabilité de vos tests (vous pouvez rejouer les tests plus tard).
+
+        // Les cartes
+        Carte un = new Carte(1);
+        Carte deux = new Carte (2);
+        Carte unBis = new Carte(1);
+        Carte deuxBis = new Carte(2);
+
+
+        // la Table
+        Table t = new Table();
+        t.add(un);
+        t.add(deux);
+        t.add(unBis);
+        t.add(deuxBis);
+
+        System.out.println(t);
+
+        t.reveler(un);
+        t.reveler(unBis);
+        
+        System.out.println(t);
+                
+    }
+}
+
+

DEV 2.2/TP01/v0/TestCarte.java

@@ -0,0 +1,84 @@
+import static org.junit.Assert.assertTrue; // import static : une facilité offerte depuis java5 (pas besoin de mettre le préfixe)
+import static org.junit.Assert.assertFalse; // 
+import org.junit.Test;
+
+
+/**
+ * Une classe pour faire des tests sur la classe Carte avec JUnit
+ */
+public class TestCarte {
+
+    // un test pour Junit4 c'est une méthode avec l'annotation @Test devant une méthode avec un type de retour void.
+    @Test
+    public void egaleSiIdentiquesEtVisible() {
+        Carte un = new Carte(1);
+        un.toggleVisible();
+         // on peut stipuler que des choses sont normalement égales (il faut charger de manière statique les Assert si on veut éviter d'avoir à écrire de quelle classe on parle)
+        assertTrue(un.egale(un));
+    }
+
+    // le nom du test doit être le plus explicite possible
+    @Test
+    public void egalSiMemeValeurEtVisible() {
+       Carte un = new Carte(1);
+       un.toggleVisible();
+       Carte unBis = new Carte(1);
+       unBis.toggleVisible();
+       assertTrue(un.egale(unBis));
+    }
+
+    @Test
+    public void pasEgalSiPasMemeValeurEtVisible() {
+       Carte un = new Carte(1);
+       un.toggleVisible();
+       Carte deux = new Carte(2);
+       deux.toggleVisible();
+       assertFalse(un.egale(deux));
+    }
+
+    // un test pour Junit4 qui cherche à vérifier qu'il y a bien une exception
+    @Test(expected = NullPointerException.class)
+    public void egalPasFaitPourNull(){
+        Carte bad = null;
+        Carte un = new Carte(1);
+        un.egale(bad);
+    }
+
+    // un autre test pour Junit4 qui cherche à vérifier qu'il y a bien une exception
+    @Test(expected = IllegalArgumentException.class)
+    public void egalPasFaitPourParametreNonVisible(){
+        Carte un = new Carte(1);
+         un.toggleVisible();
+        Carte deux = new Carte(2);
+        un.egale(deux);
+    }
+
+    // un autre test pour Junit4 qui cherche à vérifier qu'il y a bien une exception
+    @Test(expected = IllegalStateException.class)
+    public void egalPasFaitPourCarteThisNonVisible(){
+        Carte un = new Carte(1);
+        Carte deux = new Carte(2);
+        deux.toggleVisible();    
+        un.egale(deux);
+    }
+
+    //Le monde est mal fait et parfois c'est le test qui est faux.
+    //Notez que je suis vraiment méchant car ce test est satisfait au début avec le code proposé...
+    //Moralité : faites des tests très simples et faites vous relire! 
+    @Test 
+    public void egalTestMalFait(){
+        Carte un = new Carte(1);
+        un.toggleVisible();
+        Carte deux = new Carte(2);
+        deux.toggleVisible();
+        assertFalse(un.egale(deux));
+    }
+
+    // si on ne met pas l'annotation arobase test, le test n'est jamais pris en compte.
+    // c'est juste une méthode annexe qui n'est pas appellée comme dans n'importe quelle classe.
+    public void autreTestMalFait(){
+        assertFalse(true);
+    }
+    
+     
+}