diff --git a/APL2.1/TP14/Homotetie/Homotetie.class b/APL2.1/TP14/Homotetie/Homotetie.class new file mode 100644 index 0000000..918ff0f Binary files /dev/null and b/APL2.1/TP14/Homotetie/Homotetie.class differ diff --git a/APL2.1/TP14/Homotetie/Homotetie.java b/APL2.1/TP14/Homotetie/Homotetie.java new file mode 100644 index 0000000..81e9e23 --- /dev/null +++ b/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) { + + } + } +} diff --git a/APL2.1/TP14/Homotetie/polygone.bin b/APL2.1/TP14/Homotetie/polygone.bin new file mode 100644 index 0000000..329c5a5 Binary files /dev/null and b/APL2.1/TP14/Homotetie/polygone.bin differ diff --git a/APL2.1/TP14/Homotetie/polygonex2.bin b/APL2.1/TP14/Homotetie/polygonex2.bin new file mode 100644 index 0000000..f16c9b1 Binary files /dev/null and b/APL2.1/TP14/Homotetie/polygonex2.bin differ diff --git a/APL2.1/TP14/Memoire/CloseListener.class b/APL2.1/TP14/Memoire/CloseListener.class new file mode 100644 index 0000000..15d23fd Binary files /dev/null and b/APL2.1/TP14/Memoire/CloseListener.class differ diff --git a/APL2.1/TP14/Memoire/CloseListener.java b/APL2.1/TP14/Memoire/CloseListener.java new file mode 100644 index 0000000..84d0070 --- /dev/null +++ b/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 + + } + +} diff --git a/APL2.1/TP14/Memoire/Fond.class b/APL2.1/TP14/Memoire/Fond.class new file mode 100644 index 0000000..352fb55 Binary files /dev/null and b/APL2.1/TP14/Memoire/Fond.class differ diff --git a/APL2.1/TP14/Memoire/Fond.java b/APL2.1/TP14/Memoire/Fond.java new file mode 100644 index 0000000..c7823e8 --- /dev/null +++ b/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); + } + } +} \ No newline at end of file diff --git a/APL2.1/TP14/Memoire/Observer.class b/APL2.1/TP14/Memoire/Observer.class new file mode 100644 index 0000000..5ca3185 Binary files /dev/null and b/APL2.1/TP14/Memoire/Observer.class differ diff --git a/APL2.1/TP14/Memoire/Observer.java b/APL2.1/TP14/Memoire/Observer.java new file mode 100644 index 0000000..0f416c6 --- /dev/null +++ b/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); + } + } +} \ No newline at end of file diff --git a/APL2.1/TP14/Memoire/save.dat b/APL2.1/TP14/Memoire/save.dat new file mode 100644 index 0000000..8e58a8d Binary files /dev/null and b/APL2.1/TP14/Memoire/save.dat differ diff --git a/APL2.1/TP14/Polygone/Polygone.class b/APL2.1/TP14/Polygone/Polygone.class new file mode 100644 index 0000000..255faa8 Binary files /dev/null and b/APL2.1/TP14/Polygone/Polygone.class differ diff --git a/APL2.1/TP14/Polygone/Polygone.java b/APL2.1/TP14/Polygone/Polygone.java new file mode 100644 index 0000000..65be658 --- /dev/null +++ b/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); + } + + } +} \ No newline at end of file diff --git a/APL2.1/TP14/Polygone/Test.class b/APL2.1/TP14/Polygone/Test.class new file mode 100644 index 0000000..349a375 Binary files /dev/null and b/APL2.1/TP14/Polygone/Test.class differ diff --git a/APL2.1/TP14/Polygone/Test.java b/APL2.1/TP14/Polygone/Test.java new file mode 100644 index 0000000..ebfa7f4 --- /dev/null +++ b/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); + } +} diff --git a/APL2.1/TP14/Polygone/polygone.bin b/APL2.1/TP14/Polygone/polygone.bin new file mode 100644 index 0000000..329c5a5 Binary files /dev/null and b/APL2.1/TP14/Polygone/polygone.bin differ diff --git a/DEV 2.2/TP01/MonInt/Ma-Touille-pour-les-tests.txt b/DEV 2.2/TP01/MonInt/Ma-Touille-pour-les-tests.txt new file mode 100644 index 0000000..bec4b5d --- /dev/null +++ b/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."); \ No newline at end of file diff --git a/DEV 2.2/TP01/MonInt/MonInt.class b/DEV 2.2/TP01/MonInt/MonInt.class new file mode 100644 index 0000000..fc7b1cf Binary files /dev/null and b/DEV 2.2/TP01/MonInt/MonInt.class differ diff --git a/DEV 2.2/TP01/MonInt/MonInt.java b/DEV 2.2/TP01/MonInt/MonInt.java new file mode 100644 index 0000000..323aa39 --- /dev/null +++ b/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); + } + + + } +} diff --git a/DEV 2.2/TP01/v0/Carte.class b/DEV 2.2/TP01/v0/Carte.class new file mode 100644 index 0000000..c7bc443 Binary files /dev/null and b/DEV 2.2/TP01/v0/Carte.class differ diff --git a/DEV 2.2/TP01/v0/Carte.java b/DEV 2.2/TP01/v0/Carte.java new file mode 100644 index 0000000..860678c --- /dev/null +++ b/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); + } +} + + diff --git a/DEV 2.2/TP01/v0/EnsembleCarte.class b/DEV 2.2/TP01/v0/EnsembleCarte.class new file mode 100644 index 0000000..85bf583 Binary files /dev/null and b/DEV 2.2/TP01/v0/EnsembleCarte.class differ diff --git a/DEV 2.2/TP01/v0/EnsembleCarte.java b/DEV 2.2/TP01/v0/EnsembleCarte.java new file mode 100644 index 0000000..7761cb9 --- /dev/null +++ b/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 contenu = new LinkedHashSet(); + + /** + * 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()); + + // } +} + + diff --git a/DEV 2.2/TP01/v0/Joueur.class b/DEV 2.2/TP01/v0/Joueur.class new file mode 100644 index 0000000..a6d492d Binary files /dev/null and b/DEV 2.2/TP01/v0/Joueur.class differ diff --git a/DEV 2.2/TP01/v0/Joueur.java b/DEV 2.2/TP01/v0/Joueur.java new file mode 100644 index 0000000..daa64e1 --- /dev/null +++ b/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); + } +} + + diff --git a/DEV 2.2/TP01/v0/Table.class b/DEV 2.2/TP01/v0/Table.class new file mode 100644 index 0000000..730e4cd Binary files /dev/null and b/DEV 2.2/TP01/v0/Table.class differ diff --git a/DEV 2.2/TP01/v0/Table.java b/DEV 2.2/TP01/v0/Table.java new file mode 100644 index 0000000..de178c4 --- /dev/null +++ b/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); + + } +} + + diff --git a/DEV 2.2/TP01/v0/TestCarte.class b/DEV 2.2/TP01/v0/TestCarte.class new file mode 100644 index 0000000..83d38b5 Binary files /dev/null and b/DEV 2.2/TP01/v0/TestCarte.class differ diff --git a/DEV 2.2/TP01/v0/TestCarte.java b/DEV 2.2/TP01/v0/TestCarte.java new file mode 100644 index 0000000..a7dd593 --- /dev/null +++ b/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); + } + + +} diff --git a/DEV 2.2/TP01/v0/TestEnsemble.java b/DEV 2.2/TP01/v0/TestEnsemble.java new file mode 100644 index 0000000..e69de29