diff --git a/DEV2.1/TP7:Evenements/Attente.java b/DEV2.1/TP7:Evenements/Attente.java index 9ea5b52..9a472af 100644 --- a/DEV2.1/TP7:Evenements/Attente.java +++ b/DEV2.1/TP7:Evenements/Attente.java @@ -1,6 +1,7 @@ import java.awt.*; import javax.swing.*; import java.awt.event.*; +import java.lang.* public class Attente extends JPanel implements WindowListener{ diff --git a/DEV2.1/TP8/MonInt.class b/DEV2.1/TP8/MonInt.class new file mode 100644 index 0000000..99b981c Binary files /dev/null and b/DEV2.1/TP8/MonInt.class differ diff --git a/DEV2.1/TP8/MonInt.java b/DEV2.1/TP8/MonInt.java new file mode 100644 index 0000000..9ec608d --- /dev/null +++ b/DEV2.1/TP8/MonInt.java @@ -0,0 +1,98 @@ +// notez le s apres Object. Permet entre autre de stipuler qu'un objet o n'est pas null avec la methode Objects.requireNonNull(o, "message d'erreur detaille"); +import java.util.Objects; +/* + * Sorte de Int du pauvre a laquelle on ajoute un nom sous forme textuelle. + * + * Classe donnee a titre d'exemple pour illustrer les ingredients techniques de la prog defensive. + * 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 etre null"); + int avant = this.valeur; + + this.valeur = this.valeur / c.getValeur(); + this.nom = "(" + this.nom + " divise 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 plutot mieux que de mettre des print dans chaque methode car vous etes plus sur de la stabilite de vos tests + * (vous pouvez rejouer les tests plus tard). + * + * Idealement on utilise un outil dedie comme JUnit qui favorise au maximum cette automatisation. + * + * @param args pas de parametre en ligne de commande prevu. + */ + 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 verifier 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/TP8/v0/Carte.class b/DEV2.1/TP8/v0/Carte.class new file mode 100644 index 0000000..745636a Binary files /dev/null and b/DEV2.1/TP8/v0/Carte.class differ diff --git a/DEV2.1/TP8/v0/Carte.java b/DEV2.1/TP8/v0/Carte.java new file mode 100644 index 0000000..3b24116 --- /dev/null +++ b/DEV2.1/TP8/v0/Carte.java @@ -0,0 +1,150 @@ +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"); + if(!c.visible){ + throw new IllegalArgumentException("carte en argument non visible"); + } if (!this.visible){ + throw new IllegalArgumentException ("carte courante 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 " + 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/TP8/v0/EnsembleCarte.class b/DEV2.1/TP8/v0/EnsembleCarte.class new file mode 100644 index 0000000..ab7d3e5 Binary files /dev/null and b/DEV2.1/TP8/v0/EnsembleCarte.class differ diff --git a/DEV2.1/TP8/v0/EnsembleCarte.java b/DEV2.1/TP8/v0/EnsembleCarte.java new file mode 100644 index 0000000..7761cb9 --- /dev/null +++ b/DEV2.1/TP8/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/TP8/v0/Joueur.class b/DEV2.1/TP8/v0/Joueur.class new file mode 100644 index 0000000..f3a1cf3 Binary files /dev/null and b/DEV2.1/TP8/v0/Joueur.class differ diff --git a/DEV2.1/TP8/v0/Joueur.java b/DEV2.1/TP8/v0/Joueur.java new file mode 100644 index 0000000..3a4a69a --- /dev/null +++ b/DEV2.1/TP8/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/TP8/v0/Table.class b/DEV2.1/TP8/v0/Table.class new file mode 100644 index 0000000..e8f5cb9 Binary files /dev/null and b/DEV2.1/TP8/v0/Table.class differ diff --git a/DEV2.1/TP8/v0/Table.java b/DEV2.1/TP8/v0/Table.java new file mode 100644 index 0000000..1c1cc57 --- /dev/null +++ b/DEV2.1/TP8/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/TP8/v0/TestCarte.java b/DEV2.1/TP8/v0/TestCarte.java new file mode 100644 index 0000000..9862dd2 --- /dev/null +++ b/DEV2.1/TP8/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/TP8/v0Memory.zip b/DEV2.1/TP8/v0Memory.zip new file mode 100644 index 0000000..dbf238d Binary files /dev/null and b/DEV2.1/TP8/v0Memory.zip differ diff --git a/DEV3.1/TP2:Transitions/Galerie/Changement.class b/DEV3.1/TP2:Transitions/Galerie/Changement.class new file mode 100644 index 0000000..bdf31cf Binary files /dev/null and b/DEV3.1/TP2:Transitions/Galerie/Changement.class differ diff --git a/DEV3.1/TP2:Transitions/Galerie/Changement.java b/DEV3.1/TP2:Transitions/Galerie/Changement.java new file mode 100644 index 0000000..fd699ac --- /dev/null +++ b/DEV3.1/TP2:Transitions/Galerie/Changement.java @@ -0,0 +1,23 @@ +import java.awt.*; +import javax.swing.*; +import java.util.*; + +public class Changement{ + + static public void fenetreCliquer(int LR){ + Main.pan.remove(Listeimage.liste[Listeimage.index]); + if (LR==1){ + Listeimage.index+=1; + if(Listeimage.index==-1){ + Listeimage.index=5; + } + }else { + Listeimage.index-=1; + if(Listeimage.index==6){ + Listeimage.index=0; + } + } + Main.pan.add(Listeimage.liste[Listeimage.index]); + Main.pan.repaint(); + } +} \ No newline at end of file diff --git a/DEV3.1/TP2:Transitions/Galerie/Galerie.class b/DEV3.1/TP2:Transitions/Galerie/Galerie.class new file mode 100644 index 0000000..9f50586 Binary files /dev/null and b/DEV3.1/TP2:Transitions/Galerie/Galerie.class differ diff --git a/DEV3.1/TP2:Transitions/Galerie/Galerie.java b/DEV3.1/TP2:Transitions/Galerie/Galerie.java new file mode 100644 index 0000000..7585119 --- /dev/null +++ b/DEV3.1/TP2:Transitions/Galerie/Galerie.java @@ -0,0 +1,32 @@ +import java.awt.*; +import javax.swing.*; +import java.awt.event.*; +import java.util.*; + +public class Galerie extends JPanel implements MouseListener{ + + public Galerie(){ + super(); + } + + public void mouseClicked(MouseEvent e){ + int x = e.getX(); + if (x <= this.getWidth()/5){ + Changement.fenetreCliquer(0); + }else if(x >= (this.getWidth()/5)*4){ + Changement.fenetreCliquer(1); + } + } + + public void mouseEntered(MouseEvent evenement){ + } + + public void mouseExited(MouseEvent evenement){ + } + + public void mousePressed(MouseEvent evenement){ + } + + public void mouseReleased(MouseEvent evenement){ + } +} diff --git a/DEV3.1/TP2:Transitions/Galerie/Listeimage.class b/DEV3.1/TP2:Transitions/Galerie/Listeimage.class new file mode 100644 index 0000000..72dd0d9 Binary files /dev/null and b/DEV3.1/TP2:Transitions/Galerie/Listeimage.class differ diff --git a/DEV3.1/TP2:Transitions/Galerie/Listeimage.java b/DEV3.1/TP2:Transitions/Galerie/Listeimage.java new file mode 100644 index 0000000..04c5d5b --- /dev/null +++ b/DEV3.1/TP2:Transitions/Galerie/Listeimage.java @@ -0,0 +1,15 @@ +import java.awt.*; +import javax.swing.*; +import java.awt.event.*; +import java.util.*; + +public class Listeimage{ + + static JLabel image1 = new JLabel(new ImageIcon("image1.jpg")); + static JLabel image2 = new JLabel(new ImageIcon("image2.jpg")); + static JLabel image3 = new JLabel(new ImageIcon("image3.jpg")); + static JLabel image4 = new JLabel(new ImageIcon("image4.jpg")); + static JLabel image5 = new JLabel(new ImageIcon("image5.jpg")); + static JLabel[] liste = {image1, image2, image3, image4, image5}; + static int index=0; +} \ No newline at end of file diff --git a/DEV3.1/TP2:Transitions/Galerie/Main.class b/DEV3.1/TP2:Transitions/Galerie/Main.class new file mode 100644 index 0000000..6431783 Binary files /dev/null and b/DEV3.1/TP2:Transitions/Galerie/Main.class differ diff --git a/DEV3.1/TP2:Transitions/Galerie/Main.java b/DEV3.1/TP2:Transitions/Galerie/Main.java new file mode 100644 index 0000000..9dc9a82 --- /dev/null +++ b/DEV3.1/TP2:Transitions/Galerie/Main.java @@ -0,0 +1,20 @@ +import java.awt.*; +import javax.swing.*; +import java.util.*; + +public class Main{ + + static JFrame fenetre = new JFrame(); + static Galerie pan = new Galerie(); + + public static void main(String[] args) { + + pan.add(Listeimage.image1); + fenetre.setSize(250, 250); + fenetre.setLocation(250, 250); + fenetre.addMouseListener(pan); + fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + fenetre.setContentPane(pan); + fenetre.setVisible(true); + } +} \ No newline at end of file diff --git a/DEV3.1/TP2:Transitions/Galerie/image1.jpg b/DEV3.1/TP2:Transitions/Galerie/image1.jpg new file mode 100644 index 0000000..d402162 Binary files /dev/null and b/DEV3.1/TP2:Transitions/Galerie/image1.jpg differ diff --git a/DEV3.1/TP2:Transitions/Galerie/image2.jpg b/DEV3.1/TP2:Transitions/Galerie/image2.jpg new file mode 100644 index 0000000..f0b6b06 Binary files /dev/null and b/DEV3.1/TP2:Transitions/Galerie/image2.jpg differ diff --git a/DEV3.1/TP2:Transitions/Galerie/image3.jpg b/DEV3.1/TP2:Transitions/Galerie/image3.jpg new file mode 100644 index 0000000..b823066 Binary files /dev/null and b/DEV3.1/TP2:Transitions/Galerie/image3.jpg differ diff --git a/DEV3.1/TP2:Transitions/Galerie/image4.jpg b/DEV3.1/TP2:Transitions/Galerie/image4.jpg new file mode 100644 index 0000000..939d686 Binary files /dev/null and b/DEV3.1/TP2:Transitions/Galerie/image4.jpg differ diff --git a/DEV3.1/TP2:Transitions/Galerie/image5.jpg b/DEV3.1/TP2:Transitions/Galerie/image5.jpg new file mode 100644 index 0000000..2f97128 Binary files /dev/null and b/DEV3.1/TP2:Transitions/Galerie/image5.jpg differ diff --git a/SAE b/SAE deleted file mode 160000 index 12188da..0000000 --- a/SAE +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 12188daa2226d67c8e71cacb6b2d8e635cb12d4c diff --git a/Vote.java b/Vote.java new file mode 100644 index 0000000..e239f24 --- /dev/null +++ b/Vote.java @@ -0,0 +1,20 @@ +import java.awt.*; +import java.sql.*; + +public class Vote{ + public static void main(String[] args) { + try{ + Class.forName("org.mariadb.jdbc.Driver"); + try{ + Connection cnx = new DriverManager.getConnection("jdbc:mariadb://dwarves.arda.lan/pourchot","pourchot","A1B2C3"); + try{ + PreparedStatement ps=cnx.prepareStatement("SELECT ("); + }catch(SQLException){ + cnx.close(); + } + }catch(SQLException){ + } + }catch(ClassNotFoundException){ + } + } +} \ No newline at end of file