Cours d'Informatique
par Jacques LAFORGUE

Exercice08_InterfaceVivants2

Retour

Télécharger

EnonceExercice08.pdf

            compil.bat 
mkdir bin del /f /s /q bin\*.class javac -d bin -classpath "src" src/fr/cnam/programme/*.java pause       run.bat 
cd bin java -classpath "." fr.cnam.programme.Exercice08 pause       src
         fr
            cnam
               etrevivant
                  Cafard.java 
package fr.cnam.etrevivant; import java.util.Random; import fr.cnam.multiagent.*; // Classe de définition d'un cafard. // Un cafard a qu'une vie (hérite de EtreVivantMultiple) //  mais il est difficile à tuer. Il a une  //  probabilité de mourir de 1/10 //  public class Cafard extends EtreVivantMultiple {     private Random rnd;    // La fonction aléatoire      // Constructeur     public Cafard(String nom)     {         super(nom);         this.rnd = new Random();         genre = "Cafard";     }     // On surcharge la méthode "tuer" de la classe héritée afin     //   de spécialiser le traitement "tuer".     //     // Si le cafard n'est pas mort alors     //  on décrémente son nombre de vie que si aléatoirement      //   on tire le chiffre 9 entre 0 et 9 (proba = 1/10)     //     public void tuer()     {         if (this.nbVies>=1)              {                 int n = this.rnd.nextInt(10);                 if (n==9)                     this.nbVies--;             }     } }                   Chat.java 
package fr.cnam.etrevivant; import fr.cnam.multiagent.*; // Classe de définition d'un Chien. // Un chien a un nombre max de vie de 7. //  // La classe hérite de la classe EtreVivantMultiple // public class Chat extends EtreVivantMultiple {     // Constructeur     public Chat(String nom)     {         super(nom);         maxVies = 7;         nbVies = maxVies;         genre = "Chat";     } }                   Chien.java 
package fr.cnam.etrevivant; import fr.cnam.multiagent.*; // Classe de définition d'un Chien. // Un chien a un nombre max de vie de 2. //  // La classe hérite de la classe EtreVivantMultiple // public class Chien extends EtreVivantMultiple {     // Constructeur     public Chien(String nom)     {         super(nom);         maxVies = 2;         nbVies = maxVies;         genre = "Chien";     } }                   Dieu.java 
package fr.cnam.etrevivant; import fr.cnam.multiagent.*; // Classe de définition d'un Dieu. // Un Dieu est immortel et ne peut être tué. //  // La classe hérite de la classe EtreVivant qui implémente une partie //   de l'interface Agent. Elle doit donc implémenter le reste de l'interface // public class Dieu extends EtreVivant {     // Constructeur     public Dieu(String nom)     {         super(nom);         genre = "Dieu";     }     // ========== Implémentation de l'interface Agent     // ======================================================     // Un Dieu est toujours vivant     public boolean estVivant()     {         return true;     }     // Le nombre de vie d'un Dieu est 1     public int nbVies()     {         return 1;     }     // Un dieu ne peut être tué     public void tuer()     {     }     // Un dieu ne peut être ressuscité car il ne peut être tué     public void ressusciter()     {     } }                   EtreVivant.java 
package fr.cnam.etrevivant; import fr.cnam.multiagent.Agent; // La classe EtreVivant est la classe racine de notre conception. // Elle regroupe les attributs communs à tous les êtres vivants. // La classe est asbtraite car créer une instance de cette classe n'a // pas de sens et parcequ'elle n'implémente qu'uen partie de l'interface // Agent. // public abstract class EtreVivant implements Agent {     private String nom;   // Le nom de l'etre vivant     protected String genre; // La nature de l'etre vivant (ex: Chat, Humain, ...)     // Cet atttibut est protected car les classes héritantes (Chat, Humain, ...)      //  renseigne cet attribut     // Constructeur (appelé depuis les classes héritantes     public EtreVivant(String nom)     {         this.nom   = nom;         this.genre = "Inconnu"; // Valeur par défaut.         // C'est les classes réeles qui surchargeront cet attribut avec         //  la valeur correspondante     }     // Le genre     public String genre()     {         return genre;     }     // Le nom      public String nom()     {         return nom;     }      }                   EtreVivantMultiple.java 
package fr.cnam.etrevivant; // Cette classe définit les êtres vivants qui ont un nombre de vies //   et un nombre max de vie. // Elle hérite de la classe EtreVivant. // Les classes Chat, Chien et Cafard héritent de cette classe. // public abstract class EtreVivantMultiple extends EtreVivant {     protected int    nbVies;    // Le nombre de vie courant     protected int    maxVies;   // Le nombre max de vie     // Constructeur     public EtreVivantMultiple(String nom)     {         super(nom);         nbVies = 1;  // Par defaut (cas de la classe Cafard)         maxVies = 1; // Par defaut (cas de la classe Cafard)     }     // ========== Implémentation de l'interface Agent     // ======================================================     // Un chat est vivant si son nombre de vie est >=1     public boolean estVivant()     {         if (this.nbVies>=1)             return true;         else             return false;     }     // Retourne le nombre de vie     public int nbVies()     {         return nbVies;     }     // Tuer un chat consiste à décrémenter son nombre de vie     public void tuer()     {         if (this.nbVies>=1) this.nbVies--;     }     // Ressusciter un chat consiste a lui redonner son nombre max de vie      public void ressusciter()     {         this.nbVies = this.maxVies;     } }                   Humain.java 
package fr.cnam.etrevivant; import fr.cnam.multiagent.*; // Classe de définition d'un Humain. // Un humain meurt dès que on tente de le tuer. //  // La classe hérite de la classe EtreVivant qui implémente une partie //   de l'interface Agent. Elle doit donc implémenter le reste de l'interface // public class Humain extends EtreVivant {     private boolean vivant;  // True si vivant sinon false     // Constructeur     public Humain(String nom)     {         super(nom);         genre = "Humain";         this.vivant = true;     }     // ========== Implémentation de l'interface Agent     // ======================================================          // Humain est vivant s'il n'a pas été tué     public boolean estVivant()     {         return this.vivant;     }     // Un humain a 1 vie s'il est vivant)     public int nbVies()     {         if (this.vivant) return 1;         else return 0;     }     // Tuer un humain      public void tuer()     {         this.vivant=false;     }     // Ressusciter un humain     public void ressusciter()     {         this.vivant = true;     } }                multiagent
                  Agent.java 
package fr.cnam.multiagent; // Interface de description d'un etre vivant appelé Agent // public interface Agent {     public boolean estVivant();     public int nbVies();     public void tuer();     public void ressusciter();     public String genre();     public String nom(); }                   Population.java 
package fr.cnam.multiagent; import java.util.*; import fr.cnam.multiagent.*; // Cette classe gère une collection d'être vivants // et réalise des traitements sur l'ensemble de ces être vivants. // Ces êtres vivants sont des "agents" c'est à dire tout objet //  JAVA qui implémente l'interface Agent // public class Population {     private ArrayList<Agent> etres;  // La collection d'êtres     // Le constructeur     public Population()     {         this.etres = new ArrayList<Agent>();     }     // Methode qui ajoute un nouvel agent     public void ajouterAgent(Agent a)     {         this.etres.add(a);     }     // retourne les êtres de la collection qui sont vivants     public ArrayList<Agent> etresVivants()     {         ArrayList<Agent> l = new ArrayList<Agent>();         for(Agent a : this.etres)             if (a.estVivant())                 l.add(a);         return l;     }     // retourne tous les êtres de la collection     public ArrayList<Agent> getEtres()     {         return this.etres;     }     // Tente de tuer chacun des êtres de la collection     public void tuerTous()     {         for(Agent a : this.etres) a.tuer();     }     // Ressuscite tous les être de la collection     public void ressusciterTous()     {         for(Agent a : this.etres) a.ressusciter();     }     // Trie par les êtres de la collection par ordre de vivant ou mort     //   puis par ordre alphabétique sur le genre     public void trier()     {         Collections.sort(this.etres,new ComparerAgent());     }          // Affiche les êtres de la collection (les trie aussi)     public void afficher()     {         this.trier();         for(Agent a : this.etres)             {                 String genre = a.genre();                 String nom = a.nom();                 int vies = a.nbVies();                 String vivant;                 if (a.estVivant()) vivant="vivant";                 else vivant="mort";                 System.out.println(String.format("%20s %20s %6s (%2d)",genre,nom,vivant,vies));             }         System.out.println("-----------------------------------");     } } // Classe interne qui définit le critère de tri des agents de la collection // class ComparerAgent implements Comparator<Agent>  {      // Méthode de l'interface Comparator     //     public int compare(Agent a1, Agent a2)     {         // Les vivants en premier         if ( (a1.estVivant()) && (! (a2.estVivant())) )             return -1;                  // Puis les morts         if ( (a2.estVivant()) && (! (a1.estVivant())) )             return 1;         // Puis par genre         return (a1.genre().compareTo(a2.genre()));     } }                 programme
                  Exercice08.java 
package fr.cnam.programme; //Exercice d'application de l'interface : une gestion des êtres vivants. import fr.cnam.multiagent.*; import fr.cnam.etrevivant.*; // Cette classe permet de tester la classe Population qui gère les êtres vivants //  de notre univers // // Ce programme ne change pas par rapport à celui de l'exercice 07 // public class Exercice08 {     public static void main(String... args)     {         // Création de la poulation         Population pop = new Population();         // Ajout d'êtres dans la population         pop.ajouterAgent(new Dieu("Zeus"));         pop.ajouterAgent(new Humain("moi"));         pop.ajouterAgent(new Dieu("Chronos"));         pop.ajouterAgent(new Humain("lui"));         pop.ajouterAgent(new Chien("kador"));         pop.ajouterAgent(new Cafard("berk"));         Humain h = new Humain("zurglob");         pop.ajouterAgent(h);         pop.ajouterAgent(new Chat("miaou"));         pop.afficher();         // Test          System.out.println("Tuer tous (une fois)");         pop.tuerTous();         pop.afficher();         System.out.println("Tuer tous (une fois)");         pop.tuerTous();         pop.afficher();                  System.out.println("Ressusciter tous");         pop.ressusciterTous();         pop.afficher();         // Ce code permet de tuer un cafard et voir au bout de combien de         // tentative il est mort         // On fait le test su 10 cafards         //         System.out.println("Etude statistique pour tuer un cafard");         for(int i=1;i<=10;i++)             {                 Cafard c = new Cafard("cobaye");                 int n=0;                 while (c.estVivant())                     {                         c.tuer();                         n++;                     }                 System.out.println(String.format("Tuer en %3d coups",n));             }     } }       Execution.txt 
Exercice07_run d:\jacques\CNAM\SITE\SITE_NFA001-002\Exercices\bin>cd Exercice07  d:\jacques\CNAM\SITE\SITE_NFA001-002\Exercices\bin\Exercice07>java -classpath "." Exercice07                Cafard                 berk vivant ( 1)                 Chat                miaou vivant ( 7)                Chien                kador vivant ( 2)                 Dieu                 Zeus vivant ( 1)                 Dieu              Chronos vivant ( 1)               Humain                  moi vivant ( 1)               Humain                  lui vivant ( 1)               Humain              zurglob vivant ( 1) ----------------------------------- Tuer tous (une fois)               Cafard                 berk vivant ( 1)                 Chat                miaou vivant ( 6)                Chien                kador vivant ( 1)                 Dieu                 Zeus vivant ( 1)                 Dieu              Chronos vivant ( 1)               Humain                  moi   mort ( 0)               Humain                  lui   mort ( 0)               Humain              zurglob   mort ( 0) ----------------------------------- Tuer tous (une fois)               Cafard                 berk vivant ( 1)                 Chat                miaou vivant ( 5)                 Dieu                 Zeus vivant ( 1)                 Dieu              Chronos vivant ( 1)                Chien                kador   mort ( 0)               Humain                  moi   mort ( 0)               Humain                  lui   mort ( 0)               Humain              zurglob   mort ( 0) ----------------------------------- Ressusciter tous               Cafard                 berk vivant ( 1)                 Chat                miaou vivant ( 7)                Chien                kador vivant ( 2)                 Dieu                 Zeus vivant ( 1)                 Dieu              Chronos vivant ( 1)               Humain                  moi vivant ( 1)               Humain                  lui vivant ( 1)               Humain              zurglob vivant ( 1) ----------------------------------- Etude statistique pour tuer un cafard Tuer en   6 coups Tuer en   2 coups Tuer en   1 coups Tuer en  14 coups Tuer en   1 coups Tuer en  19 coups Tuer en   5 coups Tuer en   4 coups Tuer en   4 coups Tuer en  26 coups