Merge branch 'master' of https://dwarves.iut-fbleau.fr/gitiut/sayebabu/DEV

.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "java.project.referencedLibraries": [
+        "lib/**/*.jar",
+        "DEV3.1/BDD_java/mariadb-java-client-3.2.0.jar",
+        "c:\\Users\\simon\\Downloads\\mysql-connector-j-8.2.0.jar"
+    ]
+}

DEV IHM/TP2/Synopsis.txt

@@ -0,0 +1,6 @@
+Synopsis
+
+le jardinier papé14 separe la partielle
+il observe la premiere moitier
+il separe la deuxieme parcelle
+il change d'avis et reunis les dexu sous parcelle

DEV2.3/tp1/MainCapture.java

@@ -0,0 +1,17 @@
+public class MainCapture {
+    public static void main(String[] args) {
+        try 
+        {
+            arrErr();
+        } 
+        catch (Exception e) 
+        {
+            System.out.println("Erreur :(");
+        }
+    }
+
+    public static void arrErr()
+    {
+        System.out.println(8/0);
+    }
+}

DEV2.3/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);
+    }
+}
+
+

DEV2.3/v0/EnsembleCarte.java

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

DEV2.3/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);	
+    }
+}
+
+

DEV2.3/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);
+                
+    }
+}
+
+

DEV2.3/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);
+    }
+    
+     
+}

DEV3.1/BDD_java/vote.java

@@ -11,14 +11,15 @@ public class vote
     
         try 
         {
+            Class.forName("org.mariadb.jdbc.Driver");
             Connection cnx = DriverManager.getConnection("jdbc:mariadb://dwarves.iut-fbleau.fr/sayebabu","sayebabu", "kjrzB5S4kqKAwdT");
             try 
             {
-                PreparedStatement pst = cnx.prepareStatement("SELECT PaysID FROM `Pays` WHERE Pays = '?'");
+                PreparedStatement pst = cnx.prepareStatement("SELECT PaysID FROM `Pays` WHERE Pays = ?");
                 pst.setString(1, args[0]);
                 ResultSet rs = pst.executeQuery();
                 int paysID = rs.getInt(1);
-                pst = cnx.prepareStatement("SELECT PaysVoteID, Points FROM `Comp` WHERE PaysCompID = '?'");
+                pst = cnx.prepareStatement("SELECT PaysVoteID, Points FROM `Comp` WHERE PaysCompID = ?");
                 pst.setInt(1, paysID);
 
                 int sumVote = 0;
@@ -28,7 +29,7 @@ public class vote
                     int votants = rs.getInt(2);
                     sumVote+=votants;
 
-                    PreparedStatement pst2 = cnx.prepareStatement("SELECT Pays FROM `Pays` WHERE PaysID = '?'");
+                    PreparedStatement pst2 = cnx.prepareStatement("SELECT Pays FROM `Pays` WHERE PaysID = ?");
                     pst2.setInt(1, comp);
                     ResultSet rs2 = pst.executeQuery();
                     rs2.next();
@@ -43,13 +44,13 @@ public class vote
             catch (Exception e) 
             {
                 cnx.close();
-                System.out.printf("TA MERE");
+                System.out.printf("TA MERE2"+e);
                 
             }
         } 
         catch (Exception e) 
         {
-          System.out.printf("TA MERE");  
+          System.out.printf("TA MERE1"+ e);  
         }
     }
 }

DEV3.2/Arbre/Repertoires/src/Noeud.java

@@ -0,0 +1,50 @@
+import java.util.ArrayList;
+
+/**
+ * La classe Noeud représente un nœud dans une structure d'arbre.
+ * Chaque nœud possède un identifiant unique (ID), un nom, un rang, et une liste d'enfants.
+ */
+public class Noeud {
+
+
+    /** Le nom du nœud */
+    public String name;
+
+    /** La liste des enfants du nœud */
+    public ArrayList<Noeud> enfants;
+
+   
+    public Noeud(String nom) {
+        this.name = nom;
+        this.enfants = new ArrayList<>();
+    }
+
+    /**
+     * Ajoute un nœud en tant qu'enfant du nœud actuel.
+     *
+     * @param enfant Le nœud à ajouter en tant qu'enfant.
+     */
+    public void ajouterEnfant(Noeud enfant) {
+        this.enfants.add(enfant);
+    }
+
+    /**
+     * Obtient la liste des enfants du nœud.
+     *
+     * @return La liste des enfants du nœud.
+     */
+    public ArrayList<Noeud> getEnfants() {
+        return enfants;
+    }
+
+
+    /**
+     * Obtient une représentation textuelle du nœud (son nom).
+     *
+     * @return Le nom du nœud.
+     */
+    @Override
+    public String toString() {
+        return name;
+    }
+}

DEV3.2/Arbre/Repertoires/src/repertoires.java

@@ -0,0 +1,52 @@
+import java.io.*; 
+  
+public class repertoires { 
+    public static void main(String args[]) 
+    { 
+  
+        try { 
+  
+            File f = new File(args[0]); 
+            System.out.println("Files are:"); 
+  
+            Noeud test = explo(f);
+            afficherArbre(test);
+        } 
+        catch (Exception e) { 
+            System.err.println(e.getMessage()); 
+        } 
+    } 
+
+    private static Noeud explo(File f)
+    {
+        File[] files = f.listFiles();
+        Noeud root = new Noeud(f.getName());
+        if (files != null) {
+            for (File fi : files) {
+                Noeud node = new Noeud(fi.getName());
+                node.ajouterEnfant(explo(fi));
+                root.ajouterEnfant(root);
+            }
+        }
+        
+        return root;
+    }
+
+    public static void afficherArbre(Noeud racine) {
+        afficherArbre(racine, 0);
+    }
+
+    private static void afficherArbre(Noeud noeud, int niveau) {
+        // Affiche le nœud actuel avec une indentation basée sur le niveau
+        StringBuilder indentation = new StringBuilder();
+        for (int i = 0; i < niveau; i++) {
+            indentation.append("  "); // Deux espaces par niveau pour l'indentation
+        }
+        System.out.println(indentation.toString() + noeud);
+
+        // Appelle récursivement la méthode pour chaque enfant du nœud actuel
+        for (Noeud enfant : noeud.getEnfants()) {
+            afficherArbre(enfant, niveau + 1);
+        }
+    }
+} 

DEV3.2/Florent/TD5/stub/exo3/Chef.java

@@ -0,0 +1,75 @@
+import java.util.ArrayList;
+import java.util.List;
+
+/** feuille du motif composite */
+public class Chef extends Person {
+
+    private List<Person> subalternes = new ArrayList<Person>(); 
+
+    public boolean addSubalterne(Person p){
+        return subalternes.add(p);
+    }
+
+
+    
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Chef(int n){
+        super(n);
+        // d'autres choses peut-être.
+    }
+
+    
+    /** 
+     * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     *
+     */ 
+    public int bestPartyWithoutMe(){
+        int output = 0;
+        for (Person person : subalternes) {
+            output += person.bestParty();
+        }
+        return output;
+    }
+
+    /** 
+     * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     *
+     */ 
+    private int bestPartyWithMe(){
+        int output = getFunFactor();
+        for (Person person : subalternes) {
+            output += person.bestPartyWithoutMe();
+        }
+        return output; 
+    }
+
+    /**
+     *  La meilleure fête est soit sans moi (c'est l'union des meilleures fêtes de mes subalternes). 
+     *  soit c'est la meilleure fête avec moi.
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     *
+     */ 
+    public int bestParty(){
+        int avec,sans;
+        avec = this.bestPartyWithMe();
+        sans = this.bestPartyWithoutMe();
+        System.err.println("avec:"+avec+"\nsans:"+sans);
+        if (avec > sans) {
+            return avec;
+        } else {
+            return sans;
+        }
+    }
+    
+}
+
+

DEV3.2/Florent/TD5/stub/exo3/Exemple.java

@@ -0,0 +1,36 @@
+public class Exemple {
+     public static void main(String[] args) {
+         // bar 2
+         //   foo 5
+         //     titi 4
+         //     tata 4
+         //     toto 6
+         //   tete 6
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         System.out.println(foo.bestParty());
+         System.out.println(foo.bestPartyWithoutMe());
+         
+         Travailleur tete = new Travailleur(6);
+         // System.out.println(tete.bestParty());
+         // System.out.println(tete.bestPartyWithoutMe());
+
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         bar.addSubalterne(tete);
+         System.out.println(bar.bestParty());
+         //System.out.println(bar.bestPartyWithoutMe());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo3/Exemple2.java

@@ -0,0 +1,33 @@
+public class Exemple2 {
+     public static void main(String[] args) {
+         // Exemple inspiré question Thibault B.
+         // 1
+         //   10
+         //       1
+         //         1
+         //           10
+         //              3
+         //              4
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+         
+         System.out.println(g.bestParty());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo3/Exemple3.java

@@ -0,0 +1,43 @@
+public class Exemple3 {
+     public static void main(String[] args) {
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         Travailleur tete = new Travailleur(6);
+         bar.addSubalterne(tete);
+         
+         Chef x = new Chef(2);
+         x.addSubalterne(g);
+         x.addSubalterne(bar);
+         Chef y = new Chef(39);
+         y.addSubalterne(x);
+         
+         System.out.println(y.bestParty());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo3/Person.java

@@ -0,0 +1,44 @@
+
+/** "Les personnes sont soit des chefs, soit des travailleurs" */
+public abstract class  Person{
+    /**
+    * valeur indiquant le niveau de coolitude de la personne
+    */
+    private int funFactor;
+
+    /**
+     * @return  la valeur indiquant le niveau de coolitude de la personne. plus cete valeur est grande, plus la personne contribue à améliorer l'ambiance dans une fête.
+     *
+     */
+    public int getFunFactor(){
+        return this.funFactor;
+    }
+
+    /**
+     * constructeur 
+     *
+     * <b>NB</b>. Cette méthode ne peut pas être appelé directement pour instancier un objet car la classe est abstraite, mais sert dans les constructeurs de classes dérivées.
+     *
+     * @see Travailleur, Chef
+     */
+    // 
+    public Person(int n){
+        if (n < 0)
+            throw new IllegalArgumentException("Le fun facteur est positif ou nul, vous avez proposé " + n);
+        this.funFactor = n;
+    }
+        
+    /** 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     */ 
+    public abstract int bestPartyWithoutMe();
+
+
+    /** 
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     */ 
+    public abstract int bestParty();
+}
+

DEV3.2/Florent/TD5/stub/exo3/Travailleur.java

@@ -0,0 +1,31 @@
+/** feuille du motif composite */
+public class Travailleur extends Person {
+
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Travailleur(int n){
+        super(n);
+    }
+    
+    /** 
+     *
+     * @return fête sans le travailleur
+     */ 
+    public int bestPartyWithoutMe(){
+        return 0;
+    }
+    
+    /**
+     * @return fête avec le travailleur
+     */
+    public int bestParty(){
+        return getFunFactor();
+    }
+    
+    
+}
+
+

DEV3.2/Florent/TD5/stub/exo4/Chef.java

@@ -0,0 +1,89 @@
+import java.util.ArrayList;
+import java.util.List;
+
+/** feuille du motif composite */
+public class Chef extends Person {
+
+    private List<Person> subalternes = new ArrayList<Person>(); 
+    private Integer avec,sans = null;
+
+    public boolean addSubalterne(Person p){
+        return subalternes.add(p);
+    }
+
+
+    
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Chef(int n){
+        super(n);
+        // d'autres choses peut-être.
+    }
+
+    
+    /** 
+     * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     *
+     */ 
+    public int bestPartyWithoutMe(){
+        if (this.sans != null) {
+            return this.sans;
+        }
+        int output = 0;
+        for (Person person : subalternes) {
+            output += person.bestParty();
+        }
+        this.sans = output;
+        return output;
+    }
+
+    /** 
+     * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     *
+     */ 
+    private int bestPartyWithMe(){
+        if (this.avec != null) {
+            return this.avec;
+        }
+        int output = getFunFactor();
+        for (Person person : subalternes) {
+            output += person.bestPartyWithoutMe();
+        }
+        this.avec = output;
+        return output; 
+    }
+
+    /**
+     *  La meilleure fête est soit sans moi (c'est l'union des meilleures fêtes de mes subalternes). 
+     *  soit c'est la meilleure fête avec moi.
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     *
+     */ 
+    public int bestParty(){
+        if (this.avec != null && this.sans != null) {
+            if (this.avec > sans) {
+                return this.avec;
+            } else {
+                return this.sans;
+            }
+        }
+        this.avec = this.bestPartyWithMe();
+        this.sans = this.bestPartyWithoutMe();
+        if (this.avec > this.sans) {
+            return this.avec;
+        } else {
+            return this.sans;
+        }
+        
+    }
+}
+
+

DEV3.2/Florent/TD5/stub/exo4/Exemple.java

@@ -0,0 +1,36 @@
+public class Exemple {
+     public static void main(String[] args) {
+         // bar 2
+         //   foo 5
+         //     titi 4
+         //     tata 4
+         //     toto 6
+         //   tete 6
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         System.out.println(foo.bestParty());
+         System.out.println(foo.bestPartyWithoutMe());
+         
+         Travailleur tete = new Travailleur(6);
+         // System.out.println(tete.bestParty());
+         // System.out.println(tete.bestPartyWithoutMe());
+
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         bar.addSubalterne(tete);
+         System.out.println(bar.bestParty());
+         //System.out.println(bar.bestPartyWithoutMe());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo4/Exemple2.java

@@ -0,0 +1,33 @@
+public class Exemple2 {
+     public static void main(String[] args) {
+         // Exemple inspiré question Thibault B.
+         // 1
+         //   10
+         //       1
+         //         1
+         //           10
+         //              3
+         //              4
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+         
+         System.out.println(g.bestParty());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo4/Exemple3.java

@@ -0,0 +1,43 @@
+public class Exemple3 {
+     public static void main(String[] args) {
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         Travailleur tete = new Travailleur(6);
+         bar.addSubalterne(tete);
+         
+         Chef x = new Chef(2);
+         x.addSubalterne(g);
+         x.addSubalterne(bar);
+         Chef y = new Chef(39);
+         y.addSubalterne(x);
+         
+         System.out.println(y.bestParty());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo4/Person.java

@@ -0,0 +1,44 @@
+
+/** "Les personnes sont soit des chefs, soit des travailleurs" */
+public abstract class  Person{
+    /**
+    * valeur indiquant le niveau de coolitude de la personne
+    */
+    private int funFactor;
+
+    /**
+     * @return  la valeur indiquant le niveau de coolitude de la personne. plus cete valeur est grande, plus la personne contribue à améliorer l'ambiance dans une fête.
+     *
+     */
+    public int getFunFactor(){
+        return this.funFactor;
+    }
+
+    /**
+     * constructeur 
+     *
+     * <b>NB</b>. Cette méthode ne peut pas être appelé directement pour instancier un objet car la classe est abstraite, mais sert dans les constructeurs de classes dérivées.
+     *
+     * @see Travailleur, Chef
+     */
+    // 
+    public Person(int n){
+        if (n < 0)
+            throw new IllegalArgumentException("Le fun facteur est positif ou nul, vous avez proposé " + n);
+        this.funFactor = n;
+    }
+        
+    /** 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     */ 
+    public abstract int bestPartyWithoutMe();
+
+
+    /** 
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     */ 
+    public abstract int bestParty();
+}
+

DEV3.2/Florent/TD5/stub/exo4/Travailleur.java

@@ -0,0 +1,31 @@
+/** feuille du motif composite */
+public class Travailleur extends Person {
+
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Travailleur(int n){
+        super(n);
+    }
+    
+    /** 
+     *
+     * @return fête sans le travailleur
+     */ 
+    public int bestPartyWithoutMe(){
+        return 0;
+    }
+    
+    /**
+     * @return fête avec le travailleur
+     */
+    public int bestParty(){
+        return getFunFactor();
+    }
+    
+    
+}
+
+

DEV3.2/Florent/TD5/stub/exo5/Chef.java

@@ -0,0 +1,48 @@
+import java.util.LinkedHashSet;
+import java.util.Objects;
+
+/** feuille du motif composite */
+public class Chef extends Person {
+
+
+    public boolean addSubalterne(Person p){
+        
+    }
+
+
+    
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Chef(int n){
+        super(n);
+        // d'autres choses peut-être.
+    }
+
+    
+    /** 
+     * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     *
+     */ 
+    public int bestPartyWithoutMe(){
+        // to do
+    }
+
+    /**
+     *  La meilleure fête est soit sans moi (c'est l'union des meilleures fêtes de mes subalternes). 
+     *  soit c'est la meilleure fête avec moi.
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     *
+     */ 
+    public int bestParty(){
+        // to do
+    }
+    
+}
+
+

DEV3.2/Florent/TD5/stub/exo5/Exemple.java

@@ -0,0 +1,36 @@
+public class Exemple {
+     public static void main(String[] args) {
+         // bar 2
+         //   foo 5
+         //     titi 4
+         //     tata 4
+         //     toto 6
+         //   tete 6
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         System.out.println(foo.bestParty());
+         System.out.println(foo.bestPartyWithoutMe());
+         
+         Travailleur tete = new Travailleur(6);
+         // System.out.println(tete.bestParty());
+         // System.out.println(tete.bestPartyWithoutMe());
+
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         bar.addSubalterne(tete);
+         System.out.println(bar.bestParty());
+         //System.out.println(bar.bestPartyWithoutMe());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo5/Exemple2.java

@@ -0,0 +1,33 @@
+public class Exemple2 {
+     public static void main(String[] args) {
+         // Exemple inspiré question Thibault B.
+         // 1
+         //   10
+         //       1
+         //         1
+         //           10
+         //              3
+         //              4
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+         
+         System.out.println(g.bestParty());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo5/Exemple3.java

@@ -0,0 +1,43 @@
+public class Exemple3 {
+     public static void main(String[] args) {
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         Travailleur tete = new Travailleur(6);
+         bar.addSubalterne(tete);
+         
+         Chef x = new Chef(2);
+         x.addSubalterne(g);
+         x.addSubalterne(bar);
+         Chef y = new Chef(39);
+         y.addSubalterne(x);
+         
+         System.out.println(y.bestParty());
+     }
+    
+}
+
+
+
+

DEV3.2/Florent/TD5/stub/exo5/Person.java

@@ -0,0 +1,44 @@
+
+/** "Les personnes sont soit des chefs, soit des travailleurs" */
+public abstract class  Person{
+    /**
+    * valeur indiquant le niveau de coolitude de la personne
+    */
+    private int funFactor;
+
+    /**
+     * @return  la valeur indiquant le niveau de coolitude de la personne. plus cete valeur est grande, plus la personne contribue à améliorer l'ambiance dans une fête.
+     *
+     */
+    public int getFunFactor(){
+        return this.funFactor;
+    }
+
+    /**
+     * constructeur 
+     *
+     * <b>NB</b>. Cette méthode ne peut pas être appelé directement pour instancier un objet car la classe est abstraite, mais sert dans les constructeurs de classes dérivées.
+     *
+     * @see Travailleur, Chef
+     */
+    // 
+    public Person(int n){
+        if (n < 0)
+            throw new IllegalArgumentException("Le fun facteur est positif ou nul, vous avez proposé " + n);
+        this.funFactor = n;
+    }
+        
+    /** 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     */ 
+    public abstract int bestPartyWithoutMe();
+
+
+    /** 
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     */ 
+    public abstract int bestParty();
+}
+

DEV3.2/Florent/TD5/stub/exo5/Travailleur.java

@@ -0,0 +1,31 @@
+/** feuille du motif composite */
+public class Travailleur extends Person {
+
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Travailleur(int n){
+        super(n);
+    }
+    
+    /** 
+     *
+     * @return fête sans le travailleur
+     */ 
+    public int bestPartyWithoutMe(){
+        // return null;
+    }
+    
+    /**
+     * @return fête avec le travailleur
+     */
+    public int bestParty(){
+        // return null;
+    }
+    
+    
+}
+
+

DEV3.2/Listes/Luminance/src/forme.java

@@ -0,0 +1,15 @@
+import java.awt.*;
+
+public class forme {
+    public static void parallelogramme(Graphics g, int x, int y, Color c)
+    {
+        int [] xP = {x+0, x+50, x+100, x+50};
+        int [] yP = {y+0, y+100, y+100, y+0};
+        //Polygon p = new Polygon();
+        g.setColor(Color.BLACK);
+        g.drawPolygon(xP,yP,4);
+        g.setColor(c);
+        g.fillPolygon(xP,yP,4);
+    }
+    
+}

DEV3.2/Listes/Luminance/src/main.java

@@ -0,0 +1,41 @@
+import java.awt.Color;
+import java.awt.Graphics;
+import java.util.ArrayList;
+import java.util.List;
+import javax.swing.*;
+import java.util.Random;
+
+class main extends JPanel 
+{
+    public void paintComponent(Graphics G) 
+    {
+        Random rand = new Random();
+        int x = 50;
+        int y = 50;
+        List<Color> couleur = new ArrayList<Color> ();
+        for (int i = 0; i < 10; i++) 
+        {
+            couleur.add(i,new Color(rand.nextInt(255),rand.nextInt(255),rand.nextInt(255)));
+        }
+
+        for (int i = 0; i < couleur.size(); i++) {
+            forme.parallelogramme(G, x, y, couleur.get(i));  
+            x+=60;
+        }
+        
+        //Polygon p = new Polygon();
+        //g.fillPolygon(p);
+    }
+    public static void main( String args[] ) 
+    {
+        JFrame frame = new JFrame();
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.setBackground(Color.white);
+        frame.setSize(750, 250);
+
+        main panel = new main();
+
+        frame.add(panel);
+        frame.setVisible(true);      
+    }
+}

DEV3.2/Listes/test/src/listes.java

@@ -0,0 +1,22 @@
+import java.util.ArrayList;
+
+public class listes {
+    public static void main(String[] args)
+    {
+        ArrayList<Integer> l1 = new ArrayList<Integer>();
+        l1.add(1); 
+        ArrayList<Float> l2 = new ArrayList<Float>();
+        l2.add(2.5654546f);
+        ArrayList<Number> l3 = new ArrayList<Number>();
+        l3.add(1);
+        l3.add(2.5654546f);
+        l3.add(646L);
+        
+        l3.addAll(l2);
+        
+
+        for (int i = 0; i < l3.size(); i++) {
+            System.out.println(l3.get(i));
+        }
+    }
+}

DEV3.2/Piles/Arithmetique/src/arithm.java

@@ -0,0 +1,44 @@
+import java.util.Deque;
+import java.util.LinkedList;
+
+public class arithm {
+    public static void main(String[] args) {
+        Deque<Object> pile = new LinkedList<>();
+        Object x;
+        int a,b;
+        for (int i = 0; i < args.length; i++) 
+        {
+            x = args[i];
+            if (x == "+" || x == "-" || x == "/" || x == "*" ) 
+            {
+                switch (x) {
+                    case "+":
+                        a = (Integer) pile.pop();
+                        b = (Integer) pile.pop();
+                        pile.add(a+b);
+                        break;
+                    case "-":
+                        a = (Integer) pile.pop();
+                        b = (Integer) pile.pop();
+                        pile.add(a-b);
+                        break;
+                    case "/":
+                        a = (Integer) pile.pop();
+                        b = (Integer) pile.pop();
+                        pile.add(a/b);
+                        break;
+                    case "*":
+                        a = (Integer) pile.pop();
+                        b = (Integer) pile.pop();
+                        pile.add(a*b);
+                        break;
+                }    
+            }  
+            else
+            {
+                pile.add(x);
+            }  
+        }
+        System.out.println("="+pile.pop());
+    }
+}

DEV3.2/Recursivité/src/appel.java

@@ -0,0 +1,20 @@
+public class appel {
+
+    private static int factorielle(int x)
+    {
+        if( x > 1)
+        {
+            return x*factorielle(x-1);
+        }
+        else
+        {
+            return 1;
+        }
+    }
+
+    public static void main(String[] args) {
+
+        int y = factorielle(Integer.parseInt(args[0]));
+        System.out.println(y);
+    }
+}

DEV3.2/Tableaux/src/tab.java

@@ -0,0 +1,5 @@
+public class tab {
+    public static void main(String[] args) {
+        
+    }
+}

Junit4Exemples/AssertTests.java

@@ -0,0 +1,106 @@
+/**
+   Il y a en fait pleins d'assertions possibles.
+
+   voici un exemple faisant un petit tour de ce qui est possible que j'ai pris ici.
+   https://github.com/junit-team/junit4/wiki/Assertions
+
+   NB. hamcrest est un projet maintenant intégré à junit
+   (c'est un anagrame de matchers)
+
+ */
+
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.both;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.everyItem;
+import static org.hamcrest.CoreMatchers.hasItems;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.CoreMatchers.sameInstance;
+import static org.hamcrest.CoreMatchers.startsWith;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+
+import org.hamcrest.core.CombinableMatcher;
+import org.junit.Test;
+
+public class AssertTests {
+  @Test
+  public void testAssertArrayEquals() {
+    byte[] expected = "trial".getBytes();
+    byte[] actual = "trial".getBytes();
+    assertArrayEquals("failure - byte arrays not same", expected, actual);
+  }
+
+  @Test
+  public void testAssertEquals() {
+    assertEquals("failure - strings are not equal", "text", "text");
+  }
+
+  @Test
+  public void testAssertFalse() {
+    assertFalse("failure - should be false", false);
+  }
+
+  @Test
+  public void testAssertNotNull() {
+    assertNotNull("should not be null", new Object());
+  }
+
+  @Test
+  public void testAssertNotSame() {
+    assertNotSame("should not be same Object", new Object(), new Object());
+  }
+
+  @Test
+  public void testAssertNull() {
+    assertNull("should be null", null);
+  }
+
+  @Test
+  public void testAssertSame() {
+    Integer aNumber = Integer.valueOf(768);
+    assertSame("should be same", aNumber, aNumber);
+  }
+
+  // JUnit Matchers assertThat
+  @Test
+  public void testAssertThatBothContainsString() {
+    assertThat("albumen", both(containsString("a")).and(containsString("b")));
+  }
+
+  @Test
+  public void testAssertThatHasItems() {
+    assertThat(Arrays.asList("one", "two", "three"), hasItems("one", "three"));
+  }
+
+  @Test
+  public void testAssertThatEveryItemContainsString() {
+    assertThat(Arrays.asList(new String[] { "fun", "ban", "net" }), everyItem(containsString("n")));
+  }
+
+  // Core Hamcrest Matchers with assertThat
+  @Test
+  public void testAssertThatHamcrestCoreMatchers() {
+    assertThat("good", allOf(equalTo("good"), startsWith("good")));
+    assertThat("good", not(allOf(equalTo("bad"), equalTo("good"))));
+    assertThat("good", anyOf(equalTo("bad"), equalTo("good")));
+    assertThat(7, not(CombinableMatcher.<Integer> either(equalTo(3)).or(equalTo(4))));
+    assertThat(new Object(), not(sameInstance(new Object())));
+  }
+
+  @Test
+  public void testAssertTrue() {
+    assertTrue("failure - should be true", true);
+  }
+}

Junit4Exemples/Calculator.java

@@ -0,0 +1,30 @@
+
+/**
+   Calculator est une classe offrant une seule méthode qui évalue une somme, donnée sous la forme d'une chaîne de caractère listant des opérandes séparées par des +
+
+*/
+
+public class Calculator {
+
+    /**
+       somme les opérandes passées sous forme d'une chaîne de caractères et retourne le résultat sous forme d'entier.
+       @param expression : chaîne de caractères ("nombres" séparés par des + sans espaces), par exemple "42+3" ou encore "-42+42" (le moins unaire est autorisé).
+                           ici nombre est à comprendre au sens de  parseInt(java.lang.String)
+       @throws NumberFormatException : si l'expression n'est pas dans ce format (par exemple "x+2" ou " 1 +2" -- il y a des espaces -- ou encore "9999999990").
+     */    
+    public int evaluate(String expression) {
+        int sum = 0;
+        for (String summand: expression.split("\\+"))
+            sum += Integer.valueOf(summand);
+        return sum;
+    }
+
+    /**
+       Pour appeller cette super méthode depuis la ligne de commande (on ne regarde que le premier argument, les autres sont ignorés).
+ 
+     */   
+    public static void main(String[] args) {
+        Calculator calculator = new Calculator();
+        System.out.println(calculator.evaluate(args[0]));
+    }
+}

Junit4Exemples/CalculatorTest0.java

@@ -0,0 +1,30 @@
+import static org.junit.Assert.assertEquals; // import static : une facilité offerte par java5
+import org.junit.Test;
+
+/**
+  CalculatorTest0 est un premier exemple de test pour la classe Calculator utilisant junit4
+  Assert, ou comment vérifier qu'une méthode donne un résultat correct?
+
+  Remarque en passant, pour tester en ligne de commande (une fois les classes compilées), il faut faire
+  $java org.junit.runner.JUnitCore CalculatorTest0
+
+  Remarque, comme expliqué dans la doc de org.junit.runner.JUnitCore
+JUnitCore is a *facade* for running tests. It supports running JUnit 4 tests, JUnit 3.8.x tests, and mixtures. To run tests from the command line, run java org.junit.runner.JUnitCore TestClass1 TestClass2
+
+  Oh le joli design pattern. C'est cadeau.
+ */
+
+public class CalculatorTest0 {
+
+    
+    // un test pour Junit4 c'est une méthode avec l'annotation suivante devant la méthode.
+    @Test
+    public void evaluatesGoodExpression() {
+        Calculator calculator = new Calculator();
+        int sum = calculator.evaluate("1+2+3");
+        // 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)
+        assertEquals(6, sum);
+    }
+
+
+}

Junit4Exemples/CalculatorTest1.java

@@ -0,0 +1,18 @@
+import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+
+/**
+  CalculatorTest1 est un exemple de test pour la classe Calculator utilisant junit4.
+  Comment vérifier qu'on lance bien une exception?
+ */
+
+public class CalculatorTest1 {
+
+    
+    // un test pour Junit4 qui cherche à vérifier qu'il y a bien une exception
+    @Test(expected = NumberFormatException.class) 
+    public void doesNotEvaluateBadExpression() {
+        Calculator calculator = new Calculator();
+        int sum = calculator.evaluate("1 +2+3");//notez l'espace qui va génèrez une exception
+    }
+}

Junit4Exemples/CalculatorTest2.java

@@ -0,0 +1,48 @@
+import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+
+import org.junit.BeforeClass; // ne pas oublie de charger le fait qu'on veut l'annotation @BeforeClass
+import org.junit.AfterClass; 
+
+/**
+  
+   CalculatorTest2 est un exemple de test pour la classe Calculator utilisant junit4
+   Il réunit en fait les deux tests des 2 classes précédentes dans une seule classe.
+
+   Typiquement on a en effet tous les tests simples portant sur une classe "métier" regroupée dans une classe de test correspondante.
+   Avec les annotations, on peut factoriser des choses concernant tous ces tests. 
+
+ */
+
+public class CalculatorTest2 {
+    static Calculator calculator;
+
+    // On peut si on le souhaite faire un traitement avant tous les tests (typiquement on fait quelque chose de cher comme se connecter à une base de données, ici j'économise une instance de Calculator (on s'en moque un peu pour être honnête). 
+    @BeforeClass
+    public static void setUp() {
+        System.out.println("Avant tous les tests");
+        calculator = new Calculator();
+    }
+    
+    @Test
+    public void evaluatesGoodExpression() {
+        System.out.println("Test evaluation bonne expression");
+        int sum = calculator.evaluate("1+2+3");
+        assertEquals(6, sum);
+    }
+
+
+    @Test(expected = NumberFormatException.class) 
+    public void doesNotEvaluateBadExpression() {
+        System.out.println("Test evaluation mauvaise expression");
+        int sum = calculator.evaluate("1 +2+3");
+    }
+    
+    // On peut si on le souhaite faire un traitement après tous les tests (typiquement on fait quelque chose de cher comme se connecter à une base de données, ici j'économise une instance de Calculator (on s'en moque un peu pour être honnête). 
+    @AfterClass
+    public static void tearDown() {
+        System.out.println("Après tous les Test");
+        calculator = null;
+    }
+
+}

Junit4Exemples/CalculatorTest3.java

@@ -0,0 +1,20 @@
+import static org.junit.Assert.assertEquals; 
+import org.junit.Test;
+
+/**
+  CalculatorTest3 est un exemple de test pour la classe Calculator utilisant junit4 qui est volontairement non satisfait
+
+ */
+
+public class CalculatorTest3 {
+
+    
+    @Test
+    public void evaluatesGoodExpression() throws Exception{
+        Calculator calculator = new Calculator();
+        int sum = calculator.evaluate("1+2+3");
+        assertEquals(42, sum);
+    }
+
+
+}