Partage

[Exo] Javaquarium

04-2010 : Ca parlait forcément de poissons

31 mars 2010 à 22:38:21

Avant toute chose, je n'ai pas encore fait la correction.
Cet exercice est donc sous réserve de coquilles et de sauts de difficulté imprévus !


Exercice Java, 04-2010 : Le Javaquarium


Thèmes


Parce qu'on est en Java, et que c'est super horriblement vraiment très très important en Java, le thème principal de cet exercice est les objets. Et puis les poissons, mais ça c'est parce que c'est l'exo d'avril.
N'ayez pas peur !
L'énoncé est assez long, mais tentez l'exercice : tout ce blabla se code en peu de lignes.


Comment ça marche ?


Vous lisez l'énoncé et vous répondez à l'exercice.
Là, deux manières de faire :
  • Soit vous postez votre code fonctionnel ci-dessous et profitez des conseils des autres membres.
  • Soit vous m'envoyez un MP, et je vous donnerai une correction.

Sachant que je détaillerai moins des corrections personnelles que ce qui peut profiter à tout le monde.
Pas la peine d'envoyer n'importe quoi pour avoir une correction, surtout par MP.
C'est pour vous que vous travaillez, l'exercice n'a d'intérêt que si vous tentez de le faire.


Un peu d'enrobage...


Monsieur Shingshan, aquariophile accompli, vous demande de faire un programme de simulation pour son prochain aquarium : il compte y mettre un certain nombre d'espèces de poissons rares et chères, et n'a pas envie qu'au bout de deux mois son précieux investissement se transforme en désert...

Votre mission (et vous l'acceptez) : lui concevoir un programme qui fera la chose suivante :

Citation : Le cahier des charges

Je devrai pouvoir mettre des poissons et des plantes dans mon aquarium virtuel, et faire passer le temps pour savoir si tout se passe bien.


Traduit en geek / développeur java, ça veut dire qu'il faudra un programme en deux phases :
  1. L'initialisation : les poissons et les algues sont ajoutés dans l'aquarium
  2. Le temps qui passe : on résous les actions d'un tour, et on fait un rapport de la situation.

On est partis ?
On y va !

Partie 1 : Peuplons notre Javaquarium


Exercice 1.1 : Remplissage de l'aquarium


Il s'agit de la base du programme : avoir un aquarium rempli.
L'aquarium contient des poissons et des algues, un nombre quelconque de chaque.
L'algue ne fait rien : c'est une algue, elle se contente d'exister ou non.
Le poisson, lui, a un nom (monsieur Shingshan aime ses poissons et leur donne un nom à chacun) et un sexe (mâle ou femelle).
L'aquarium a une méthode une méthode pour ajouter un poisson (avec son nom et son sexe), et une autre méthode pour ajouter une algue.
L'aquarium a une méthode pour faire passer le temps : à chaque nouveau tour, on fait toutes les actions (ce qui n'est pas très passionnant pour l'instant puisqu'il n'y en a aucune) et on affiche sur la console :
  • Le nombre d'algues présentes
  • La liste des poissons avec leur nom et leur sexe.

Exercice 1.2 : un peu de diversité


En fait, des poissons tous identiques, c'est pas très passionnant. Dans le magasin où se fournit monsieur Shingshan, on trouve des poissons carnivores et d'autres herbivores. Il y a six races de poissons :
Poissons carnivores : Mérou, Thon, Poisson-clown.
Poissons herbivores : Sole, Bar, Carpe.
Chaque poisson peut donc manger (une méthode) : selon s'il est carnivore, il mange une algue (paramètre : une algue), ou un autre poisson (paramètre : un poisson quel qu'il soit).

Partie 2 : Mange, tu ne sais pas qui te mangera


Exercice 2.1 : Miam miam miam !


Nos poissons sont des goinfres : à chaque tour, tous les poissons mangent, et ils mangent tout ce qu'ils ont commencé.
En clair, ça veut dire que ce qui et mangé disparaît purement et simplement.
Attention : un poisson ne peut pas se manger lui-même, et un poisson mangé ne peut rien faire.
L'algue ou le poisson mangé est choisi au hasard.
Astuce : Tirer un nombre aléatoire en Java :

// 1- Initialiser le générateur de nombres aléatoires.
// (une seule fois pour tout le programme suffit)
Random r = new Random();

// 2- Récupérer le prochain entier entre 0 (inclus) et n (exclus) :
int x = r.nextInt(n);

// On a des méthodes de ce genre pour tous les types primitifs : nextDouble(), nextBoolean(), ...


Exercice 2.2 : un peu de douceur dans ce monde de brutes


Tout ça est beaucoup trop brutal, introduisons la notion de points de vie (PV).

Les poissons et les algues sont des êtres vivants.
Tous les êtres vivants commencent avec 10 PV.
Un être vivant qui arrive à 0 PV meurt.

Chaque algue grandit à chaque tour : elle gagne 1 PV.
Une algue mangée par un poisson perds 2 PV.

A chaque tour qui passe, le poisson a de plus en plus faim : il perds 1 PV.
Un poisson qui a suffisamment faim (5 PV ou moins) cherche à manger.
Les herbivores n'ont pas trop de problème, mais les algues ne sont pas très nourrissantes : +3 PV.
Les carnivores mangent de la bonne viande de poisson, qui fait gagner +5 PV.
Un carnivore attaque chaque tour un poisson au hasard : il n'a qu'une seule chance. Hélas pour lui, il ne peut ni se manger lui-même, ni manger un poisson de son espèce.
Se faire mordre fait très mal et fait perdre 4 PV.

Partie 3 : Reproductions


Exercice 3.1 : Le désastre du vieillissement


Les êtres vivants ont tous un âge.
Tous les êtres vivants naissent à l'âge de 0 tours.
Les êtres vivants qui ont plus de 20 tours meurent de vieillesse.

On peut acheter des poissons et des algues à un âge quelconque.

Exercice 3.2 : Le miracle de la jeunesse


Notre aquarium précédent est condamné à être désert au bout de 20 tours, ou alors il faut remettre sans arrêt des algues et des poissons. Pas très intéressant, non ?
Nous avons des poissons mâles et femelles ? Faisons-les se reproduire !

Un poisson qui n'a pas faim va aller voir un autre poisson (au hasard). Si ce poisson est de même race et de sexe opposé, les deux poissons se reproduisent et donnent naissance à un troisième poisson, de même race et de sexe aléatoire.
Il n'a qu'un seul essai par tour.

Concernant les algues, c'est plus simple : Une algue qui a 10 PV ou plus se sépare en deux pour donner naissance à une algue deux fois plus petite, donc avec deux fois moins de PV.
Évidemment l'algue parente perds la moitié de ses PV dans le processus, mais garde son âge.

Exercice 3.3 : Mais... la sexualité des poissons est horriblement compliquée !


Eh bien oui, la sexualité des poisson est horriblement compliquée. Pourquoi ?
Parce qu'ils ne sont pas simplement "mâle" ou "femelle" !
On distingue :
Le poisson mono-sexué : Comme vous et moi, ces poissons naissent mâle ou femelle et n'en changent plus.
Le poisson hermaphrodite avec l'âge : Ce poisson passe les 10 premiers tours de sa vie en tant que mâle et les 10 suivants en tant que femelle.
Le poisson hermaphrodite opportuniste : Ce poisson va rencontrer un membre de son espèce. Si ce membre est de même sexe que lui, notre poisson change de sexe pour pouvoir se reproduire.

Je rappelle que nous avons déjà des races herbivores et carnivores, ce qui nous donne le tableau suivant :
Herbivore Carnivore
Mono-sexué Carpe Thon
Hermaphrodite avec l'âge Bar Mérou
Hermaphrodite opportuniste Sole Poisson-clown

Pour ceux que ça intéresse, cette histoire de poisson hermaphrodites est parfaitement exacte... par contre je ne garantis pas le classement des races dans le tableau.

Partie 4 : Rendons notre simulateur d'aquarium pratique


Exercice 4.1 : Sauvez Willy !


Monsieur Shingshan voudrait pouvoir sauvegarder l'état actuel de la simulation (par exemple au tour 35) dans un fichier (par exemple un .poisson) pour pouvoir la reprendre plus tard.
Cette question est beaucoup plus simple qu'elle n'en a l'air, mais nécessitera sans doute de modifier toutes les classes.


Exercice 4.2 : Un fichier pour les enregistrer tous...


Monsieur Shingshan voudrait que les rapport de ce qui s'est passé dans le tour s'enregistrent dans un fichier en plus d'être affichés sur la console.

Exercice 4.3 : ... et dans un fichier les charger


Monsieur Shingshan est aquariophile mais pas programmeur, et n'a pas envie de re-compiler le programme à chaque fois qu'il veut changer les poissons et les algues introduits au début. De toutes façons, il ne sait pas ce qu'est "recompiler".
Il veut bien lancer le programme en ligne de commande, mais il veut pouvoir écrire les poissons et les algues dans un fichier texte dont il passerait le nom au programme.
Il fournit un exemple de fichier (les lignes qui commencent par // sont des commentaires et n'apparaitrons jamais dans le fichier).
// 1- Algues
// Format : [Nombre d'algues] algues [âge] ans (= tours)
// Exemple :
1 algues 10 ans
10 algues 4 ans

// 2- Poissons
// Format : [nom], [race], [âge] ans (= tours)
// Exemple :
Lin, Morue, 10 ans
Anaclet, Poisson-clown, 1 ans
Évariste, Thon, 3 ans


Exercice 4.4 : Tourne, la roue tourne...


Monsieur Shingshan voudrait pouvoir ajouter des poissons et des algues à n'importe quel tour.
Le tour d'insertion serait indiqué par des séparateurs comme celui-ci :
===== tour 5 ====

Tout ce qu'il y a après (et avant le séparateur suivant) suit le format de l'exercice 4.1.
Attention, cette question n'est pas si simple qu'elle en a l'air...


Exercice 4.5 : Le petit neveu


Monsieur Shingshan voudrait donner le simulateur à son petit-neveu, Ashini. Sauf que celui-ci, bien qu'aquariophile, n'est pas précautionneux : il ne faudrait pas qu'il puisse planter son PC avec le logiciel.
Si vous avez programmé nickel, vous avez déjà réalisé cet exercice.



Voilà, amusez-vous bien !
Anonyme
2 avril 2010 à 11:12:43

Je vais voir pour le faire ! Je ne sais pas si j'aurais le temps de le faire en entier, mais je vais essayer ! En tout cas je trouve ça bien de reprendre les exercices Java !
2 avril 2010 à 13:55:27

c'est génial les exos sont de retour,
Je vais essayer de le faire, je débute en Java et c'est l'occasion pour apprendre
2 avril 2010 à 16:16:07

c ' est vrai.
Merci de te devouer pour nous donner des exos qui nous feront surement progresser.
J ' ai plus ou moins commencé l ' exo meme si je pense pas arriver a la partie 4 car elle a l air assez hard
xd

thx
2 avril 2010 à 16:31:07

En fait, je vais ré-ordonner les questions de la partie 4 par ordre de difficulté parce que là c'est un peu n'importe quoi.

Edit : Fait.

A la réflexion, la 4.2 est sans doute plus simple que la 4.1, surtout si vous vous y prenez bien - mais pas de beaucoup alors je ne réédite pas.
8 avril 2010 à 21:41:08

Merci SpaceFox pour l'initiative.
J'ai fait l'exo 3.3, j'ai utilisé les classes( :p ), l'héritage, le polymorphisme, les interfaces, les enums et la reflexivité (j'avoue que c'est la premiere fois que je l'utilise, avant de faire l'exercice je ne voyais pas en quoi ça peut étre utile :honte: )

Poisson.java (classe Poisson + interface Opportuniste)
public abstract class Poisson {

    private final String nom;
    protected Sexe sexe;
    protected int pV = 10;
    protected int age = 0;

    public Poisson(String nom, Sexe sexe) {
        this.nom = nom;
        this.sexe = sexe;
    }

    public Poisson(String nom, Sexe sexe, int age) {
        this.nom = nom;
        this.sexe = sexe;
        this.age = age;
    }

    public String getNom() {
        return nom;
    }

    public Sexe getSexe() {
        return sexe;
    }

    public int getPV() {
        return pV;
    }

    public void ajouterPV(int i) {
        pV += i;
    }

    public void diminuerPV(int i) {
        pV = pV > i ? pV - i : 0;
    }

    @Override
    public String toString() {
        return "Nom:" + this.nom + " | Type:"
                + this.getClass().getSimpleName() + " | Sexe:"
                + this.sexe + " | PV:" + this.pV+" | Age:"+this.age;
    }

    public int getAge() {
        return age;
    }

    public void ajouterAge(int i) {
        age += i;
    }
}



interface Opportuniste{
    public void changerSexe();
}

PoissonHerbivore.java (classes PoissonHerbivore,Carpe,Sole,Bar)
public abstract class PoissonHerbivore extends Poisson {

    public PoissonHerbivore(String nom, Sexe sexe) {
        super(nom, sexe);
    }

    public PoissonHerbivore(String nom, Sexe sexe, int age) {
        super(nom, sexe, age);
    }

    public void manger(Algue a) {
        this.ajouterPV(3);
        a.diminuerPV(2);
    }
}

class Carpe extends PoissonHerbivore {

    public Carpe(String nom, Sexe sexe) {
        super(nom, sexe);
    }

    public Carpe(String nom, Sexe sexe, int age) {
        super(nom, sexe, age);
    }
}

class Sole extends PoissonHerbivore implements Opportuniste {

    public Sole(String nom, Sexe sexe) {
        super(nom, sexe);
    }

    public Sole(String nom, Sexe sexe, int age) {
        super(nom, sexe, age);
    }

    public void changerSexe() {
        this.sexe = this.sexe.equals(Sexe.MALE) ? Sexe.FEMELLE : Sexe.MALE;

    }
}

class Bar extends PoissonHerbivore {

    public Bar(String nom, Sexe sexe) {
        super(nom, sexe);
    }

    public Bar(String nom, Sexe sexe, int age) {
        super(nom, sexe, age);
        if (this.getAge() > 9) {
            this.sexe = this.sexe.equals(Sexe.MALE) ? Sexe.FEMELLE : Sexe.MALE;
        }

    }

    @Override
    public void ajouterAge(int i) {
        age += i;
        if (this.getAge() > 9) {
            this.sexe = this.sexe.equals(Sexe.MALE) ? Sexe.FEMELLE : Sexe.MALE;
        }
    }
}

PoissonCarnivore.java(classes PoissonCarnivore,Thon,PoissonClown et Merou)
public abstract class PoissonCarnivore extends Poisson {

    public PoissonCarnivore(String nom, Sexe sexe) {
        super(nom, sexe);

    }

    public PoissonCarnivore(String nom, Sexe sexe, int age) {
        super(nom, sexe, age);
    }

    public void manger(Poisson p) {
        p.diminuerPV(4);
        this.ajouterPV(5);
    }
}

class Thon extends PoissonCarnivore {

    public Thon(String nom, Sexe sexe) {
        super(nom, sexe);
    }

    public Thon(String nom, Sexe sexe, int age) {
        super(nom, sexe, age);
    }
}

class Merou extends PoissonCarnivore {

    public Merou(String nom, Sexe sexe) {
        super(nom, sexe);
    }

    public Merou(String nom, Sexe sexe, int age) {
        super(nom, sexe, age);
        if (this.getAge() > 9) {
            this.sexe = this.sexe.equals(Sexe.MALE) ? Sexe.FEMELLE : Sexe.MALE;
        }

    }

    @Override
    public void ajouterAge(int i) {
        age += i;
        if (this.getAge() > 9) {
            this.sexe = this.sexe.equals(Sexe.MALE) ? Sexe.FEMELLE : Sexe.MALE;
        }
    }
}

class PoissonClown extends PoissonCarnivore implements Opportuniste {

    public PoissonClown(String nom, Sexe sexe) {
        super(nom, sexe);
    }

    public PoissonClown(String nom, Sexe sexe, int age) {
        super(nom, sexe, age);
    }
    public void changerSexe() {
        this.sexe = this.sexe.equals(Sexe.MALE) ? Sexe.FEMELLE : Sexe.MALE;

    }
}

Sexe.java (enum Sexe)
public enum Sexe {
    MALE, FEMELLE;
}

Algue.java(classe Algue)
public class Algue {

    private int pV = 10;
    private int age = 0;

    public Algue() {
    }

    public Algue(int age) {
        this.age = age;
    }

    public void setPV(int i) {
        pV = i;
    }

    public int getPV() {
        return pV;
    }

    public void ajouterPV(int i) {
        pV += i;
    }

    public void diminuerPV(int i) {
        pV = pV > i ? pV - i : 0;
    }

    void setAge(int i) {
        age = i;
    }

    public int getAge() {
        return age;
    }

    public void ajouterAge(int i) {
        age += i;
    }

    @Override
    public String toString() {
        return "PV:" + this.pV + " | Age:" + this.age;
    }

    
}

Aquarium.java (classe Aquarium, la plus importante)
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Aquarium {

    private List<Poisson> poissons = new ArrayList<Poisson>();
    private List<Algue> algues = new ArrayList<Algue>();

    public void ajouterPoisson(Poisson p) {
        poissons.add(p);
    }

    public void ajouterAlgue(Algue a) {
        algues.add(a);
    }

    public String action() {
        StringBuffer actions = new StringBuffer("");
        miseAJour();
        actions.append(nettoyer(poissons));
        actions.append(nettoyer(poissons));
        actions.append(mangerEtReproduction());
        return actions.toString();
    }

    private String mangerEtReproduction() {
        StringBuffer actions = new StringBuffer("");
        /*poissons2 contiendra les poissons qui n'ont pas mangé
         * et qui sont encore vivants
         */
        List<Poisson> poissons2 = new ArrayList<Poisson>(poissons);
        /*poissonsTemp contiendra les poissons qui n'ont pas essayé
         * de faire l'amour
         */
        List<Poisson> poissons3 = new ArrayList<Poisson>(poissons);

        for (int j = 0; j < poissons.size(); j++) {
            Poisson poissonActuel = poissons.get(j);
            Random r = new Random();
            Poisson poissonAlea = poissons.get(r.nextInt(poissons.size()));
            //si c'est le meme poisson,rien a faire
            if (poissonActuel == poissonAlea) {
                continue;
            }
            if (poissonActuel.getPV() > 5 && poissons3.contains(poissonActuel) && poissons3.contains(poissonAlea)
                    && poissons2.contains(poissonAlea) && poissonActuel.getClass() == poissonAlea.getClass()) {
                if (poissonActuel instanceof Opportuniste && poissonActuel.getSexe().equals(poissonAlea.getSexe())) {
                    ((Opportuniste) poissonActuel).changerSexe();
                }
                if (poissonActuel.getSexe() != poissonAlea.getSexe()) {
                    Poisson fils = creerFils(poissonActuel.getClass(), poissonActuel.getNom(), poissonAlea.getNom());
                    poissons2.add(fils);
                    actions.append(poissonActuel.getNom() + " et " + poissonAlea.getNom() + " ont eu un bébé !\n");
                    poissons3.remove(poissonActuel);
                    poissons3.remove(poissonAlea);
                }
            } else if (poissonActuel.getPV() < 6 && poissons2.contains(poissonActuel)) {  //si le poisson n'algue pas été mangé
                if (poissonActuel instanceof PoissonCarnivore) {
                    if (poissons2.contains(poissonAlea) && poissonActuel.getClass() != poissonAlea.getClass()) {
                        ((PoissonCarnivore) poissonActuel).manger(poissonAlea);
                        actions.append(poissonActuel.getNom() + " à mangé " + poissonAlea.getNom() + " !\n");
                    }
                } else if (algues.size() != 0) {
                    Algue algue = algues.get(r.nextInt(algues.size()));
                    ((PoissonHerbivore) poissonActuel).manger(algue);
                    actions.append(poissonActuel.getNom() + " à mangé une algue !\n");
                }
            }
            actions.append(nettoyer(poissons2));
        }
        poissons = poissons2;
        return actions.toString();
    }

    private String nettoyer(List<Poisson> poissons2) {
        List<Poisson> poissonsTemp = poissons2;
        List<Algue> alguesTemp = algues;
        StringBuffer nettoyage = new StringBuffer("");
        for (int i = 0; i < poissonsTemp.size(); i++) {
            Poisson p = poissonsTemp.get(i);
            if (p.getPV() == 0 || p.getAge() > 20) {
                nettoyage.append(p.getNom() + " est mort !\n");
                poissons2.remove(p);
            }
        }

        for (int i = 0; i < alguesTemp.size(); i++) {
            Algue a = algues.get(i);
            if (a.getPV() == 0 || a.getAge() > 20) {
                nettoyage.append("Une algue est morte !");
                algues.remove(a);
            }
        }
        return nettoyage.toString();
    }

    private void miseAJour() {
        List<Algue> algues2 = algues;
        for (int i = 0; i < poissons.size(); i++) {
            poissons.get(i).diminuerPV(1);
            poissons.get(i).ajouterAge(1);
        }
        for (int i = 0; i < algues.size(); i++) {
            Algue a = algues2.get(i);
            a.ajouterPV(1);
            a.ajouterAge(1);
            if (a.getPV() > 9) {
                a.setPV(a.getPV() / 2);
                a.setAge(a.getAge() / 2);
                Algue a2 = new Algue(a.getAge());
                a2.setPV(a.getPV());
                algues2.add(a2);
            }
        }
        algues = algues2;
    }

    private Poisson creerFils(Class classe, String nom1, String nom2) {
        Poisson fils = null;
        try {
            Class[] tabClasses = new Class[]{String.class, Sexe.class};
            Constructor cons = classe.getConstructor(tabClasses);
            String nomFils = nom1.substring(0, nom1.length() / 2)
                    + nom2.substring(nom2.length() / 2);
            Sexe sexeFils = ((new Random()).nextInt(2) == 0) ? Sexe.FEMELLE : Sexe.MALE;
            fils = (Poisson) cons.newInstance(nomFils, sexeFils);

        } catch (InstantiationException ex) {
            Logger.getLogger(Aquarium.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            Logger.getLogger(Aquarium.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IllegalArgumentException ex) {
            Logger.getLogger(Aquarium.class.getName()).log(Level.SEVERE, null, ex);
        } catch (InvocationTargetException ex) {
            Logger.getLogger(Aquarium.class.getName()).log(Level.SEVERE, null, ex);
        } catch (NoSuchMethodException ex) {
            Logger.getLogger(Aquarium.class.getName()).log(Level.SEVERE, null, ex);
        } catch (SecurityException ex) {
            Logger.getLogger(Aquarium.class.getName()).log(Level.SEVERE, null, ex);
        }
        return fils;
    }

    @Override
    public String toString() {
        String resultat = "";
        resultat += "Algues:\n";
        if (algues.size() == 0) {
            resultat += "\t/*\\ Pas d'algues dans l'aquarium\n";
        } else {
            resultat += "\t/*\\ " + algues.size() + " algue(s)\n";
            for (int i = 0; i < algues.size(); i++) {
                resultat += "\t\t/*\\ Algue n°" + i + " | " + algues.get(i).toString() + "\n";
            }
        }
        resultat += "Poissons:\n";
        if (poissons.size() == 0) {
            resultat += "\t/*\\ Pas de poissons dans l'aquarium\n";
        } else {
            resultat += "\t/*\\ " + poissons.size() + " poissons(s)\n";
            for (Poisson p : poissons) {
                resultat += "\t\t/*\\ " + p.toString() + "\n";
            }
        }
        return resultat;
    }
}

et enfin un petit main de test:
public static void main(String[] args) {
        Aquarium aq = new Aquarium();
        for (int i = 0; i < 2; i++) {
            aq.ajouterPoisson(new Thon("Charlie" + i, Sexe.MALE,10));
            aq.ajouterPoisson(new Carpe("Marie" + i, Sexe.FEMELLE));
            aq.ajouterPoisson(new Bar("Lili" + i, Sexe.FEMELLE));
            aq.ajouterAlgue(new Algue());
        }
        aq.ajouterPoisson(new Thon("tlilota",Sexe.FEMELLE));
        Scanner sc = new Scanner(System.in);
        System.out.println(aq);
        while (!sc.nextLine().equalsIgnoreCase("quitter")) {
            System.out.println(aq.action()+aq);
        }
        sc.close();
    }

Que pensez vous du code ?
8 avril 2010 à 22:01:16

C'est intéressant parce que j'aurais pas modélisé ça comme ça, mais ça m'a l'air tout à fait valable.
Par contre, j'ai pas trop le temps de le tester là, donc je verrai comment il marche ce WE.
En tous cas j'aime bien l'utilisation des getters pour changer le sexe et l'override des toString.
Sinon le code est propre, rien à dire de ce côté.

J'avoue que j'ai fait exprès de chercher un cas qui nécessite la réflexivité, justement parce qu'on peut se retrouver face à des modèles de données où ça peut être utile.
12 avril 2010 à 17:43:30

Salut !
Tout d'abord je voudrais dire que c'est un exercice très intéressant et ludique, qui fait bien utiliser un peu tout.
J'ai commencé le java il y a pas longtemps après avoir fait les tutos sur le C et le C++, donc mon code est surement très bourrin
J'en suis à la gestion de la reproduction des poissons, et après l'avoir écrite, en lançant mon programme je remarque que mon programme s'arrête à la fonction reproduction() comprise dans passerTemps().
Premièrement j'aimerais bien des conseils pour avoir un code moins bourrin, parce que j'ai l'impression d'avoir trop de boucles ou de conditions à employer, et puis j'aimerais bien comprendre pourquoi mon code se bloque
Merci


main.java
import java.util.Scanner;


public class main {

	/**
	 */
	public static void main(String args[]) 
	{
		Scanner sc = new Scanner(System.in);

		System.out.println("Comment souhaitez vous nommer votre aquarium ?");
		String st = sc.nextLine();
		System.out.println("Combien de poissons souhaitez vous y intégrer ?");
		int nP = sc.nextInt();
		System.out.println("Combien d'algues souhaitez vous y mettre ?");
		int nA = sc.nextInt();
		
		// On demande les paramètres à l'utilisateur pour former l'aquarium de base
		
		Aquarium Aqualand = new Aquarium(st, nP , nA);
		int i = 0;
		while(i == 0)
			Aqualand.passerTemps();
	}

}


Aquarium.java
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;


public class Aquarium extends Object
{
	private String nomAquarium;
	private int nombrePoisson;
	private int nombreAlgue;
	private int i;
	protected ArrayList<Poisson> poisson = new ArrayList<Poisson>();
	protected ArrayList<Algue> algue = new ArrayList<Algue>();
	private boolean genre = true;
	private Scanner sc = new Scanner(System.in);
	private char oui = 'O';
	private char non = 'N';
	Random r = new Random();
	
	public Aquarium()
	{
	}
	
	public Aquarium(String nom, int npoisson, int nalgue)
	{
		nomAquarium = nom;
		setNombrePoisson(npoisson);
		nombreAlgue = nalgue;
		System.out.println("Bienvenue dans " +nomAquarium+ ", contenant " +nombrePoisson+ " poissons et " +nombreAlgue+ " algues.");
		parametrePoisson(nombrePoisson); // on demande à l'utilisateur les caractérisitques des poisons qu'il veut ajouter
		for(int i = 0; i < nombreAlgue; i++)
		{
			Algue a = new Algue();
			algue.add(i, a); // on ajoute les algues à une ArrayList d'algues pour avoir des paramètres pour chacune
		}
		this.affichePoisson();
	}

	

	public void setNombrePoisson(int nombrePoisson) 
	{
		this.nombrePoisson = nombrePoisson;
	}

	public int getNombrePoisson() 
	{
		nombrePoisson = poisson.size();
		return nombrePoisson;
	}
	
	public int geti()
	{
		return i;
	}
	
	public void ajoutePoisson()
	{
		int j = getNombrePoisson() + 1;
		setNombrePoisson(j);
		String espece = choixPoisson();
		String ccc = sc.nextLine(); // Pour être sur que le caractère demandé ensuite sera pris en compte
		System.out.println("Ce poisson est il un mâle ? (O/N)");
		String verif = sc.nextLine();
		verif.toUpperCase();
		char c = verif.charAt(0);
		if(c == oui)
		{
			genre = true;
		}
		else if(c == non)
		{
			genre = false;
		}
		Poisson poiss = new Poisson(genre, espece);
		poisson.add(i, poiss);
	}
	
	public void setNombreAlgue(int nombreAlgue)
	{
		this.nombreAlgue = nombreAlgue;
	}
	
	public int getNombreAlgue()
	{
		nombreAlgue = algue.size();
		return nombreAlgue;
	}
	
	public void ajouteAlgue()
	{
		Algue a = new Algue();
		int j = algue.size();
		setNombreAlgue(j);
		algue.add(j, a);
	}

	
	
	public void affichePoisson()
	{
		for(i = 0; i < getNombrePoisson(); i++)
		{
			Poisson poi = poisson.get(i);
			int j = geti() + 1;
			String sexe = null;
			if(poi.getGenre() == true)
			{
				sexe = "un Mâle ";
			}
			else
			{
				sexe = "une Femelle ";
			}
			System.out.println("Le poisson n°" + j + " est un " +poi.getEspece()+ ", est " + sexe + ", a " +poi.getVie()+ " PV et est agé de " +poi.getAge()+ " jours.");
		}
	}
	
	public void parametrePoisson(int nombrePoisson2) 
	{
		for(i = 0 ; i < nombrePoisson2; i++)
		{
			String espece = choixPoisson();
			String car = sc.nextLine();
			char cara;
			System.out.println("Ce poisson est il un mâle ? (O/N)");
			String verif = sc.nextLine();
			verif.toUpperCase();
			try
			{
				cara = verif.charAt(0);
			}
			catch(StringIndexOutOfBoundsException e)
			{
					cara = 'O';
			}			
			if(cara == oui)
			{
				genre = true;
			}
			else if(cara == non)
			{
				genre = false;
			}
			
			Poisson poiss = new Poisson(genre, espece);
			poisson.add(i, poiss);
		}		
	}
	
	public String choixPoisson()
	{
		System.out.println("Quelle espèce de poisson souhaitez vous ajouter :");
		System.out.println("1 Mérou");
		System.out.println("2 Thon");
		System.out.println("3 Poisson-Clown");
		System.out.println("4 Sole");
		System.out.println("5 Bar");
		System.out.println("6 Carpe");
		int choix = sc.nextInt();
		String espece = null;
		switch (choix)
		{
			case 1 :
				espece = "Mérou";
				break;
			case 2 :
				espece = "Thon";
				break;
			case 3 :
				espece = "Poisson-Clown";
				break;
			case 4 : 
				espece = "Sole";
				break;
			case 5 :
				espece = "Bar";
				break;
			case 6 :
				espece = "Carpe";
				break;
			default :
				break;
		}
		
		return espece;
	}
	public void passerTemps()
	{
		char cara;
		do
		{
			System.out.println("Voulez vous ajouter un nouveau poisson à l'aquarium ? (O/N)");
			String st = sc.nextLine();
			st.toUpperCase();
			try{
			cara = st.charAt(0);
			}
			catch(StringIndexOutOfBoundsException e)
			{
				cara = 'O';
			}
			if(cara == 'O')
				this.ajoutePoisson();
			else
				System.out.println("Vous n'avez pas ajouté de poisson à l'aquarium");
		}while(cara == 'O');
		do
		{
			System.out.println("Voulez vous ajouter une nouvelle algue à l'aquarium ? (O/N)");
			String st = sc.nextLine();
			st.toUpperCase();
			try{
				cara = st.charAt(0);
			}
			catch(StringIndexOutOfBoundsException e)
			{
			cara = 'O';
			}
			if(cara == 'O')
				this.ajouteAlgue();
			else
				System.out.println("Vous n'avez pas ajouté d'algue à l'aquarium");
		}while(cara == 'O');
		for(int i = 0; i < getNombrePoisson(); i++)
		{
			int viep = (poisson.get(i)).getVie() - 1;
			(poisson.get(i)).setVie(viep);
			int agep = (poisson.get(i)).getAge() + 1;
			(poisson.get(i)).setAge(agep);
		}

		for(int i = 0; i < getNombreAlgue(); i++)
		{
			if((algue.get(i)).getVie() < 10)
			{
			int viea = (algue.get(i)).getVie() + 1;
			(algue.get(i)).setVie(viea);
			}
			else
			{
			(algue.get(i)).setVie(5);
			Algue a = new Algue();
			a.setVie(5);
			algue.add(a);
			}
			int agea = (algue.get(i)).getAge() + 1;
			(algue.get(i)).setAge(agea);
		}

		changeSexe();
		reproduction();
		manger();
		destructionMorts();
		affichePoisson();

		System.out.println("Bienvenue dans " +nomAquarium+ ", contenant " +getNombrePoisson()+ " poissons et " +nombreAlgue+ " algues.");
	}

	

	private void changeSexe() 
	{
		for(i = 0; i < getNombrePoisson(); i++)
		{
			if(((poisson.get(i)).getEspece() == "Bar" || (poisson.get(i)).getEspece() == "Mérou") && (poisson.get(i)).getAge() == 10)
			{
				if((poisson.get(i)).getGenre() == true)
					(poisson.get(i)).setMale(false);
				if((poisson.get(i)).getGenre() == false)
					(poisson.get(i)).setMale(true);
			}
		}
	}

	public void reproduction() 
	{
		for(i = 0; i < getNombrePoisson(); i++)
		{
			int x = 0;
			if((poisson.get(i)).getVie() > 5)
			{
				do{
					if(i != x && (poisson.get(i)).getEspece() == (poisson.get(x)).getEspece())
					{	
						x = r.nextInt(getNombrePoisson());
						(poisson.get(i)).seReproduire(poisson.get(x));
					}
				}while(i == x);
			}
		}
	}

	public void manger() 
	{
		for(int i = 0; i < getNombrePoisson(); i++)
		{
			int x = 0;
			if(poisson.get(i).getVie() < 5)
			{
				if((poisson.get(i)).isCarni())
				{
				
					do{
						try{
							x = r.nextInt((getNombrePoisson() - 1));
							}
							catch(IllegalArgumentException e)
							{
								System.out.println("L'aquarium est vide d'algues !");
							}
						if(x != i && (poisson.get(x)).getAge() < 20 && (poisson.get(i).getEspece()) != (poisson.get(x)).getEspece())
						{
							
							(poisson.get(i)).mangerPoisson(poisson.get(x));
						}
					}while(x == i);
				}
				else
				{
					try{
					x = r.nextInt((getNombreAlgue() - 1));
					}
					catch(IllegalArgumentException e)
					{
						System.out.println("L'aquarium est vide d'algues !");
					}
					if((algue.get(x)).getAge() < 20)
						(poisson.get(i)).mangerAlgue(algue.get(x));
				}
			}
		}
	}
	
	public void destructionMorts() 
	{
		for(int i = 0; i < getNombrePoisson(); i++)
		{
			if((poisson.get(i)).getVie() <= 0 || (poisson.get(i)).getAge() >= 20)
			{
				poisson.remove(i);
				setNombrePoisson(getNombrePoisson() - 1);
			}
		}
		for(int i = 0; i < getNombreAlgue(); i++)
		{
			if((algue.get(i)).getVie() <= 0 || (algue.get(i)).getAge() >= 20)
			{
				algue.remove(i);
				setNombreAlgue(getNombreAlgue() - 1);
			}
		}
	}
}


Poisson.java
import java.util.Scanner;


public class Poisson extends Aquarium implements Carnivore, Herbivore
{
	private int vie;
	private int age;
	private boolean male;
	private String race;
	private String nom;
	private Scanner sc2 = new Scanner(System.in);
	private boolean carni;
	
	public void regimeAlimentaire(String espece)
	{
		if(espece == "Mérou" || espece == "Thon" || espece == "Poisson-Clown")
			setCarni(true);
		else
			setCarni(false);
	}
	
	public boolean isCarni() 
	{
		return carni;
	}

	public void setCarni(boolean carni) 
	{
		this.carni = carni;
	}

	public Poisson(boolean b, String espece)
	{
		race = espece;
		regimeAlimentaire(race);
		vie = 10;
		male = b;
		age = 0;
				
	}
	
	public boolean getGenre()
	{
		return male;
	}

	public int getVie() 
	{
		return vie;
	}
	
	public int getAge()
	{
		return age;
	}

	public void mangerPoisson(Poisson poi) 
	{
		if(vie > 0 && age < 20)
		{
		int PV = poi.getVie() - 4;
		poi.setVie(PV);
		if(vie < 10)
		{	
			this.vie += 5;
			if(vie > 10)
				this.vie = 10;
		}
		}
	}

	public void mangerAlgue(Algue al) 
	{
		int PV = al.getVie() - 2;
		al.setVie(PV);
		this.vie += 3;
	}

	public void setVie(int vie) {
		this.vie = vie;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public void setMale(boolean male) {
		this.male = male;
	}

	public String getEspece() {
		return race;
	}

	public void setEspece(String espece) 
	{
		this.race = espece;
	}
	
	public void seReproduire(Poisson p)
	{
		if(this.getGenre() != p.getGenre())
		{
			boolean b = r.nextBoolean();
			Poisson d = new Poisson(b, this.race);
			poisson.add(d);
		}
		
		if(this.getGenre() == p.getGenre() && this.getEspece() == "Sole")
		{
			boolean b = r.nextBoolean();
			Poisson d = new Poisson(b, this.race);
			poisson.add(d);
			if(this.getGenre() == true)
				this.setMale(false);
			if(this.getGenre() == false)
				this.setMale(true);
		}
	}

		
	
}


Algue.java
public class Algue extends Aquarium
{
	private int vie = 10;
	private int age = 0;
	
	public int getVie() 
	{
		return vie;
	}
	
	public void setVie(int vie) 
	{
		this.vie = vie;
	}
	
	public int getAge() 
	{
		return age;
	}
	
	public void setAge(int age) 
	{
		this.age = age;
	}
	
	
	
}


Ps : j'ai pas mis les deux interfaces que j'implémente dans Poisson parce qu'il n'y a rien de spécial dedans, et parce que je ne vois pas encore l'utilité des interfaces
Ps2 : j'ai viré la gestion du nom des poissons parce que c'est trop long pour les tests ; )
12 avril 2010 à 21:40:08

Correction rapide :

@Einstein++ :
Y'a pas grand-chose à dire, c'est propre et clair, et ça semble faire ce qui est demandé.
Encore qu'il me semble avoir vu un truc impossible (un poisson mort de vieillesse qui a fait quelque chose, je sais plus s'il s'est reproduit, a mangé ou a été mangé). Mais comme tous tes poissons finissent par avoir le même nom ^^

En fait le plus gros défaut de ton code serait que toute la logique est dans l'aquarium alors qu'elle devrait être dans les diverses classes.
Personnellement je déteste les conditions ternaires, je trouve ça totalement illisible, mais c'est un avis perso.

Pour en revenir au "instanceof", je pense qu'en ayant un modèle suffisemment complet et en remontant bien les informations on peut s'en passer ; par contre j'en suis pas encore certain, j'ai pas encore fait la correction ^^


@Satch33
Désolé, mais c'est vraiment pas bon.

Pour commencer, tu ne sembles pas avoir compris le concept d'héritage : A extends B peut se lire "A est un B".
Or, dans ton modèle, on peut lire "Poisson extends Aquarium", et je ne pense pas qu'un poisson soit un aquarium.

Pour pallier à ça, je te conseille de lire ce tutoriel : faut pas avoir peur du titre, c'est le meilleur tuto débutant Java et le meilleur tuto sur le modèle Objets que j'ai jamais lu.

Pour le reste, je te donne les conseils en vrac :
  • Utilises des noms de variable clairs. T'es virtuellement pas limité en nombre de caractères pour une variable ou un nom de méthode en Java.
  • Seul le main devrait interragir avec l'utilisateur dans mon exercice, là je vois des scanners partout. Il doit y avoir queque chose dans le concept d'objets que t'as pas bien compris aussi, cf encore le même tuto.
  • En Java, un objet sans extends étends automatiquement Object, c'est pas la peine de le déclarer.
  • N'hésites pas à lire la doc, ta manière de gérer les List est horriblement compliquée. Un simple maListe.add(monObjet); suffit pour ajouter un objet à une liste, tout le reste est automatique.
  • Idem, t'as pas besoin de parenthèses autour de chaque objet, tu peux chaîner les appels : (poisson.get(i)).getVie() --> poisson.get(i).getVie()
  • Evites les lignes de 150 km de long. 80 caractères de long c'est un peu court, mais 120 caractères max par ligne, ça marche pas mal en Java.
  • La variable dans chaque poisson pour donner sa race n'est pas indispensable grâce à un truc qui s'appelle l'introspection (mais il vaut mieux que tu fasse fonctionner le programme comme ça et que ça marche plutôt que tu te casses la tête avec l'introspection), ou éventuellement un modèle objet très complet (je pense, j'ai pas encore fini la solution).

En fait, si t'as le courage de continuer l'exercice, il vaudrait mieux que tu laisse tomber l'interface d'ajout des poissons à la main (qui n'a pas grand intérêt, à cause de la partie 4), que tu imposes le contenu de l'aquarium dans ton main (cf ce qu'a fait Einstein++) et que tu te concentres sur le fonctionnement. Ce serait bien plus intéressant et formateur.
12 avril 2010 à 22:18:16

@SpaceFox:
J'ai re-testé le code mais je n'ai pas rencontré le cas dont tu parles, par contre j'ai eu une fois un poisson avec un age de 21. Déja lorsque j'ai fait le code au début il y a avait la plupart des temps des poissons vivants à 21 (bon c'est très bizarre), j'ai contourné le problème en appelant deux fois la méthode nettoyer(). Bon je vais revoir cette partie du code.
Pour la classe aquarium c'est vrai je la trouve un peu trop grande, je penserai à une autre soluce (j'ai déjà quelques idées et je pourrai peut-être me débarrasser du instanceof ;) ).
Merci encore pour avoir testé le code, et pour tes remarques constructives.
18 avril 2010 à 10:52:57

J'ai tout repris depuis le début, en écoutant bien tes conseils, en relisant plusieurs parties du cours et en articulant mieux le programme.
J'ai un peu regardé le code d'Enstein++ quand je rencontrais des problèmes bizarres (pour la création des bébés algues, j'avais un Java Heap Space Error au début :euh: )
Bref tout ça pour dire que la je pense que mon code est bon, à part surement deux trois trucs un peu mal bidouillés il est plus propre et il marche bien :)
Par contre je sais pas si j'aurai le temps de faire la partie 4 :p

Le voila (je suis toujours prêt à avoir des conseils hein :)

Test.java

import java.util.Scanner;


public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) 
	{
		Aquarium Aqualand = new Aquarium();	
		int nombreTours = 1;
		char choix;
		Scanner sc = new Scanner(System.in);
		
		
		System.out.println("Bienvenue dans votre nouvel aquarium !! \n");
		
		for(byte i = 1; i <= 2; i++)
		{
			Aqualand.ajoutePoisson(new Sole("MALE", "Bibi" + i));
			Aqualand.ajoutePoisson(new Bar("FEMELLE", "Bibette" + i));
			Aqualand.ajoutePoisson(new PoissonClown("MALE", "Boubou"+i));
			Aqualand.ajoutePoisson(new Bar("MALE", "Boubette"+i));
		}
		
		for(byte i = 0; i < 4; i++)
		{
			Aqualand.ajouteAlgue(new Algue());
		}
		System.out.print("Tour "+nombreTours+" : ");
		Aqualand.afficheEtat();
		Aqualand.affichePoisson();
		do{
			nombreTours++;
			System.out.println("Voulez vous passer un tour ? (O/N)");
			String ligne = sc.nextLine();
			String ligneMajuscule = ligne.toUpperCase();
			try{
					choix = ligneMajuscule.charAt(0);
			}
			catch(StringIndexOutOfBoundsException e) // si l'utilisateur appuie juste sur entrée, on lève l'exception
			{
				choix = 'O';
			}
			if(choix == 'O')
				System.out.print("Tour "+nombreTours+" : ");
				Aqualand.passerTour();
			}while(choix == 'O');
		
		System.out.println("Fin du programme ... Voulez vous enregistrer votre situation ?");
	}

}



Aquarium.java
import java.util.ArrayList;
import java.util.Random;


public class Aquarium 
{
	
	private ArrayList<Poisson> poisson = new ArrayList<Poisson>(); // Liste de poissons
	private ArrayList<Algue> algue = new ArrayList<Algue>(); // Liste d'algues
	private ArrayList<Integer> algueMangee = new ArrayList<Integer>(); //Liste des algues mangées en ce tour
	private ArrayList<Integer> poissonMangeurAlgue = new ArrayList<Integer>(); //Liste des poissons mangeant des algues
	private ArrayList<Integer> poissonMange = new ArrayList<Integer>(); //Liste des poissons mangés en ce tour
	private ArrayList<Integer> poissonMangeurPoisson = new ArrayList<Integer>(); //Liste des poissons mangeant des poissons
	private ArrayList<Integer> poissonReproducteur = new ArrayList<Integer>(); //Liste des poissons se reproduisant
	private Random r = new Random(); // Générateur de nombre aléatoire
	private int aleaPoisson; // Nombre aléatoire pour les poissons à manger
	
	
	public void ajoutePoisson(Poisson p)
	{
		poisson.add(p);
	}
	
	public void ajouteAlgue(Algue a)
	{
		algue.add(a);
	}
	public void afficheEtat()
	{
		if(poisson.size() == 0)
			System.out.println("\nPlus de poissons !");
		if(algue.size() == 0)
			System.out.println("\nPlus d'algues !");
		System.out.println("\nL'aquarium comporte " +poisson.size()+ " poissons et " +algue.size()+ " algues.\n");
	}
	
	public void affichePoisson()
	{
		for(int i = 0; i < poisson.size(); i++)
		{
			System.out.println(poisson.get(i).toString());
		}
	}
	
	public void destructionMort()
	{
		for(int i = 0; i < algue.size(); i++)
		{
			if(algue.get(i).verifierMort())
				algue.remove(i);
		}
		for(int i = 0; i < poisson.size(); i++)
		{
			if(poisson.get(i).verifierMort())
				poisson.remove(i);
		}
	}
	
	public void nourrirPoisson()
	{
		for(int i = 0; i < poisson.size(); i++)
		{
			poissonMangeurAlgue.clear();
			poissonMange.clear();
			poissonMangeurPoisson.clear();
			algueMangee.clear();
			if(poisson.get(i).getVie() < 5)
			{
				int x = 0;
				try{
				x = r.nextInt(algue.size());
				}
				catch(IllegalArgumentException e)
				{
					System.out.println("Plus d'algues, les herbivores sont mal barrés !");
				}
				if(poisson.get(i).getType().equals("Herbivore") && algue.size() > 0)
				{
					int j = 0;
					boolean bool = false;
					while(j < algueMangee.size() && bool == false)
					{
						if(algueMangee.get(j) == x)
							bool = true;
						j++;
					}
					if(bool == false)
					{
						((Herbivore) poisson.get(i)).manger(algue.get(x));
						poissonMangeurAlgue.add(i); // on ajoute les poissons qui mangent des algues à la liste
						algueMangee.add(x); // on ajoute les algues déjà mangées à la liste
					}
				}
				else if(poisson.get(i).getType().equals("Carnivore") && poisson.size() > 1)
				{
					aleaPoisson = r.nextInt(poisson.size());
					do
					{
						aleaPoisson = r.nextInt(poisson.size());
						if(aleaPoisson == i)
							aleaPoisson = r.nextInt(poisson.size());
					}while(aleaPoisson == i );
					
					boolean bool = verification(aleaPoisson); //on vérifie si ce poisson aléatoire est mangeable
					
					if(poisson.get(i).getClass().equals(poisson.get(aleaPoisson).getClass()) || bool == true);
					else
					{
						((Carnivore) poisson.get(i)).manger(poisson.get(aleaPoisson)); //Cast demandé par Eclipse
						poissonMangeurPoisson.add(i);
						poissonMange.add(aleaPoisson);
					}
				}
				
			}
		}
	}
	
	private boolean verification(int aleaPoisson2) 
	{
		int j = 0; //itérateur
		boolean bool = false; //booléen pour vérifier si le poisson aléatoire ne mange rien ou n'est pas mangé
		
		/*on filtre notre poisson aléatoire par trois boucles while un itérateur, 
		un booléen et nos trois arraylist d'int*/
		
		while(j < poissonMangeurPoisson.size() && bool == false)
		{
			if(aleaPoisson == poissonMangeurPoisson.get(j))
				bool = true; //si on retrouve le poisson dans une des listes, ce booléen permet de ne pas manger le poisson
			j++;
		}
		j = 0; // On remet notre itérateur à zéro
		while(j < poissonMange.size() && bool == false)
		{
			if(aleaPoisson == poissonMange.get(j))
				bool = true;
			j++;
		}
		j = 0;
		while(j < poissonMangeurAlgue.size() && bool == false)
		{
			if(aleaPoisson == poissonMangeurAlgue.get(j))
				bool = true;
			j++;
		}		
		return bool;
	}

	public void vieillissement()
	{
		for(int i = 0; i < poisson.size(); i++)
		{
			poisson.get(i).setAge(poisson.get(i).getAge() + 1);
			poisson.get(i).setVie(poisson.get(i).getVie() - 1);
		}
		for(int i = 0; i < algue.size(); i++)
		{
			algue.get(i).passerTour();
			if(algue.get(i).getVie() == 10)
			{
				algue.get(i).division();
				Algue a2 = new Algue();
				a2.setVie(5);
				algue.add(a2);
				System.out.println("Une algue est née !");
			}
		}
	}
	
	private void reproduction() 
	{
		int nombrePoisson = poisson.size(); //on ne compte pas les poissons qui pourraient naitre durant ce tour
		int poissonAlea = 0; // nombre aléatoire
		poissonReproducteur.clear(); // on réinitialise la liste des poissons reproducteurs
		
		for(int i = 0; i < nombrePoisson; i++)
		{
			if(poisson.get(i).getVie() > 5)
			{
				String classePoisson = poisson.get(i).getClass().getName(); // on allège les conditions
				String sexePoisson = poisson.get(i).getSexe();
				do{
					poissonAlea = r.nextInt(nombrePoisson);
				}while(poissonAlea == i);
				
				String classeAlea = poisson.get(poissonAlea).getClass().getName();
				String sexeAlea = poisson.get(poissonAlea).getSexe();
				boolean b = verificationReproduction(i, poissonAlea);
				
				if(poisson.get(poissonAlea).getVie() <= 5 || b == true);
				else if(classePoisson.equals(classeAlea) && poisson.get(i).sexualite().equals("Opportuniste") && b == false)
				{
					boolean sexe = r.nextBoolean(); // on determine au hasard le sexe du nouveau poisson
					String sexeNe;
					if(sexe == true)
						sexeNe = "MALE";
					else
						sexeNe = "FEMELLE";
					if(sexePoisson.equals(sexeAlea))
						((Opportuniste) poisson.get(i)).changeSexeOpp(poisson.get(i).getSexe());
					else;
					if(classePoisson.equals("Sole"))
						poisson.add(new Sole(sexeNe, "Bubu"+i, 5));
					else if(classePoisson.equals("PoissonClown"))
						poisson.add(new PoissonClown(sexeNe, "Bobo"+i, 5));
					
					System.out.println("Un(e) " +classePoisson+ " est né !");
					poissonReproducteur.add(i); // on met a jour notre liste
					poissonReproducteur.add(poissonAlea);
				}
				else if(classePoisson.equals(classeAlea) &! poisson.get(i).sexualite().equals("Opportuniste") && b == false)
				{
					boolean sexe = r.nextBoolean(); // on determine au hasard le sexe du nouveau poisson
					String sexeNe;
					if(sexe == true)
						sexeNe = "MALE";
					else
						sexeNe = "FEMELLE";
					
					if(classePoisson.equals("Bar"))
						poisson.add(new Bar(sexeNe, "Babar"+i, 5));
					else if(classePoisson.equals("Carpe"))
						poisson.add(new Carpe(sexeNe, "Bob"+i, 5));
					else if(classePoisson.equals("Mérou"))
						poisson.add(new Mérou(sexeNe, "BipBip"+i, 5));
					else if(classePoisson.equals("Thon"))
						poisson.add(new Thon(sexeNe, "Toto"+i, 5));
					System.out.println("Un(e) " +classePoisson+ " est né !");
					poissonReproducteur.add(i);
					poissonReproducteur.add(poissonAlea);
				}
			}
		}
	}
	
	private boolean verificationReproduction(int nombre1, int nombre2) 
	{
		boolean bool = false; // booléen de vérification
		int i = 0;
		while(i < poissonReproducteur.size() && bool == false)
		{
			if(poissonReproducteur.get(i) == nombre1 || poissonReproducteur.get(i) == nombre2)
				bool = true;
			i++;
		}
		return bool;
	}

	
	public void passerTour()
	{
		destructionMort();
		changementSexeVieillesse();
		nourrirPoisson();
		reproduction();
		vieillissement();
		destructionMort();
		affichePoisson();
		afficheEtat();
	}

	public void changementSexeVieillesse() 
	{
		for(int i = 0; i < poisson.size(); i++)
		{
			// on met la condition complète ici
			if(poisson.get(i).sexualite().equals("Hermaphrodite") && poisson.get(i).getAge() == 10)
				((Hermaphrodite) poisson.get(i)).changeSexe(poisson.get(i).getSexe());
		}
	}

}


Poisson.java, Herbivore.java, Carnivore.java, interfaces opportuniste et hermaphrodite
public abstract class Poisson 
{
	protected int vie;
	protected int age;
	protected String sexe;
	protected String nom;
	
	public abstract void seReproduire();
	public abstract String getType();
	
	// Constructeur par défaut, prenant en compte l'information sur le sexe du poisson
	public Poisson(String a, String b) 
	{
		nom = b;
		sexe = a;
		vie = 10;
		age = 0;
	}
	
	public Poisson(String a, String b, int nouvelleVie)
	{
		vie = nouvelleVie;
		sexe = a;
		nom = b;
		age = 0;
	}
	
	public boolean verifierMort()
	{
		if(age >= 20 || vie <= 0)
		{
			System.out.println("Un(e) "+getClass().getName()+" est mort(e) !");
			return true;
		}
		else
			return false;
		
	}
	
	public void passerTour()
	{
		setVie(getVie() - 1);
		setAge(getAge() + 1);
	}
	
	public int getVie() {
		return vie;
	}
	public void setVie(int vie) {
		this.vie = vie;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString()
	{
		return "Je m'appelle " +nom+ ", je suis un(e) " +getClass().getName()+  ", je suis un(e) " +sexe+ ", j'ai "+age+" jours, et je n'ai plus que "+vie+ " PV";
		
	}
	
	public String getSexe() {
		return sexe;
	}
	
	public void setSexe(String sexe) {
		this.sexe = sexe;
	}
	
	public String sexualite()
	{
		return null;
	}
	
}


public abstract class Herbivore extends Poisson 
{
	public Herbivore(String a, String b) {
		super(a, b);
		// TODO Auto-generated constructor stub
	}
	
	public Herbivore(String a, String b, int nouvelleVie)
	{
		super(a, b, nouvelleVie);
	}
	
	public void manger(Algue a)
	{
		this.setVie(this.getVie() + 3);
		a.setVie(a.getVie() - 3);
	}
	
	@Override
	public String getType()
	{
		return "Herbivore";
	}
	
}


public abstract class Carnivore extends Poisson
{
	public Carnivore(String a, String b) 
	{
		super(a, b);
	}
	
	public Carnivore(String a, String b, int nouvelleVie)
	{
		super(a, b, nouvelleVie);
	}
	
	public void manger(Poisson a)
	{
		a.setVie(a.getVie() - 4);
		this.setVie(getVie() + 5);
	}
	
	@Override
	public String getType()
	{
		return "Carnivore";
	}
	
}


public interface Hermaphrodite
{
	public void changeSexe(String b);
	public String sexualite();
}


public interface Opportuniste 
{
	public void changeSexeOpp(String b);
	public String sexualite();
}


Algue.java
public class Algue 
{
	private int vie = 10;
	private int age = 0;
	
	public Algue(){ }
	
	public void passerTour()
	{
		if(vie < 10)
			this.setVie(getVie() + 1);
		this.setAge(getAge() + 1);
	}
	
	public boolean verifierMort()
	{
		if(vie <= 0 || age >= 20)
		{
			System.out.println("Une algue est morte !");
			return true;
		}
		else
			return false;
	}
	
	
	public int getVie() {
		return vie;
	}
	public void setVie(int vie) {
		this.vie = vie;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	public void division() 
	{
		setVie(5);
	}
	
}


Et les six classes de poisson
public class Thon extends Carnivore
{

	public Thon(String a, String b) {
		super(a, b);
		// TODO Auto-generated constructor stub
	}
	
	public Thon(String a, String b, int nouvelleVie)
	{
		super(a, b, nouvelleVie);
	}

	@Override
	public void seReproduire() {
		// TODO Auto-generated method stub
		
	}

}


public class Sole extends Herbivore implements Opportuniste
{

	public Sole(String a, String b) 
	{
		super(a, b);
		// TODO Auto-generated constructor stub
	}
	
	public Sole(String a, String b, int nouvelleVie)
	{
		super(a, b, nouvelleVie);
	}

	@Override
	public void seReproduire() 
	{
		
	}

	public String sexualite() 
	{
		return "Opportuniste";
	}

	public void changeSexeOpp(String b) 
	{
		
		if(sexe.equals("MALE"))
			sexe = "FEMELLE";
		else
			sexe = "MALE";
		
	}

	

}


public class PoissonClown extends Carnivore implements Opportuniste
{

	public PoissonClown(String a, String b) {
		super(a, b);
		// TODO Auto-generated constructor stub
	}
	
	public PoissonClown(String a, String b, int nouvelleVie)
	{
		super(a, b, nouvelleVie);
	}

	@Override
	public void seReproduire() {
		// TODO Auto-generated method stub
		
	}
	
	public void changeSexeOpp(String b) 
	{
		if(sexe.equals("MALE"))
			sexe = "FEMELLE";
		else
			sexe = "MALE";
	}
	
	public String sexualite() 
	{
		return "Opportuniste";
	}
}


public class Mérou extends Carnivore implements Hermaphrodite
{

	public Mérou(String a, String b) 
	{
		super(a, b);
		// TODO Auto-generated constructor stub
	}
	
	public Mérou(String a, String b, int nouvelleVie)
	{
		super(a, b, nouvelleVie);
	}


	@Override
	public void seReproduire() 
	{
		// TODO Auto-generated method stub
		
	}

	
	public void changeSexe(String b) 
	{
		if(b.equals("MALE"))
			sexe = "FEMELLE";
		else
			sexe = "MALE";
	}


	public String sexualite() 
	{
		return "Hermaphrodite";
	}
}


public class Bar extends Herbivore implements Hermaphrodite
{


	public Bar(String a, String b) {
		super(a, b);
		// TODO Auto-generated constructor stub
	}
	
	public Bar(String a, String b, int nouvelleVie)
	{
		super(a, b, nouvelleVie);
	}

	@Override
	public void seReproduire() 
	{
		// TODO Auto-generated method stub
		
	}

	public void changeSexe(String b) 
	{
		if(b.equals("MALE"))
			sexe = "FEMELLE";
		else
			sexe = "MALE";
	}

	public String sexualite() 
	{
		return "Hermaphrodite";
	}

	
}


public class Carpe extends Herbivore
{

	public Carpe(String a, String b) {
		super(a, b);
		// TODO Auto-generated constructor stub
	}
	
	public Carpe(String a, String b, int nouvelleVie)
	{
		super(a, b, nouvelleVie);
	}

	@Override
	public void seReproduire() {
		// TODO Auto-generated method stub
		
	}

}


Voila alors il reste la méthode seReproduire() que je n'ai pas utilisée finalement
J'ai levé deux exceptions, je sais pas si je dois en lever d'autres
Merci de ton aide en tout cas :) !
PS : l'utilisation des byte dans le main, c'était pour le fun ^^
PS 2 : ya pas une fonction pour avoir des caractères en aléatoire ? (pour les bébés poissons)
PS 3 : je me rappelais plus de la reflexivité donc je l'ai contournée, mais je peux toujours changer le code j'ai compris maitenant :D
18 avril 2010 à 15:25:59

Salut!
J'ai pris mon temps pour faire jusqu'au 2.2 (exclu).
Voilà les codes :

PackPoissons :

/** Classe Poisson **/

public abstract class Poisson implements PeutEtreMange {

    protected String nom;
    protected Sexe sexe;
    protected RegimeAlimentaire regime;
    protected TypePoisson typePoisson;
    protected TypeAlimentation typeAlimentation;
    protected boolean estMange = false;

    public abstract void action(ArrayList <Poisson> un, ArrayList <Vegetal> deux);

    public void rencontreUnPoisson (Poisson poisson) {
        regime.getAlimentation().queFaireAvecPoisson(poisson);
    }

    public void rencontreUnVegetal (Vegetal vegetal) {
        regime.getAlimentation().queFaireAvecVegetal(vegetal);
    }

    public TypePoisson getTypePoisson () {
        return typePoisson;
    }

    public String getNom() {
        return nom;
    }

    public boolean estMange() {
        return estMange;
    }

    public RegimeAlimentaire getRegime() {
        return regime;
    }

    public Sexe getSexe() {
        return sexe;
    }

    public TypeAlimentation getTypeAlimentation() {
        return typeAlimentation;
    }
}

/** classe PoissonBasique *//

public abstract class PoissonBasique extends Poisson {

    /**
     * Constructeur basique.
     */
    public PoissonBasique() {
        this.sexe = Logique.sexeAleatoire();
        this.nom = Logique.nomAleatoire(Logique.sexeAleatoire(), new ArrayList<Poisson>());
        initialiser();
    }

    /**
     * Constructeur avec paramètres.
     * @param nom
     * @param sexe
     */
    public PoissonBasique(String nom, Sexe sexe) {
        this.nom = nom;
        this.sexe = sexe;
        initialiser();
    }

    public abstract void initialiser();

    @Override
    public String toString() {
        String retournage = "Poisson : TYPE = ";
        switch (this.getTypePoisson()) {
            case MEROU:
                retournage += "Merou |";
                break;
            case BAR:
                retournage += "Bar |";
                break;
            case CARPE:
                retournage += "Carpe |";
                break;
            case POISSONCLOWN:
                retournage += "Poisson Clown |";
                break;
            case THON:
                retournage += "Thon |";
                break;
            case SOL:
                retournage += "Sol |";
                break;
        }
        retournage += " NOM = " + nom + " | SEXE = ";
        switch (sexe) {
            case MALE:
                retournage += "Mâle";
                break;
            case FEMELLE:
                retournage += "Femelle";
                break;
        }
        retournage += " | Régime Alimentaire = ";
        switch (typeAlimentation) {
            case CARNIVORE:
                retournage += "Carnivore";
                break;
            case HERBIVORE:
                retournage += "Herbivore";
                break;
        }
        retournage += " ;";
        return retournage;
    }

    @Override
    public void action(ArrayList<Poisson> poissons, ArrayList<Vegetal> vegetaux) {
        int nombreAleatoire = 0;
        if (Logique.aleatoire(2) == 0) {
            if (!poissons.isEmpty() && poissons.size() > 0) {
                nombreAleatoire = Logique.aleatoire(poissons.size());
                if (nombreAleatoire != poissons.indexOf(this) && !poissons.get(nombreAleatoire).estMange()) {
                    regime.getAlimentation().queFaireAvecPoisson(poissons.get(nombreAleatoire));
                }
            }
        } else if (!vegetaux.isEmpty() && vegetaux.size() > 0) {
            nombreAleatoire = Logique.aleatoire(vegetaux.size());
            if (!vegetaux.get(nombreAleatoire).estMange()) {
                regime.getAlimentation().queFaireAvecVegetal(vegetaux.get(nombreAleatoire));
            }
        }
    }

    public void estMangePar(Poisson poisson) {
        this.estMange = true;
        if (this.sexe == Sexe.MALE) {
            System.out.println(nom + " est mangé par " + poisson.getNom() + "!");
        } else {
            System.out.println(nom + " est mangée par " + poisson.getNom() + "!");
        }
    }
}

/** Classe Thon *//

public class Thon extends PoissonBasique {

 /**
     * Constructeur basique.
     */
    public Thon () {
        super();
    }

    /**
     * Constructeur avec paramètres.
     * @param nom
     * @param sexe
     */
    public Thon (String nom, Sexe sexe) {
        super(nom,sexe);
    }

    public void initialiser () {
        this.typeAlimentation = TypeAlimentation.CARNIVORE;
        this.typePoisson = TypePoisson.THON;
        this.regime = new RegimeAlimentaire (this);
    }
}

// Vu que les autres poissons sont construits pratiquement comme ça je vous épargne les 5 autres 

/** Enumération TypePoisson **/

public enum TypePoisson {
    MEROU,THON,POISSONCLOWN,SOL,BAR,CARPE
}

/** Enumération Sexe **/

public enum Sexe {
        MALE,FEMELLE
    }

//////////////////////////////////////////
Voilà pour le pack Poisson!


Pack Végétaux :
/** classe Végétal **/

public abstract class Vegetal implements PeutEtreMange {

    protected boolean estMange = false;

    public abstract void action();

    public boolean estMange() {
        return estMange;
    }

/** classe Algue **/

public class Algue extends Vegetal {

    public Algue() {
    }

    @Override
    public String toString() {
        return "Algue";
    }

    public void estMangePar(Poisson poisson) {
        System.out.println("Algue est mangée par "+poisson.getNom());
        estMange = true;
    }

    @Override
    public void action() {
    }
}

}


Pack Alimentation :

/** classe RégimeAlimentaire **/

public class RegimeAlimentaire {

    private Alimentation alimentation;
    private Poisson proprietaire;

    public RegimeAlimentaire(Poisson proprietaireParam) {
        this.proprietaire = proprietaireParam;
        switch (proprietaire.getTypeAlimentation()) {
            case CARNIVORE:
                alimentation = new Carnivore() {

                    public void queFaireAvecPoisson(Poisson poisson) {
                        if (poisson.estMange()) {
                            return;
                        }
                        System.out.println(proprietaire.getNom() + " croise le chemin de " + poisson.getNom() + " : " +
                                "étant carnivore, il le mange!");
                        poisson.estMangePar(proprietaire);
                    }

                    public void queFaireAvecVegetal(Vegetal vegetal) {
                        if (vegetal.estMange()) {
                            return;
                        }
                        System.out.println(proprietaire.getNom() + " croise le chemin d'un végétal : " +
                                "étant carnivore, il l'ignore.");
                    }
                };
                break;
            case HERBIVORE:
                alimentation = new Herbivore() {

                    public void queFaireAvecPoisson(Poisson poisson) {
                        if (poisson.estMange()) {
                            return;
                        }
                        System.out.println(proprietaire.getNom() + " croise le chemin de " + poisson.getNom() + " : " +
                                "étant herbivore, il l'ignore.");
                    }

                    public void queFaireAvecVegetal(Vegetal vegetal) {
                        if (vegetal.estMange()) {
                            return;
                        }
                        System.out.println(proprietaire.getNom() + " croise le chemin d'un végétal : " +
                                "étant herbivore, il le mange!");
                        vegetal.estMangePar(proprietaire);
                    }
                };
                break;
        }
    }

    public Alimentation getAlimentation() {
        return alimentation;
    }
}

/** interface Alimentation **/

public interface Alimentation {

    public void queFaireAvecPoisson (Poisson poisson);
    public void queFaireAvecVegetal (Vegetal vegetal);
}

/** interface Herbivore **/

public interface Herbivore extends Alimentation {
}

/** interface Carnivore **/

public interface Carnivore extends Alimentation {

}

/** énumération TypeAlimentation **/

public enum TypeAlimentation {
    CARNIVORE, HERBIVORE
}

/** interface PeutEtreMange **/

public interface PeutEtreMange {

    public void estMangePar (Poisson poisson);
}


Pack Aquarium :
/** classe Aquarium **/

public class Aquarium {

    ////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////        Attributs       ////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////
    private ArrayList<Poisson> listePoissons = new ArrayList<Poisson>();
    private ArrayList<Vegetal> listeVegetaux = new ArrayList<Vegetal>();
    private int nombreDeJours = 0;

    ////////////////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////        Constructeurs       //////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////
    /**
     * Constructeur basique. L'aquarium crée lui-même sa liste de poisson.
     */
    public Aquarium() {
        final int nombreP = Logique.aleatoire(7) + 3;
        final int nombreV = Logique.aleatoire(5) + 2;

        for (int i = 0; i < nombreP; i++) {
            ajouterPoisson(Logique.poissonAleatoire(listePoissons));
        }
        for (int i = 0; i < nombreV; i++) {
            ajouterVegetal();
        }
    }

    /**
     * Constructeur à paramètres définis.
     * @param listeP
     * @param listeV
     */
    public Aquarium(ArrayList<Poisson> listeP, ArrayList<Vegetal> listeV) {
        this.listePoissons = listeP;
        this.listeVegetaux = listeV;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////        Ajout de poissons       ////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////
    /**
     * Méthode permettant d'ajouter un poisson donné en paramètre.
     * @param poisson
     */
    public void ajouterPoisson(Poisson poisson) {
        this.listePoissons.add(poisson);
    }

    /**
     * Méthode permettant d'ajouter un poisson basique.
     * @param poisson
     */
    public void ajouterPoisson() {
        this.listePoissons.add(new Merou());
    }

    /**
     * Méthode permettant d'ajouter un végétal donné en paramètre.
     * @param vegetal
     */
    public void ajouterVegetal(Vegetal vegetal) {
        this.listeVegetaux.add(vegetal);
    }

    /**
     * Méthode permettant d'ajouter une algue quelconque.
     * @param vegetal
     */
    public void ajouterVegetal() {
        this.listeVegetaux.add(new Algue());
    }

    ////////////////////////////////////////////////////////////////////////////////////////////
    ///////////////////////////////////        Temps       /////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////
    public void passerLeTemps() {
        nombreDeJours++;
    }

    public void nettoyerAquarium() {
        ArrayList<Poisson> poissonsAEnlever = new ArrayList<Poisson>();
        ArrayList<Vegetal> vegetauxAEnlever = new ArrayList<Vegetal>();

        for (Poisson poisson : listePoissons) {
            if (poisson.estMange()) {
                poissonsAEnlever.add(poisson);
            }
        }
        for (Vegetal vegetal : listeVegetaux) {
            if (vegetal.estMange()) {
                vegetauxAEnlever.add(vegetal);
            }
        }

        listePoissons.removeAll(poissonsAEnlever);
        listeVegetaux.removeAll(vegetauxAEnlever);
    }

    public void enclencherActions() {
        for (Poisson poisson : listePoissons) {
            poisson.action(listePoissons, listeVegetaux);
        }
        for (Vegetal vegetal : listeVegetaux) {
            vegetal.action();
        }
    }

    public void processusTemps(int jours, int intervalle) {
        for (int i = 0; i < jours; i++) {
            passerLeTemps();
            afficherCompteRendu();
            enclencherActions();
            nettoyerAquarium();
            try {
                Thread.sleep(intervalle);
            } catch (InterruptedException ex) {
                Logger.getLogger(Aquarium.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
    private boolean processusTempsDejaDemarre = false;

    public void demarrerProcessusTemps(int jours, int intervalle) {
        if (processusTempsDejaDemarre) {
            return;
        }
        processusTempsDejaDemarre = true;
        processusTemps(jours, intervalle);
    }

    ////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////        Affichage       ////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////
    public String compteRendu() {
        String compteRendu = "\n\n =============== Jour " + nombreDeJours + " =============== \n\n";
        compteRendu += "Il y a en tout " + listePoissons.size() + " poissons et " +
                listeVegetaux.size() + " végétaux. Voici les détails de chaque poisson :\n\n";
        for (Poisson poisson : listePoissons) {
            compteRendu += "\t - " + poisson.toString() + "\n";
        }
        for (Vegetal vegetal : listeVegetaux) {
            compteRendu += "\t - " + vegetal.toString() + "\n";
        }
        return compteRendu;
    }

    public void afficherCompteRendu() {
        System.out.println(compteRendu());
    }
}



PackLogique :
public class Logique {

    static Random r = new Random();

    public static int aleatoire(int max) {
        return r.nextInt(max);
    }

    public static Poisson poissonAleatoire (Collection<Poisson> poissons) {
        int nombreMystere = Logique.aleatoire(5);
        Sexe sexe = Logique.sexeAleatoire();
        String nomAleatoire = Logique.nomAleatoire(sexe,poissons);
        switch (nombreMystere) {
            case 0 : return new Merou(nomAleatoire,sexe);
            case 1 : return new Sol (nomAleatoire,sexe);
            case 2 : return new Bar (nomAleatoire,sexe);
            case 3 : return new Carpe (nomAleatoire,sexe);
            case 4 : return new PoissonClown (nomAleatoire,sexe);
            case 5 : return new Thon (nomAleatoire,sexe);
            default : return new Thon (nomAleatoire,sexe);
        }
    }

    public static String nomAleatoire(Sexe sexe, Collection<Poisson> poissons) {
        String nomMasculins[] = {"Francis", "Michel", "Robert", "Gilbert", "Gérard", "Jean", "Edouard", "Léopold", "Taylor", "Patrick",
            "Luck", "Pierre", "Christophe", "Vincent", "Boris", "Socrate", "Cicéron"};
        String nomFeminins[] = {"Francisca", "Mireille", "Patricia", "Miqueline", "Micheline", "Nouille", "Clémentine", "Cerise", "Pomme", "Céline",
            "Rachel", "Maman", "Felicia", "Pêche", "Lucie", "Lisa", "Julia", "Manon"};
        while (true) {
            String nomMystere = "";
            if (sexe == Sexe.MALE) {
                nomMystere = nomMasculins[Logique.aleatoire(16)];
            } else {
                nomMystere = nomFeminins[Logique.aleatoire(18)];
            }
            boolean condition = true;
            for (Poisson poisson : poissons) {
                if (poisson.getNom().equals(nomMystere)) {
                    condition = false;
                }
            }
            if (condition) {
                return nomMystere;
            }
        }
    }

    public static Sexe sexeAleatoire() {
        if (Logique.aleatoire(2) == 0) {
            return Sexe.MALE;
        } else {
            return Sexe.FEMELLE;
        }
    }
}



Le main :

public class Main {

    public static void main(String[] args) {
        Aquarium aquarium = new Aquarium ();
        aquarium.demarrerProcessusTemps(5, 1000);
    }

}



Et un aperçu de ce que ça donne :

Citation : Javaquarium


=============== Jour 1 ===============

Il y a en tout 7 poissons et 2 végétaux. Voici les détails de chaque poisson :

- Poisson : TYPE = Poisson Clown | NOM = Edouard | SEXE = Mâle | Régime Alimentaire = Carnivore ;
- Poisson : TYPE = Carpe | NOM = Patrick | SEXE = Mâle | Régime Alimentaire = Herbivore ;
- Poisson : TYPE = Carpe | NOM = Jean | SEXE = Mâle | Régime Alimentaire = Herbivore ;
- Poisson : TYPE = Carpe | NOM = Gérard | SEXE = Mâle | Régime Alimentaire = Herbivore ;
- Poisson : TYPE = Poisson Clown | NOM = Gilbert | SEXE = Mâle | Régime Alimentaire = Carnivore ;
- Poisson : TYPE = Carpe | NOM = Julia | SEXE = Femelle | Régime Alimentaire = Herbivore ;
- Poisson : TYPE = Poisson Clown | NOM = Léopold | SEXE = Mâle | Régime Alimentaire = Carnivore ;
- Algue
- Algue

Edouard croise le chemin de Julia : étant carnivore, il le mange!
Julia est mangée par Edouard!
Patrick croise le chemin de Jean : étant herbivore, il l'ignore.
Gérard croise le chemin d'un végétal : étant herbivore, il le mange!
Algue est mangée par Gérard
Gilbert croise le chemin de Gérard : étant carnivore, il le mange!
Gérard est mangé par Gilbert!
Julia croise le chemin d'un végétal : étant herbivore, il le mange!
Algue est mangée par Julia


=============== Jour 2 ===============

Il y a en tout 5 poissons et 0 végétaux. Voici les détails de chaque poisson :

- Poisson : TYPE = Poisson Clown | NOM = Edouard | SEXE = Mâle | Régime Alimentaire = Carnivore ;
- Poisson : TYPE = Carpe | NOM = Patrick | SEXE = Mâle | Régime Alimentaire = Herbivore ;
- Poisson : TYPE = Carpe | NOM = Jean | SEXE = Mâle | Régime Alimentaire = Herbivore ;
- Poisson : TYPE = Poisson Clown | NOM = Gilbert | SEXE = Mâle | Régime Alimentaire = Carnivore ;
- Poisson : TYPE = Poisson Clown | NOM = Léopold | SEXE = Mâle | Régime Alimentaire = Carnivore ;

Edouard croise le chemin de Gilbert : étant carnivore, il le mange!
Gilbert est mangé par Edouard!
Jean croise le chemin de Patrick : étant herbivore, il l'ignore.
Léopold croise le chemin de Patrick : étant carnivore, il le mange!
Patrick est mangé par Léopold!


=============== Jour 3 ===============

Il y a en tout 3 poissons et 0 végétaux. Voici les détails de chaque poisson :

- Poisson : TYPE = Poisson Clown | NOM = Edouard | SEXE = Mâle | Régime Alimentaire = Carnivore ;
- Poisson : TYPE = Carpe | NOM = Jean | SEXE = Mâle | Régime Alimentaire = Herbivore ;
- Poisson : TYPE = Poisson Clown | NOM = Léopold | SEXE = Mâle | Régime Alimentaire = Carnivore ;

Edouard croise le chemin de Jean : étant carnivore, il le mange!
Jean est mangé par Edouard!
Jean croise le chemin de Léopold : étant herbivore, il l'ignore.


=============== Jour 4 ===============

Il y a en tout 2 poissons et 0 végétaux. Voici les détails de chaque poisson :

- Poisson : TYPE = Poisson Clown | NOM = Edouard | SEXE = Mâle | Régime Alimentaire = Carnivore ;
- Poisson : TYPE = Poisson Clown | NOM = Léopold | SEXE = Mâle | Régime Alimentaire = Carnivore ;

Edouard croise le chemin de Léopold : étant carnivore, il le mange!
Léopold est mangé par Edouard!


=============== Jour 5 ===============

Il y a en tout 1 poissons et 0 végétaux. Voici les détails de chaque poisson :

- Poisson : TYPE = Poisson Clown | NOM = Edouard | SEXE = Mâle | Régime Alimentaire = Carnivore ;

GÉNÉRATION TERMINÉE (durée totale  5 secondes)








19 avril 2010 à 19:32:56

Hello :)

Merci d'organiser ça, c'est excellent pour apprendre !

Je crois que j'ai fini la partie 2.1, mais je ne suis pas très satisfait de ma façon de coder. J'ai l'impression que je me complique la vie et que je n'utilise pas les bons concepts.
En plus je me rends compte que j'ai que dalle commenté :o Si c'est chiant lisez pas, je commenterai plus tard ...

Aquarium.java :
import java.util.ArrayList;
import java.util.Random;

public class Aquarium {

	/**
	 * @param args
	 */
	private static int nbTours = 0;
	private static ArrayList<Poisson> poissons = new ArrayList<Poisson>();
	private static ArrayList<Algue> algues = new ArrayList<Algue>();
	private static ArrayList<Poisson> dejaServis = new ArrayList<Poisson>();
	private static Random rand = new Random();
	
	public static void main(String[] args) {
		Poisson toto = new Poisson("Toto", Poisson.MALE, Poisson.BAR);
		Poisson tata = new Poisson("Tata", Poisson.FEMELLE, Poisson.POISSON_CLOWN);
		Poisson titi = new Poisson("Titi", Poisson.MALE, Poisson.MEROU);
		Poisson tutu = new Poisson("Tutu", Poisson.FEMELLE, Poisson.CARPE);
		Poisson tete = new Poisson("Tete", Poisson.MALE, Poisson.SOLE);
		Poisson tyty = new Poisson("Tyty", Poisson.FEMELLE, Poisson.BAR);
		Poisson tonton = new Poisson("Tonton", Poisson.FEMELLE, Poisson.CARPE);
		Algue a1 = new Algue();
		Algue a2 = new Algue();
		Algue a3 = new Algue();
		Algue a4 = new Algue();
		Algue a5 = new Algue();
		Algue a6 = new Algue();
		Algue a7 = new Algue();
		Algue a8 = new Algue();
		Algue a9 = new Algue();
		Algue a10 = new Algue();
		
		Poisson p[] = {toto, tata, titi, tutu, tete, tyty, tonton};
		ajouter(p);
		Algue a[] = {a1, a2, a3, a4, a5, a6, a7, a8, a9, a10};
		ajouter(a);
		
		System.out.println("Tour n°"+nbTours+" : ");
		System.out.println("Nombre d'algues : "+ compterAlgues());
		System.out.println("Nombre de poissons : "+ compterPoissons());
		afficherPoissons();
		System.out.println("\n--------------------------------------------------");

		Boolean continuer = true;
		do {
			nbTours++;
			tourSuivant();
			if(poissons.size() == 0)
				continuer = false;
			if(algues.size() == 0) {
				if(poissons.size() > 1){
					int nbCarninvores = 0;
					for(int i=0 ; i<poissons.size() && nbCarninvores<1; i++){
						String currentRace = poissons.get(i).getRace();
						if(currentRace.equals(Poisson.POISSON_CLOWN) || currentRace.equals(Poisson.THON) || currentRace.equals(Poisson.MEROU))
							nbCarninvores++;
					}
					if(nbCarninvores<2)
						continuer = false;
				}
			}
			Boolean isHerbivore = false;
			for(int i=0 ; i<poissons.size() && isHerbivore==false; i++){
				String currentRace = poissons.get(i).getRace();
				if(currentRace.equals(Poisson.BAR) || currentRace.equals(Poisson.CARPE) || currentRace.equals(Poisson.SOLE))
					isHerbivore = true;
			}
			if(!isHerbivore && poissons.size() < 2)
				continuer = false;
		}while(continuer == true);
	}

	public static void ajouter(Poisson p) {
		poissons.add(p);
	}
	
	public static void ajouter(Poisson p[]) {
		int max = p.length;
		for(int i=0 ; i<max ; i++) {
			poissons.add(p[i]);
		}
	}
	
	public static void ajouter(Algue a) {
		algues.add(a);
	}
	
	public static void ajouter(Algue a[]) {
		int max = a.length;
		for(int i=0 ; i<max ; i++) {
			algues.add(a[i]);
		}
	}
	
	public static void retirer(Poisson p) {
		int index = poissons.indexOf(p);
		poissons.remove(index);
	}
	
	public static void retirer(Algue a) {
		int index = algues.indexOf(a);
		algues.remove(index);
	}
	
	public static int compterPoissons() {
		return poissons.size();
	}

	private static void afficherPoissons() {
		int max = poissons.size();
		for(int i=0 ; i<max ; i++) {
			System.out.println("- "+ poissons.get(i));
		}
	}
	
	public static int compterAlgues() {
		return algues.size();
	}
	
	public static void tourSuivant() {
		
		do {
			int predateurIndex = rand.nextInt(poissons.size());
			mange(predateurIndex);
		}while(dejaServis.size() <= poissons.size());
		dejaServis.clear();
		
		retirerMorts();
		System.out.println("\nTour n°"+ nbTours +" ! Aujourd'hui :");
		System.out.println("Nombre d'algues : "+ compterAlgues());
		System.out.println("Nombre de poissons : "+ compterPoissons());
		afficherPoissons();
		System.out.println("\n--------------------------------------------------");
	}
	
	public static void retirerMorts() {
		for(int i=0 ; i<poissons.size() ; i++) {
			Poisson current = (Poisson) poissons.get(i);
			if(current.getVivant() == false) {
				poissons.remove(i);
			}
		}
		
		for(int i=0 ; i<algues.size() ; i++) {
			Algue current = (Algue) algues.get(i);
			if(current.getVivant() == false) {
				algues.remove(i);
			}
		}
	}
	
	public static void mange(int predIndex) {
		Poisson predateur = (Poisson) poissons.get(predIndex);
		String race = predateur.getRace();
		//Si le predateur est CARNIVORE
		if(Poisson.MEROU.equals(race) || Poisson.THON.equals(race) || Poisson.POISSON_CLOWN.equals(race)) {
			if(poissons.size() > 1) {
				int proieIndex;
				do {
					proieIndex = rand.nextInt(poissons.size());				
				}while(proieIndex == predIndex);
				Poisson proie = (Poisson) poissons.get(proieIndex);
				proie.meurt();
			}
		}//Si le predateur est HERBIVORE
		else if(Poisson.BAR.equals(race) || Poisson.CARPE.equals(race) || Poisson.SOLE.equals(race)) {
			if(algues.size() > 0) {
				int proieIndex = rand.nextInt(algues.size());
				Algue proie = (Algue) algues.get(proieIndex);
				proie.meurt();
			}
		}
		dejaServis.add(predateur);
		retirerMorts();
	}
}


EtreVivant.java :
public class EtreVivant {
	private Boolean vivant = true;
	
	public void meurt() {
		this.vivant = false;
	}

	public Boolean getVivant() {
		return vivant;
	}

	public void setVivant(Boolean vivant) {
		this.vivant = vivant;
	}
}


Poisson.java :
public class Poisson extends EtreVivant {
	private String nom = "";
	private String sexe = "";
	final static String MALE = "mâle";
	final static String FEMELLE = "femelle";
	private String race = "";
	final static String MEROU = "Mérou";
	final static String THON = "Thon";
	final static String POISSON_CLOWN = "Poisson-Clown";
	final static String SOLE = "Sole";
	final static String BAR = "Bar";
	final static String CARPE = "Carpe";
	
	
	public Poisson(String nom, String sexe, String race) {
		this.nom = nom;
		this.sexe = sexe;
		this.race = race;
	}
	
	public void mange(EtreVivant e) {
		e.meurt();
	}

	public String getNom() {
		return nom;
	}

	public void setNom(String nom) {
		this.nom = nom;
	}

	public String getSexe() {
		return sexe;
	}

	public void setSexe(String sexe) {
		this.sexe = sexe;
	}
	
	public String getRace() {
		return race;
	}

	public void setRace(String race) {
		this.race = race;
	}

	@Override
	public String toString() {
		return this.nom +" ("+ this.race +" "+ this.sexe +")";
	}
}


Algue.java ( :D ):
public class Algue extends EtreVivant {
	
}



En tout cas, merci pour l'exo !
19 avril 2010 à 20:08:47

Bon, je suis désolé, j'ai pas le temps de vous faire une vraie correction pour le moment, mais je vais quand même jeter un œil global à ce que vous avez fait.
Par contre je fais ça juste avec le code, j'ai pas le temps de voir ce qu'il fait quand on le lance.

Satch33
Y'a de l'idée, par contre j'ai pas bien compris pourquoi tu as mis toute la logique dans l'aquarium.
Du coup, on a des bizarreries du genre aqualand.reproduction();
La logique qui concerne les poissons devrait être dans les classes des poissons, celle des algues dans la classe des algues, ...
Apparemment tu ne connais pas les enum, les iterator et les "for avancé" (foreach) de Java 5, ça peut vachement te simplifier la vie.
Pour faire un code vraiment propre et réutilisable, l'idéal aurait été de n'avoir aucun appel à une fonction d'affichage ailleurs que dans la classe de test.
Il me semble que Random peut te sortir des Byte, il faut aller voir la doc.


Topoxy
C'est bizarre.
On voit que tu connais le langage (Enum, classes abstraites, ...) mais j'ai l'impression que tu te compliques beaucoup la vie.
Par exemple : pourquoi à la fois un Enum sur le régime alimentaire et deux interfaces ? L'enum ou les interfaces auraient suffi.
Idem : pourquoi Poisson et PoissonBasique ?
Encore : Pourquoi une méthode aleatoire(int max) qui se contente de faire return r.nextInt(max); - et du coup tu te sers de ta méthode et pas des autres r.nextMachin() qui existent avec Random, cf la doc.

Bref, du coup je suis un peu paumé dans ton code.
N'oublie pas qu'un code simple est un code fiable.

Le constructeur "basique" (celui sans arguments qui se contente d'appeler super(); ) n'est pas obligatoire, il est créé tout seul par le compilateur si aucun constructeur n'est écrit.
Les Enum sont des classes, ils peuvent avoir des attributs. Par exemple, le nom du poisson en français pour l'enum des poissons, ça éviterait l'horrible switch du toString de la classe Poissons.

Et la même remarque qu'à tous les autres : l'idéal serait de ne pas avoir de "system.out.println" ailleurs que dans la fonction de test.


gyom
Je ne te le cache pas (ce serait méchant de ma part en fait), mais tu as tout à fait raison, tu n'utilise pas les bons concepts et te complique la vie : ce que tu as fait n'est pas du Java.
C'est... je sais pas trop. Une espèce de C ou de PHP procédural appliqué tant bien que mal à Java, mais c'est pas du Java.

Visiblement, t'as pas vraiment compris les concepts de la programmation objet. Et c'est dommage, tout mon exo repose là-dessus.
Je te conseille fortement cet excellent tuto (contrairement à ce que peut laisser croire le titre, c'est l'un des meilleurs tutos Java que j'ai jamais lu, et c'est pour tous les publics, pas que pour les enfants).
Tu devrais comprendre à la lecture que la classe avec que des méthodes static, c'est directement un problème.
Enfin, la méthode main() de test devrait être dans une classe spéciale avec juste elle dedans, et aucune "logique" de fonctionnement : juste des appels à des méthodes de tes autres classes.

PS : C'est pas évident du tout la POO sans une bonne explication. Ne prends pas mon commentaire mal, surtout.
5 mai 2010 à 21:08:37

A quand le prochain exo :D ? Parce qu'il était bien celui la !
Ce serait bien d'en faire un avec quelques designs patterns :)
Parce qu'impossible de trouver des exos intéressants sur le sujet :(
5 mai 2010 à 21:19:51

Un nouvel exo, par exemple sur le thème des moteurs physiques serait sympa en effet x)
6 mai 2010 à 8:37:24

Oups...

Bon, très franchement, faire des exos et surtout les corriger me demande plus de temps que prévu et j'en ai moins que prévu.
Et la participation ne me motive pas beaucoup non plus.
9 mai 2010 à 18:15:33

En même temps si il y a un exo tous les quatre mois, ça va pas contribuer à la participation :o .
Et la correction c'est pas le plus important au pire
Enfin bref comme tu veux toute façon, c'est vrai que je comprends que ce soit pas mal de boulot, mais faudrait épingler les topics d'exercices avec les tutoriels pour qu'ils soient plus visités peut être ?
9 mai 2010 à 22:24:19

Citation : Satch33

En même temps si il y a un exo tous les quatre mois, ça va pas contribuer à la participation :o .
Et la correction c'est pas le plus important au pire
Enfin bref comme tu veux toute façon, c'est vrai que je comprends que ce soit pas mal de boulot, mais faudrait épingler les topics d'exercices avec les tutoriels pour qu'ils soient plus visités peut être ?



Ils sont épinglés sur la première page du topic Exos de Zeros. Dans le tableau des exos.
J'ai tous les badges d'OpenClassrooms.
10 mai 2010 à 19:22:45

Je sais, mais genre meme a la limite faire un lien via les tuto' du site direct, pour montrer leur existence aux lecteurs des tutos. Enfin moi je dis ça comme ça ;)
22 mai 2010 à 14:59:30

Bonjour, je commence l'héritage et je trouve le 1.1 TRÈS intéressant pour moi ! J'aimerai la correction de celui-ci mais juste de celui-ci pour m'appuyer un peu , car la, je suis vraiment coincer !!!! =) Merci de votre aide !
22 mai 2010 à 15:14:50

Dans le 1.1 il n'y a pas du tout d'héritage à construire. En revanche dans 1.2... :)
Si tu postais ce que tu as fait pour recevoir quelques conseils ?
29 mai 2010 à 15:08:48

Donc on aura toujours pas d'exo pour le mois de juin ? Dommage ...
30 mai 2010 à 0:12:53

Vu le rapport travail / utilité d'un exo en Java, malheureusement non (et encore en Java ça se comprends, le forum est très peu actif, ce qui peut s'expliquer entre autres par la qualité du tuto officiel ; mais l'exo PHP auquel j'avais participé n'avait pas plus de réponses avec 10x plus de posts par jour... mais je digresse).

Il faudra que je trouve le temps et le courage de pondre des conseils de correction sur celui-ci par contre.
17 décembre 2011 à 2:40:54

Bonjours à tous, bon je ne sais pas si ce sujet est d'actualité mais dans le doute ... ^^
Alors après des heures de dépressions, de multiples tentatives de suicides, des pleurs mais aussi des cris de joies j'arrive enfin à avoir un bout de code un peu près potable (enfin je crois ... j'espère ...). Je me suis arrêté à la question 3.3 (je ne sais pas encore géré les sortie et entrée, pas fini le tuto encore ^^ ) et je préfère avoir des avis sur ce que j'ai fais pour l'instant avant de continuer (enfin si il y a des avis ^^ ).
Algue.java :
import java.util.Random;


public class Algue implements Vieillir, Cloneable{

	private char vivant;
	private int pv;
	private int age;
	
	public Algue(){
		vivant = 'o';
		pv = 10;
		this.initiateAge();
	}
	public Algue clone(){
		Algue a = null;
		try{
			a = (Algue)super.clone();
		}catch(CloneNotSupportedException e){
			e.printStackTrace(System.err);
		}
		
		return a;
	}
	
	public void reproduction(){
		if(this.getAge()>= 10){
			Algue algue = this.clone();
			if(this.getPv()%2 == 0)
				this.setPv(this.getPv()/2);	
			else
				this.setPv((this.getPv()+1)/2);
			algue.setPv(this.getPv());
			algue.setAge(0);
			Aquarium.getNewAlgues().add(algue);
		}
	}
	
	public void vieillir(){
		int age = this.getAge();
		age++;
		this.setAge(age);
	}

	public int initiateAge() {
		Random r = new Random();
		int x = r.nextInt(19);
		age = x;
		return age;
	}
	public int getAge(){
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getPv() {
		return pv;
	}

	public void setPv(int pv) {
		this.pv = pv;
	}

	public char getVivant() {
		return vivant;
	}

	public void setVivant(char vivant) {
		this.vivant = vivant;
	}
	
}


Poisson.java
import java.util.Random;


abstract class Poisson implements Vieillir , Cloneable{
	protected String nom;
	private char sexe;
	private char vivant;
	private int pv;
	private int age;
	protected boolean reproduction;
	
	public Poisson() {
		nom =null;
		sexe = 'n';
		vivant='o';
		pv = 10;
		age = 0;
		reproduction = false;
	}
	
	public Poisson(String pnom, char pSexe){
		
		nom=pnom;
		sexe=pSexe;
		vivant='o';
		pv = 10;
		age = this.initiateAge();
		reproduction = false;
	}

	@Override
	public String toString() {
		return nom + " est de sexe " + sexe+" il lui reste "+pv+" points de vie et il a "+age+" tours";
	}
	
	public int initiateAge(){
		Random r = new Random();
		int x = r.nextInt(19);
		age = x;
		return age;
	}
	
	public boolean isReproduction() {
		return reproduction;
	}

	public void setReproduction(boolean reproduction) {
		this.reproduction = reproduction;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getPv() {
		return pv;
	}

	public void setPv(int pv) {
		this.pv = pv;
	}

	public char getVivant() {
		return vivant;
	}

	public void setVivant(char vivant) {
		this.vivant = vivant;
	}

	public String getNom() {
		return nom;
	}

	public void setNom(String nom) {
		this.nom = nom;
	}

	public char getSexe() {
		return sexe;
	}

	public void setSexe(char sexe) {
		this.sexe = sexe;
	}

	abstract String getRegime();
	
	public boolean compareRace(Poisson p){
		if(this.getClass() == p.getClass()){
			return true;
		}
		else {
			return false;
		}
	}
	public Poisson clone(){
		Object o = null;
		try{
			o = (Poisson)super.clone();
		}catch(CloneNotSupportedException e){
			e.printStackTrace(System.err);
		}
		
		return (Poisson)o;
	}
	protected void initiateEnfant(Poisson p){
		this.setAge(0);
		this.setPv(10);
		this.setNom(p.getNom()+" junior");
		Random r = new Random();
		int x = r.nextInt(2);
		if(x==0)
			this.setSexe('M');
		else this.setSexe('F');
		Aquarium.ajouterEnfant(this);
	}
	public void reproduire() throws CloneNotSupportedException{
		
		// les poissons ne se reproduisent que s'ils ont plus de 5 pv et qu'ils ne se sont pas déjà reproduit dans le tour
		if(this.getPv() > 5 && !reproduction){
			//Trouver un poisson de manière aléatoire dans la liste des poissons.
			Random r = new Random();
			int x = r.nextInt(Aquarium.getPoissons().size());
			Object partenaire = Aquarium.getPoissons().get(x);
			// vérifier qu'ils sont bien de la même race, de sexe opposé et qu'ils ne se sont pas déjà reproduit
			if(this.compareRace((Poisson) partenaire) && this.getSexe() != ((Poisson) partenaire).getSexe() && !((Poisson)partenaire).getReproduction())	{
				Poisson enfant = this.clone();
				((Poisson) enfant).initiateEnfant(this);
				System.out.println(this.nom+" a eu un enfant avec "+Aquarium.getPoissons().get(x).getNom());
				System.out.println("L'enfant s'appelle "+enfant.getNom());
				this.setReproduction(true);
			}
			
		}
	}
	
	protected boolean getReproduction() {
		// TODO Auto-generated method stub
		return false;
	}

	abstract void manger();
}


PoissonHerbivore.java
import java.util.Random;


public abstract class PoissonHerbivore extends Poisson{

	private String regime = "herbivore";
	
	public String getRegime() {
		return regime;
	}

	public void setRegime(String regime) {
		this.regime = regime;
	}

	public PoissonHerbivore() {
		// TODO Auto-generated constructor stub
	}

	public PoissonHerbivore(String pnom, char pSexe) {
		super(pnom, pSexe);
		// TODO Auto-generated constructor stub
	}
	

	void manger() {
		// TODO Auto-generated method stub
							
		if(this.getPv() <=5){
			Random r = new Random();
			int x = r.nextInt(Aquarium.getAlgues().size());
				while(Aquarium.getAlgues().get(x).getVivant() == 'n')
						x = r.nextInt(Aquarium.getPoissons().size());
				
			int miamPv = Aquarium.getAlgues().get(x).getPv()-2;
			Aquarium.getAlgues().get(x).setPv(miamPv);
			int pv = this.getPv()+3;
			this.setPv(pv);
			System.out.println(this.getNom()+" a mangé une algue !");
			}
	}
	
	public void vieillir(){
		int age = this.getAge();
		age++;
		this.setAge(age);
		
	}

}

class Sole extends PoissonHerbivore implements Opportuniste{
	

	
	public Sole(){
		super();
	}
	
	public Sole(String pnom, char pSexe){
		super(pnom, pSexe);
	}

	@Override
	public void opportuniste(Poisson p) {
		// TODO Auto-generated method stub
		if(this.getSexe()==p.getSexe()){
			if(this.getSexe() == 'M')
				this.setSexe('F');
			else this.setSexe('M');
		}
	}
	public void reproduire(){
		// les poissons ne se reproduisent que s'ils ont plus de 5 pv et qu'ils ne se sont pas déjà reproduit dans le tour
				if(this.getPv() > 5 && !reproduction){
					//Trouver un poisson de manière aléatoire dans la liste des poissons.
					Random r = new Random();
					int x = r.nextInt(Aquarium.getPoissons().size());
					Object partenaire = Aquarium.getPoissons().get(x);
					// vérifier qu'ils sont bien de la même race, de sexe opposé et qu'ils ne se sont pas déjà reproduit
					if(this.compareRace((Poisson) partenaire)  && !((Poisson)partenaire).getReproduction())	{
						this.opportuniste((Poisson) partenaire);
						Poisson enfant = this.clone();
						((Poisson) enfant).initiateEnfant(this);
						System.out.println(this.nom+" a eu un enfant avec "+Aquarium.getPoissons().get(x).getNom());
						System.out.println("L'enfant s'appelle "+enfant.getNom());
						this.setReproduction(true);
					}
					
				}
	}

}

class Bar extends PoissonHerbivore{

	
	public Bar(){
		super();
	}
	
	public Bar(String pnom, char pSexe){
		super(pnom, pSexe);
	}

}

class Carpe extends PoissonHerbivore{

	
	public Carpe(){
		super();
	}
	
	public Carpe(String pnom, char pSexe){
		super(pnom, pSexe);
	}

}


PoissonCarnivore.java
import java.util.Random;


public abstract class PoissonCarnivore extends Poisson implements Cloneable{

	private String regime = "carnivore";
	
	public String getRegime() {
		return regime;
	}

	public void setRegime(String regime) {
		this.regime = regime;
	}

	public PoissonCarnivore() {
		// TODO Auto-generated constructor stub
	}

	public PoissonCarnivore(String pnom, char pSexe) {
		super(pnom, pSexe);
		// TODO Auto-generated constructor stub
	}

	
	void manger() {
		// TODO Auto-generated method stub
		
		Random r = new Random();
		int x = r.nextInt(Aquarium.getPoissons().size());
		if(this.getPv() <= 5){
			
			while(x == Aquarium.getPoissons().indexOf(this))
				x = r.nextInt(Aquarium.getPoissons().size());
			
			if(!this.compareRace(Aquarium.getPoissons().get(x))){	
				System.out.println(this.getNom()+" a mangé "+Aquarium.getPoissons().get(x).getNom()+" !");
				int miamPv = Aquarium.getPoissons().get(x).getPv()-4;
				Aquarium.getPoissons().get(x).setPv(miamPv);
				int pv = this.getPv()+5;
				this.setPv(pv);
			}
		}
	}
	
	public void vieillir(){
		int age = this.getAge();
		age++;
		this.setAge(age);
	}

}
class Merou extends PoissonCarnivore implements Cloneable{
	
	
	

	public Merou(){
		super();
	}
	
	public Merou(String pnom, char pSexe){
		super(pnom, pSexe);
	}

	
}

class Thon extends PoissonCarnivore implements Cloneable{
	
	
	public Thon(){
		super();
	}
	
	public Thon(String pnom, char pSexe){
		super(pnom, pSexe);
	}

	
}

class Poisson_clown extends PoissonCarnivore implements Opportuniste{
	
	
	public Poisson_clown(){
		super();
	}

	public Poisson_clown(String pnom, char pSexe){
		super(pnom, pSexe);
	}

	@Override
	public void opportuniste(Poisson p) {
		// TODO Auto-generated method stub
		if(this.getSexe()==p.getSexe()){
			if(this.getSexe() == 'M')
				this.setSexe('F');
			else this.setSexe('M');
		}
		
	}
	public void reproduire(){
		// les poissons ne se reproduisent que s'ils ont plus de 5 pv et qu'ils ne se sont pas déjà reproduit dans le tour
				if(this.getPv() > 5 && !reproduction){
					//Trouver un poisson de manière aléatoire dans la liste des poissons.
					Random r = new Random();
					int x = r.nextInt(Aquarium.getPoissons().size());
					Object partenaire = Aquarium.getPoissons().get(x);
					// vérifier qu'ils sont bien de la même race, de sexe opposé et qu'ils ne se sont pas déjà reproduit
					if(this.compareRace((Poisson) partenaire)  && !((Poisson)partenaire).getReproduction())	{
						this.opportuniste((Poisson) partenaire);
						Poisson enfant = this.clone();
						((Poisson) enfant).initiateEnfant(this);
						System.out.println(this.nom+" a eu un enfant avec "+Aquarium.getPoissons().get(x).getNom());
						System.out.println("L'enfant s'appelle "+enfant.getNom());
						this.setReproduction(true);
					}
					
				}
	}

}


Aquarium.java
import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.Iterator;


public class Aquarium {

	private static ArrayList<Poisson> poissons = new ArrayList<Poisson>();
	private static ArrayList<Algue> algues = new ArrayList<Algue>();
	private static ArrayList<Poisson> enfants = new ArrayList<Poisson>();
	private static ArrayList<Algue> newAlgues = new ArrayList<Algue>();
	public static ArrayList<Poisson> getEnfants() {
		return enfants;
	}

	public static ArrayList<Algue> getNewAlgues() {
		return newAlgues;
	}

	public static void setNewAlgues(ArrayList<Algue> newAlgues) {
		Aquarium.newAlgues = newAlgues;
	}

	public static void setEnfants(ArrayList<Poisson> enfants) {
		Aquarium.enfants = enfants;
	}

	//méthode d'ajout de poisson
	public static void ajouterPoisson(Poisson pPoisson){
		poissons.add(pPoisson);
	}
	// méthode d'ajout d'enfant pour éviter une exception lors de l'itération de passTemps()
	
	public static void ajouterEnfant(Poisson p){
		enfants.add(p);
	}
	
	//méthode d'ajout d'algue
	public static void ajouterAlgue(Algue pAlgue){
		algues.add(pAlgue);
	}
	//méthode d'ajout de plusieurs algues
	public static void ajouterAlgues(int x){
		for(int i=0; i<x; i++){
			Algue algue = new Algue();
			algues.add(algue);
		}
	}
	// methode de suppression de poisson
	public static void supprPoisson(Poisson pPoisson){
		System.out.println("Le poisson "+pPoisson.getNom()+" a été mangé !");
		poissons.remove(poissons.indexOf(pPoisson));
		
	}
	// méthode de suppression d'algue
	public static void supprAlgue(Algue pAlgue){
		System.out.println("une algue a été mangé !");
		algues.remove(algues.indexOf(pAlgue));
		
	}
	
	// Mise à jour de l'aquarium
	private void Maj(){
		
		//Algues mortes sont supprimées
		Iterator<Algue> itAlgue = algues.iterator();
		while(itAlgue.hasNext()){
			try {
				Algue a = (Algue) itAlgue.next();
				if(a.getPv() <= 0 || a.getAge()>=20){
					itAlgue.remove();
				}
			} catch (ConcurrentModificationException e){
				System.out.println(e);
			}
		}
		
		// Poissons morts sont supprimés et reproduction = false pour le prochaine tour !
		Iterator<Poisson> itPoisson = poissons.iterator();
		while(itPoisson.hasNext()){
			try{
				Poisson p = (Poisson) itPoisson.next();
				p.setReproduction(false);
				if (p.getPv() <= 0 || p.getAge()>=20){
					System.out.println(p.getNom()+" est mort !");
					itPoisson.remove();
				}
			} catch (ConcurrentModificationException e){
				System.out.println(e);
			}
		}
	
		// suppression des enfants ajoutés de la liste poissons
		Iterator<Poisson> itEnfants = enfants.iterator();
		while(itEnfants.hasNext()){
			try{
			Poisson p = (Poisson) itEnfants.next();
			ajouterPoisson(p);
			itEnfants.remove();
			} catch (ConcurrentModificationException e){
				System.out.println(e);
			}
		}
		// suppression des algues nées ajoutées à la liste algues
		Iterator<Algue> itNewAlgues = newAlgues.iterator();
		while(itNewAlgues.hasNext()){
			try{
				Algue a = (Algue) itNewAlgues.next();
				ajouterAlgue(a);
				itNewAlgues.remove();
			}catch (ConcurrentModificationException e){
				System.out.println(e);
			}
		}
		// remise à false de reproduction pour le prochain tour
		
		
	}
	public static ArrayList<Poisson> getPoissons(){
		return poissons;
	}
	public static ArrayList<Algue> getAlgues(){
		return algues;
	}
	
	public void listeAquarium(){
		System.out.println("Il reste "+poissons.size()+" poisson(s) et "+algues.size()+" algue(s) dans l'aquarium.");
		for(Poisson pPoisson : poissons){
			System.out.println(pPoisson.toString());
		}
	}
	
	public void passerTemps() throws CloneNotSupportedException{
		listeAquarium();
		System.out.println("----------------------------");
		// Problème pour que la Maj se fasse dans la boucle :/ essayer la double boucle ou autre ArrayList !
		Iterator<Poisson> manger = poissons.iterator();
		
		Iterator<Algue> miam = algues.iterator();
		while(miam.hasNext()){
			Algue a = miam.next();
			a.setPv(a.getPv()+1);
			a.vieillir();
			a.reproduction();
		}
		while(manger.hasNext()){
			Poisson p = manger.next();
			p.manger();
			p.vieillir();
			p.setPv(p.getPv()-1);
			p.reproduire();
		}
		Maj();
		listeAquarium();
	}
	
}


Interface Vieillir (bon rien de bien grandiose mais bon ^^)
public interface Vieillir {

	abstract void vieillir();
}

Interface opportuniste
/**
 * 
 */

/**
 * @author kelto
 *
 */
public interface Opportuniste {
	
	abstract public void opportuniste(Poisson p);

}

Commande.java
import java.util.Scanner;


public class Commande {

	/**
	 * @param args
	 * @throws CloneNotSupportedException 
	 */
	public static void main(String[] args) throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		Aquarium javaquarium = new Aquarium();
		Poisson charles = new Poisson_clown("charles" , 'M');
		Poisson jonathan = new Bar("jonathan", 'M');
		Poisson brieux = new Sole ("brieux", 'M');
		Poisson louis = new Carpe("Louis", 'M');
		Poisson amelie = new Merou("Amelie", 'F');
		Poisson margot = new Carpe("margot", 'F');
		Poisson monique = new Thon("Monique", 'F');
		Poisson christelle = new Poisson_clown("christelle" , 'F');
		Poisson lise = new Bar("Lise", 'F');
		Poisson albane = new Sole("albane" , 'F');
		
		Aquarium.ajouterPoisson(christelle);
		Aquarium.ajouterPoisson(lise);
		Aquarium.ajouterPoisson(albane);
		Aquarium.ajouterPoisson(monique);
		Aquarium.ajouterPoisson(margot);
		Aquarium.ajouterPoisson(amelie);
		Aquarium.ajouterPoisson(charles);
		Aquarium.ajouterPoisson(brieux);
		Aquarium.ajouterPoisson(louis);
		Aquarium.ajouterPoisson(jonathan);
		Aquarium.ajouterAlgues(20);
		
		int i=1;
		Scanner scr = new Scanner(System.in);
		while(!Aquarium.getPoissons().isEmpty() && !Aquarium.getAlgues().isEmpty()){
			
			System.out.println("------------ TOUR "+i+"----------------");
			javaquarium.passerTemps();
			i++;
			System.out.println("Voulez vous continuer ? (O/N)");
			String string = scr.nextLine();
			char reponse = string.charAt(0);
			if(Aquarium.getAlgues().isEmpty()){
				System.out.println("Il n'y a plus d'algues dans l'aquarium, les poissons sont condamnés !!!");
				break;
			}
			else if (Aquarium.getPoissons().isEmpty()) {
				System.out.println("Il n'y a plus de poissons ... l'aquarium est est maintenant désert ... ");
				break;
			}
			while(reponse != 'O' && reponse !='N'){
				System.out.println("Ce n'est pas une réponse possible ! Réessayez ...");
				string = scr.nextLine();
				reponse = string.charAt(0);
			}
			if(reponse == 'N'){
				break;
			}
			
		}
	}
}


En tout cas merci beaucoup spaceFox ! Cet exo est super ! j'en ai bavé mais j'ai appris pas mal de truc ! encore merci =)
20 décembre 2011 à 0:46:28

o_O Cet exo est encore utilisé ? C'est plutôt cool !

Sinon je n'ai pas vraiment le temps de te faire une correction détaillée, mais voici ce que je peux en dire rapidement :
  • Pour moi il manque une classe-mère commune à "poisson" et "algue".
  • Algue, Poisson : Pourquoi "vieillir" est une interface ?
  • Algue : le type "booléen" existe en Java.
  • Algue : Non vraiment, on a pas besoin de clones pour faire cet exercice.
  • Algue, Poisson : pourquoi une méthode pour tirer un âge au hasard ? Attention aux variables inutiles !
  • Algue, Poisson : on naît avec un âge aléatoire ?!
  • Poisson : en Java on a des énumérations très pratiques
  • PoissonHerbivore, PoissonCarnivore : pourquoi "régime" en attribut ?
  • PoissonHerbivore, PoissonCarnivore : pourquoi "manger" en visibilité "package" ?
  • PoissonHerbivore : on peut modifier un champ directement ; encore attention aux variables inutiles
  • Sole, Poisson_clown : Je ne comprends pas la logique de la méthode "opportuniste"
  • Poisson_clown, Aquarium : attention aux conventions de nommage
  • Aquarium : pourquoi des méthodes et des champs sont statiques ?
  • Aquarium : regardes du côté de la boucle "for étendu" en Java pour faire sauter tes iterators
  • Aquarium : il y a plein de logique là-dedans qui devrait être dans les classes
  • Vieillir, Opportuniste : je ne vois pas la logique de cette interface

Bon sinon, j'ai l'impression qu'il y a encore des détails à régler dans ta compréhension du modèle objet.

Jette donc un œil du côté de ce qu'a fait Einstein++, y'a des idées à prendre de ce point de vue là.


Si j'ai le courage demain je vous fait une correction (parmi tant d'autres) de cet exo.
20 décembre 2011 à 1:18:02

En ce qui concerne la variable aléatoire, apparemment lorsqu'on achète un poisson il peut être de n'importe quel âge
  • En ce qui concerne la variable aléatoire, apparemment lorsqu'on achète un poisson il peut être de n'importe quel âge
  • Je comprend pas le "Algue : le type "booléen" existe en Java." J'ai bien utilisé des variable boléenne à plusieurs reprise ?
  • Pour la naissance j'ai rajouté un "setAge(0)
  • Je connais pas les enum (Java est mon premier langage de prog, et c'est mon premier prog, j'irais regarder ^^ )
  • Pour l'attribut régime, j'avais commencer à définir la méthode manger() dans poisson, et j'ai oublié de l'enlever par la suite ^^ , c'est vrai que c'est stupide :x
  • Citation

    PoissonHerbivore, PoissonCarnivore : pourquoi "manger" en visibilité "package" ?

    Je comprend pas :/
  • Citation : SpaceFox

    PoissonHerbivore : on peut modifier un champ directement ; encore attention aux variables inutiles

    Pareil je suis pas sur de comprendre :/
  • Citation : SpaceFox

    Poisson_clown, Aquarium : attention aux conventions de nommage

    J'ai bien respecté le majuscule pour les class, miniscule pour le reste sauf si je commence un nouveau mot, non ? A moins que les conventions de nommage ne soit pas ça :/
  • Citation : SpaceFox

    Aquarium : pourquoi des méthodes et des champs sont statiques ?

    C'est pas encore très clair pour moi les static et non static, j'ai regardé mais pas sur d'avoir bien compris, je referais un tour pour bien l'intégrer


Comme je l'ai dis, c'est mon premier exo, comme je ne comprenais absolument pas le principe et surtout l'utilité de la classe abstraite, héritage et autre, je me suis dis que ça rentrerait en pratiquant ^^
En tout cas merci beaucoup pour les indications ça m'aide beaucoup !! je m'y remet sans tarder :)
Et encore une fois merci pour l'exo, il est parfait =)

edit : j'ai jeté un coup d'oeil au code de Einstein++ mais j'ai pas compris grand chose (les .append, .logger et autres :/) je vais étudier ça :)

[Exo] Javaquarium

× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
  • Editeur
  • Markdown