pourchot/DEV
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

20 Septembre

Browse Source
This commit is contained in:
Adrian POURCHOT
2023-09-20 11:29:37 +02:00
parent 2da42fcdcc
commit 7f2d998310
28 changed files with 804 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
DEV2.1/TP8/v0/Carte.class Normal file
View File

Binary file not shown.

150
DEV2.1/TP8/v0/Carte.java Normal file
View File

@@ -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);
}
}

BIN
DEV2.1/TP8/v0/EnsembleCarte.class Normal file
View File

Binary file not shown.

142
DEV2.1/TP8/v0/EnsembleCarte.java Normal file
View File

@@ -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());
// }
}

BIN
DEV2.1/TP8/v0/Joueur.class Normal file
View File

Binary file not shown.

95
DEV2.1/TP8/v0/Joueur.java Normal file
View File

@@ -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);
}
}

BIN
DEV2.1/TP8/v0/Table.class Normal file
View File

Binary file not shown.

123
DEV2.1/TP8/v0/Table.java Normal file
View File

@@ -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);
}
}

85
DEV2.1/TP8/v0/TestCarte.java Normal file
View File

@@ -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);
}
}