Mon Javaquarium votre avis svp

a marqué ce sujet comme résolu.

Bonjour,

Je tente de faire l'exercice Javaquarium dont voici l'énoncé : https://zestedesavoir.com/forums/sujet/447/javaquarium/

(Et oui je le fais que maintenant et bien en Java et non Javascript comme je l'avais dit il y a euh longtemps ^^) Voici mes codes https://www.dropbox.com/sh/xq4l0yxnnvkzuxr/AAA8udrkBaJtZ3XnVW4HbtPsa?dl=0 non commentés ou presque (bouh pas bien, vilaine, au bucher) mais avec un uml (ça compense pas vous êtes sûrs ??). Je n'ai fait que le premier exercice (même si la 2ème partie ne change pas grand chose telle que je l'ai faite), mais j'aimerais déjà avoir votre avis. A partir de quand doit-on utiliser l'héritage ? Est-il plus intéressant de faire Poisson donne 2 classes (carnivore, herbivore) qui donnent chacune 3 classes (avec une variable sexualité quand viendra le moment) ou autre chose ? Comment bien représenter alors la liste des poissons présents ? Il me semble que si Carnivore est un Poisson, on ne peut pour autant le forcer à être Poisson sans risquer de perdre des informations non ? A savoir que je ne connais pas vraiment Java ni la POO (c'est la première fois que je pratique vraiment) et que j'aime apprendre "à la volée"…

Merci beaucoup Ccile

Edit : j'avais aussi une question sur l'énoncé : y a-t-il un lien entre le nombre de PVs gagnés par le mangeur et la perte du mangé ? Si A mange un poisson qui n'a que 3PV au lieu de 4, A gagne-t-il quand même les 5PVs ?

+1 -0

Pas de réponse… Mais une personne au moins a vu mon message et a mis -1, pourrais-je au moins savoir pourquoi ? Serais-je au mauvais endroit pour poser des questions ? Merci d'avance Bonne journée

Ccile

Je ne sais pas qui t'as mis un -1, mais tu devrais copier tes codes ici (dans des balises secrètes si c'est trop long).

+0 -0

D'accord merci Donc voici Algue.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Algue
{
    //Variables
    private int numero_algue;
    static private int nombre_algues=0;
     
    //Constructeur
    public Algue()
    {
        nombre_algues++;
        numero_algue=nombre_algues;
    }
     
    //Accesseurs
    public int getNum()
    {
        return numero_algue;
    }
     
    static public int getNbr()
    {
        return nombre_algues;
    }
}

Aquarium.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import java.util.Enumeration;
import java.util.Hashtable;
public class Aquarium
{
    //Variables
    static private int numero_tour=0; /*Pour connaitre le nombre de tour passé*/
    static private Hashtable<Integer,Poisson> poissons=new Hashtable<Integer,Poisson>();
    static private Hashtable<Integer,Algue> algues=new Hashtable<Integer,Algue>();
     
     
    //Méthodes
    static void ajoutPoisson(Poisson poisson)
    {
        poissons.put(Poisson.getNbr()+1,poisson);
    }
     
    static void ajoutAlgue()
    {
        algues.put(Algue.getNbr()+1,new Algue());
    }
     
    static void tourSuivant()
    {
        System.out.println("##### TOUR "+numero_tour+" ######");
        System.out.print("Il y a "+Algue.getNbr()+" algue");
        if(Algue.getNbr()>1)
            System.out.println("s.");
        else
            System.out.println(".");
        System.out.print("Il y a "+Poisson.getNbr()+" poisson");
        if(Poisson.getNbr()>1)
            System.out.print("s.");
        else
            System.out.print(".");
        if(Poisson.getNbr()>0)
        {
            System.out.println(" En voici la liste : ");
            Enumeration e=poissons.elements();
            while(e.hasMoreElements())
            {
                System.out.println(e.nextElement());
            }
        }
        else
            System.out.println();
        numero_tour++;
    }
}

Javaquarium.java (avec le main)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
import java.util.Scanner;
 
public class Javaquarium
{
    private static Scanner sc = new Scanner(System.in);
    public static void ajouterPoisson()
    {
        System.out.println("Veuillez entrer le nom du poisson");
        String nom=sc.next();
        System.out.println("Tapez 0 si c'est une femmelle, 1 si c'est un male");
        int sexe=sc.nextInt();
        while(sexe!=0 && sexe!=1)
        {
            System.out.println("Je n'ai pas compris");
            sexe=sc.nextInt();
        }
        System.out.println("Choisissez la race du poisson");
        String[][] races={{"Merou", " (carnivore)"},{"Thon", " (carnivore)"},{"Poisson_clown", " (carnivore)"},{"Sole"," (herbivore)"},{"Bar"," (herbivore)"},{"Carpe"," (herbivore)"}};
        for(int i=0;i<races.length;i++)
            System.out.println("["+i+"] "+races[i][0]+races[i][1]);
        int num_race=sc.nextInt();
        while(num_race<0 || num_race>=races.length)
        {
            System.out.println("Je n'ai pas compris");
            num_race=sc.nextInt();
        }
        Aquarium.ajoutPoisson(new Poisson(sexe==1,nom,races[num_race][0]));
        System.out.println("Le poisson a ete ajoute");
    }
     
    public static void ajouterAlgue()
    {
        Aquarium.ajoutAlgue();
        System.out.println("L'algue a ete ajoutee");
    }
     
    public static void passerTour()//vraiment besoin de ça ?, directement Aquarium...
    {
        Aquarium.tourSuivant();
    }
     
    public static void main(String[] args)
    {
        boolean terminate=false;
         
        while(!terminate)
        {
            System.out.println("\n\n\tQue voulez-vous faire ?");
            String[] commandes = { "Ajouter un poisson.","Ajouter une algue.", "Passer au tour suivant." };
            System.out.println("##### Commandes #####");
            for (int i = 0; i < commandes.length; i++)
                System.out.println("[" + i + "] " + commandes[i]);
            System.out.println("[Autre chiffre] Quitter.");
            System.out.print("> ");
            int commande = sc.nextInt();
            switch (commande)
            {
                case 0:
                    ajouterPoisson();
                    break;
                case 1:
                    ajouterAlgue();
                    break;
                case 2:
                    passerTour();
                    break;
                default:
                    terminate = true;
                    break;
            }
            if (!terminate)
            {
                pressAnyKeyToContinue();
            }
        }
    }
     
    private static void pressAnyKeyToContinue()
    {
        System.out.println("Appuyer sur une touche pour revenir au menu...");
        try
        {
            System.in.read();
        } 
        catch(Exception e)
        {} 
    }
}

Poisson.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
public class Poisson
{
    //Variables
    private boolean male; //true si le poisson est un male
    private String nom;
    private int numero_poisson;
    private String race;
    private boolean carnivore;
    static private int nombre_poissons=0;
     
    //Constructeur le faire par défaut n'a pas de sens
    public Poisson(boolean male, String nom, String race)
    {
        this.male=male;
        this.nom=nom;
        this.race=race;
        carnivore=(race.equals("Merou") ||race.equals("Thon") || race.equals("Poisson_clown"));
        nombre_poissons++;
        numero_poisson=nombre_poissons;
    }
     
    //Accesseurs
    public boolean getSexe()
    {
        return male;
    }
     
    public String getNom()
    {
        return nom;
    }
     
    public int getNum()
    {
        return numero_poisson;
    }
     
    public String getRace()
    {
        return race;
    }
     
    public boolean getCarnivore()
    {
        return carnivore;
    }
     
    static public int getNbr()
    {
        return nombre_poissons;
    }
     
    //Autres méthodes
    public String toString()
    {
        String sexe="une femmelle";
        String regime="herbivore";
        if(male)
            sexe="un male";
        if(carnivore)
            regime="carnivore";
        return "Le poisson nomme "+nom+" est "+sexe+" "+race+" donc "+regime;
    }
     
    public void mange(Poisson poisson)
    {
        if(carnivore)
            System.out.println(nom+" a mange "+poisson.getNom());
        else
            System.out.println(nom+" a tente de manger "+poisson.getNom()+", mais n'etant pas carnivore, l'a recrache");
    }
     
    public void mange(Algue algue)
    {
        if(!carnivore)
            System.out.println(nom+" a mange une algue");
        else
            System.out.println(nom+" a tente de manger une algue, mais n'etant pas herbivore, l'a recrachee");
    }
}

uml.txt

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
  pseudo ULM
  
  /*Les numérotations commencent à 0*/
  (Problème d'identification pour plus tard... on crée une algue ou un poisson, un meurt, on met donc nbr à jour puis on crée un autre...)
Classe : Aquarium
Variables : 
  numero_tour : entier, static private /*Pour connaitre le nombre de tour passé*/
  poissons : Hashtable<Integer,Poisson> static private /*La liste des poissons*/
  algues : Hashtable<Integer,ALgue> static private /*La liste des algues*/
  
Méthodes : 
  Autres méthodes
  static void ajoutPoissons(int sexe, String nom);/*ajoute un poisson*/
  static void ajoutAlgue();/*ajoute une algue*/
  static void tourSuivant();
      
Classe : Algue
Variables
  numero_algue : entier private /*Pour identifier l'algue*/
  nombre_algues : entier, static private /*Pour connaitre le nombre d'algues*/
  
Méthodes :
  Constructeur 
      public Algue() /*met numero à nombre, augmente nombre*/
  
  Accesseurs
      public int getNum() : entier /*renvoie le numéro de l'algue*/
      static public int getNbr() : entier /*renvoie le nombre d'algues*/
      
  Modificateurs
      /*Aucun car on ne modifie rien (pour l'instant)*/
      
  Autres méthodes
      public void toString();
  
Classe : Poisson
Variables
  numero_poisson : entier private /*Pour identifier le poisson*/
  nom : String private /*Le nom du poisson*/
  male : boolean private /*Le sexe du poisson 0 f,1 m*/
  nombre_poissons : entier, static private /*Pour connaitre le nombre de poissons*/
  race : String, private /*La race du poisson*/
  carnivore : boolean, private /*true si le poisson est carnivore, faux sinon*/
  
Méthodes :
  Constructeur
      public Poisson(int sexe, String nom,String race);/*carnivore est mis automatiquement*/
      
  Accesseurs
      public boolean getSexe();
      public String getNom();
      public int getNum();
      static public int getNbr();
      public String getRace();
      public boolean getCarnivore();
      
  Modificateurs
      /*Aucun car on ne modifie rien (pour l'instant)*/
  
  Autres méthodes
      public String toString();
      public void mange(Poisson poisson);
      public void mange(Algue algue);
  
Classe Javaquarium
  main

Merci d'avance

+0 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte