Cours CNAM par J. Laforgue

Exercice07_InterfaceVivants

Retour

Télécharger

Exercice d'application de l'interface : une gestion des êtres vivants.

EnonceExercice07.pdf

      README.txt
            compil.bat
      run.bat
      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 mais il est difficile à tuer. Il a une 
//  probabilité de mourir de 1/10
// 
// La classe implémente l'interface Agent
//
public class Cafard implements Agent
{
    private String nom;    // Un cafard a un nom
    private int    nbVies; // Le nombre de vie d'un cafard
    private Random rnd;    // La fonction aléatoire

// Constructeur qui initialise notamment le nombre de vie a 1
    public Cafard(String nom)
    {
        this.nom=nom;
        this.nbVies = 1;
        this.rnd = new Random();
    }

// ========== Implémentation de l'interface Agent
    // ======================================================

// Un cafard 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;
    }

// 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 = Math.abs(this.rnd.nextInt())%10;
                int n = this.rnd.nextInt(10);
                //System.out.print(n + " ");
                //System.out.println();
                if (n==9)
                    this.nbVies--;
            }
    }

// Ressusciter un cafard
    public void ressusciter()
    {
        this.nbVies=1;
    }

// Le genre du cafard
    public String genre()
    {
        return "Cafard";
    }

//Le nom du cafard
    public String nom()
    {
        return nom;
    }

}

Chat.java

package fr.cnam.etrevivant;

import fr.cnam.multiagent.*;

// Classe de définition d'un Chat.
// Un chat a un nombre max de vie de 7.
// 
// La classe implémente l'interface Agent
//
public class Chat implements Agent
{
    private String nom;       // Un chat a un nom
    private int    nbVies;    // Le nombre de vie courant
    private int    maxVies;   // Le nombre max de vie d'un chat

// Constructeur
    public Chat(String nom)
    {
        this.nom=nom;
        this.maxVies = 7;
        this.nbVies = this.maxVies;
    }

// ========== 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;
    }
    
    // Le genre
    public String genre()
    {
        return "Chat";
    }

// Le nom
    public String nom()
    {
        return nom;
    }

}

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 implémente l'interface Agent
//
public class Chien implements Agent
{
    private String nom;     // Un chien a un nom
    private int    nbVies;  // Le nombre de vie courant
    private int    maxVies; // Le nombre max de vie d'un chien

// Constructeur
    public Chien(String nom)
    {
        this.nom=nom;
        this.maxVies = 2;
        this.nbVies = this.maxVies;
    }

// ========== Implémentation de l'interface Agent
    // ======================================================

// Un chien 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 chien consiste à décrémenter son nombre de vie
    public void tuer()
    {
        if (this.nbVies>=1) this.nbVies--;
    }

// Ressusciter un chien consiste a lui redonner son nombre max de vie 
    public void ressusciter()
    {
        this.nbVies = this.maxVies;
    }

// Le genre
    public String genre()
    {
        return "Chien";
    }

// Le nom
    public String nom()
    {
        return nom;
    }

}

Dieu.java

package fr.cnam.etrevivant;

import fr.cnam.multiagent.*;

// Classe de définition d'un Dieu.
// Un Dieu est immortel. Son nombre de vie est égal à 1 mais ne peut
// être tué.
// 
// La classe implémente l'interface Agent
//
public class Dieu implements Agent
{
    private String nom;  // Le nom du Dieu

// Constructeur
    public Dieu(String nom)
    {
        this.nom=nom;
    }

// ========== 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()
    {
    }

// Le genre
    public String genre()
    {
        return "Dieu";
    }

// Le nom du dieu
    public String nom()
    {
        return nom;
    }

}

Humain.java

package fr.cnam.etrevivant;

import fr.cnam.multiagent.*;

// Classe de définition d'un Humain.
// Un humain n'a qu'une vie et meurt dès que on tente de le tuer.
// 
// La classe implémente l'interface Agent
//
public class Humain implements Agent
{
    private String nom;      // Un humain a un nom
    private boolean vivant;  // True si vivant sinon false

// Constructeur
    public Humain(String nom)
    {
        this.nom=nom;
        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;
    }

// Le genre
    public String genre()
    {
        return "Humain";
    }

// Le nom d'un humain
    public String nom()
    {
        return nom;
    }
}

               multiagent
                  Agent.java
                  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
Exercice07.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
//
public class Exercice07
{
    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

Cours d'Informatique par Jacques LAFORGUE

Retour

Télécharger

Cours d'Informatique
par Jacques LAFORGUE