diff --git a/DEV2.1/TP4/Moyenne.java b/DEV2.1/TP4/Moyenne.java index 692d2d6..699f6b4 100644 --- a/DEV2.1/TP4/Moyenne.java +++ b/DEV2.1/TP4/Moyenne.java @@ -44,6 +44,12 @@ public class Moyenne { public static void main(String[] args) { - + Moyenne test = new Moyenne(); + test.add(10); + test.add(20.0); + test.add(); + + + } } \ No newline at end of file diff --git a/DEV2.1/TP5/Attente.java b/DEV2.1/TP5/Attente.java new file mode 100644 index 0000000..850bce4 --- /dev/null +++ b/DEV2.1/TP5/Attente.java @@ -0,0 +1,25 @@ +import javax.swing.*; +import java.awt.*; +import java.awt.event.*; + +public class Attente extends JComponent implements WindowListener { + @Override + protected void paintComponent(Graphics pinceau) { + Graphics secondPinceau = pinceau.create(); + if (this.isOpaque()) { + secondPinceau.setColor(Color.GREEN); + secondPinceau.fillRect(0, 0, this.getWidth(), this.getHeight()); + } + } + + void windowActivated(WindowEvent evenement) // premier plan + { + + } + void windowClosed(WindowEvent evenement); // après fermeture + void windowClosing(WindowEvent evenement); // avant fermeture + void windowDeactivated(WindowEvent evenement); // arrière-plan + void windowDeiconified(WindowEvent evenement); // restauration + void windowIconified(WindowEvent evenement); // minimisation + void windowOpened(WindowEvent evenement); +} \ No newline at end of file diff --git a/DEV2.1/TP5/Fond.class b/DEV2.1/TP5/Fond.class new file mode 100644 index 0000000..94aa466 Binary files /dev/null and b/DEV2.1/TP5/Fond.class differ diff --git a/DEV2.1/TP5/Fond.java b/DEV2.1/TP5/Fond.java new file mode 100644 index 0000000..3da6931 --- /dev/null +++ b/DEV2.1/TP5/Fond.java @@ -0,0 +1,32 @@ +import javax.swing.*; +import java.awt.*; +import java.awt.event.*; + +public class Fond extends JPanel implements ActionListener { + + public Fond(){ + super(); + JButton bouton = new JButton("Blue"); + this.add(bouton); + JButton bouton2 = new JButton("Red"); + this.add(bouton2); + JButton bouton3 = new JButton("Green"); + this.add(bouton3); + + bouton.addActionListener(this); + bouton2.addActionListener(this); + bouton3.addActionListener(this); + } + public void actionPerformed(ActionEvent e) + { + if (e.getActionCommand()=="Blue") { + this.setBackground(Color.BLUE); + } + if (e.getActionCommand()=="Red") { + this.setBackground(Color.RED); + } + if (e.getActionCommand()=="Green") { + this.setBackground(Color.GREEN); + } + } +} \ No newline at end of file diff --git a/DEV2.1/TP5/Maintamere.class b/DEV2.1/TP5/Maintamere.class new file mode 100644 index 0000000..de2eb37 Binary files /dev/null and b/DEV2.1/TP5/Maintamere.class differ diff --git a/DEV2.1/TP5/Maintamere.java b/DEV2.1/TP5/Maintamere.java new file mode 100644 index 0000000..ceee0e5 --- /dev/null +++ b/DEV2.1/TP5/Maintamere.java @@ -0,0 +1,19 @@ +import javax.swing.*; +import java.awt.*; +import java.awt.event.*; + +public class Maintamere { + + public static void main(String[] args) { + + JFrame fenetre = new JFrame(); + fenetre.setSize(1000, 1000); + fenetre.setLocation(0, 0); + + Fond tamere = new Fond(); + fenetre.add(tamere, BorderLayout.CENTER); + + fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + fenetre.setVisible(true); + } +} \ No newline at end of file diff --git a/DEV2.1/TP5/main666.java b/DEV2.1/TP5/main666.java new file mode 100644 index 0000000..733a041 --- /dev/null +++ b/DEV2.1/TP5/main666.java @@ -0,0 +1,19 @@ +import javax.swing.*; +import java.awt.*; +import java.awt.event.*; + +public class Maintamere { + + public static void main(String[] args) { + + JFrame fenetre = new JFrame(); + fenetre.setSize(1000, 1000); + fenetre.setLocation(0, 0); + + Fond tamere = new Attente(); + fenetre.add(tamere, BorderLayout.CENTER); + + fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + fenetre.setVisible(true); + } +} \ No newline at end of file diff --git a/DEV2.1/TP6/MonInt.class b/DEV2.1/TP6/MonInt.class new file mode 100644 index 0000000..cc5fea7 Binary files /dev/null and b/DEV2.1/TP6/MonInt.class differ diff --git a/DEV2.1/TP6/MonInt.java b/DEV2.1/TP6/MonInt.java new file mode 100644 index 0000000..323aa39 --- /dev/null +++ b/DEV2.1/TP6/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/DEV2.1/TP6/v0/Carte.java b/DEV2.1/TP6/v0/Carte.java new file mode 100644 index 0000000..90a08bd --- /dev/null +++ b/DEV2.1/TP6/v0/Carte.java @@ -0,0 +1,145 @@ +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){ + this.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"); + 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 " + this.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/DEV2.1/TP6/v0/EnsembleCarte.java b/DEV2.1/TP6/v0/EnsembleCarte.java new file mode 100644 index 0000000..7761cb9 --- /dev/null +++ b/DEV2.1/TP6/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/DEV2.1/TP6/v0/Joueur.java b/DEV2.1/TP6/v0/Joueur.java new file mode 100644 index 0000000..3a4a69a --- /dev/null +++ b/DEV2.1/TP6/v0/Joueur.java @@ -0,0 +1,95 @@ +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 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){ + 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/DEV2.1/TP6/v0/Table.java b/DEV2.1/TP6/v0/Table.java new file mode 100644 index 0000000..1c1cc57 --- /dev/null +++ b/DEV2.1/TP6/v0/Table.java @@ -0,0 +1,123 @@ +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 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 à ajou + * @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){ + 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){ + 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/DEV2.1/TP6/v0/TestCarte.java b/DEV2.1/TP6/v0/TestCarte.java new file mode 100644 index 0000000..9862dd2 --- /dev/null +++ b/DEV2.1/TP6/v0/TestCarte.java @@ -0,0 +1,85 @@ +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(); + un.toggleVisible();//copié collé de la mort + 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/DEV2.1/TP6/v0Memory.zip b/DEV2.1/TP6/v0Memory.zip new file mode 100644 index 0000000..dbf238d Binary files /dev/null and b/DEV2.1/TP6/v0Memory.zip differ diff --git a/WEBBE/TP1/bonjour.php b/WEBBE/TP1/bonjour.php new file mode 100644 index 0000000..bb6fc6c --- /dev/null +++ b/WEBBE/TP1/bonjour.php @@ -0,0 +1,6 @@ + + + + hello world";?> + + diff --git a/WEBBE/TP2/exo1.php b/WEBBE/TP2/exo1.php new file mode 100644 index 0000000..3270124 --- /dev/null +++ b/WEBBE/TP2/exo1.php @@ -0,0 +1,50 @@ + + + +
+

Qui etes-vous ?

+
+
+
+ +
+

Sexe :

+ +
+ +
+ +
+ +
+ +
+
+

+ +

+ + \ No newline at end of file