Aquarium, Proies, Prédateurs, algorithmes Java !

Bonjour a tous, je suis en License 2 de Mathématique à l'Université ! Le seul probleme c'est que je ne suis pas passé par une L1 mais par un classe prépa avant, et je n'est pas fait de java la-bas, ce qui fait que Java pour moi c'est nouveau, et j'ai 1 an de retard par rapport aux autres, je ne comprend donc absolument rien !! :(

J'ai ceci à regarder pour demain mais je ne sais donc pas quoi écrire aux emplacements prévues (voire pièces jointes................:roll:)
Ca m'énerve un peu cette situation car certains de mes profs me rabaissent un peu trop......................!

Salut,

Mais c'est quoi l'énoncé au juste ? Parce que je n'ai pas trouvé dans le code joint une mention de quelque chose qu'il faudrait implémenter ou modifier (enfin, si, je vois des formes de code plus ou moins horribles qu'on pourrait/devrait mieux écrire, mais quelque chose qui ressemble de près ou de loin à un énoncé d'exercice, non. Je pourrais me lancer dans un exercice de divination et imaginer tout ce qu'on veut (comme un bouton pour ajouter un prédateur ou une proie dans l'arène, par exemple), mais ce serait mieux d'avoir un énoncé, histoire de ne pas perdre son temps à répondre à des questions non posées...

De plus, si tu as déjà appris un autre langage que Java, ça ne devrait pas être difficile de comprendre l'algo (des déplacements, des collisions, des trucs comme çà). Pour l'affichage, je veux bien que ça ne te parle pas directement, mais tu peux deviner (ce qu'est une fenêtre, un bouton, tout ça). Pour le reste, sur des points particuliers sur lesquels tu sèches, tu peux poser la question. Mais je ne pense que tu trouveras quelqu'un pour passer la journée à t'expliquer le programme ligne par ligne. Quant à te faire ton exercice d'ici demain, n'y compte pas trop non plus. Déjà, ce n'est pas l'objet de ce forum, mais en plus ça ne servirait pas à apprendre, et tu te retrouverais dans la même situation pour l'exercice suivant.

Si tu ne connais aucun langage de programmation, c'est déjà beaucoup plus difficile, et me semble plutôt compromis pour demain, même si tu trouvais quelqu'un pour passer une nuit blanche à t'expliquer les rudiments de programmation, programmation orientée objet et Java (Pas moi en tout cas, je passe mes nuits blanches sur Destiny en ce moment).

Ah oui pardon voila l'énoncé !! Cela correspond au TP2 a l'intérieur de l'énoncé, le TP1 étant complètement autre chose !!

MDR oui je comprend, passe tes nuit sur Destiny, c'est surement plus amusant ;)

Et non, le seul autre langage que je connais est MAPLE !! Les profs m'ont dit que j'avais beaucoup de boulot, car c'était très loin de JAVA !! En plus en MAPLE, j'étais loin d'être une bête............................!! Peut tu m'aider juste rapidement, au moins le début de ce qu'il faut écrire sur chaque classe ??

Oui, effectivement, Maple et Java, n'ont pas grand chose en commun.

A mon avis, tu vas être obligé de passer par la case "apprentissage des bases" : tu peux commencer par les tutoriels présents sur DVP. En tout cas, sans ces bases, il est difficile de faire quoique ce soit.

Commençons par simple : la question 2b)

Impossible de modifier le constructeur d'une classe, si on ne sait pas ce qu'est une classe, ou ce qu'est un constructeur de classe. Je pourrais te dire que chaque fichier .java définit une classe, définition caractérisée par le début sous la forme "public class NomDeClasse". Mais il faudra voir par toi-même ce que représente ce concept de classe dans un langage orienté objet et les particularités inhérentes au langage Java concernant les classes. Et en particulier, les constructeurs.

Pour simplifier, le constructeur d'une classe, c'est un peu comme une fonction d'initialisation : c'est un sous-programme qui sera exécuté lorsqu'une instance de classe est créée (une classe définit un comportement, et il peut y avoir plusieurs instances particulières (différentes) ayant ce comportement). En Java, le constructeur est une méthode qui a pour nom le nom de la classe, et aucun type de retour.



Le code évoqué est celui-là : le constructeur de la classe Aquarium.

Code:

---

1 2 3 4 5 6 7 8 9 10

Aquarium (int NbProies, int NbPredateurs) { lesProies = new ArrayList(); // 1 this.lesPredateurs = new ArrayList(); // 2   this.lesProies.add( new Proie( Aleatoire(0, ESPACEVITALX) , Aleatoire(0, ESPACEVITALY) ) ); // 3   maFenetre = new Fenetre("Proies Predateurs", 500, 500, this.lesProies, this.lesPredateurs, 0, Color.RED, Color.BLACK); // Création de la fenêtre graphique   }

---

Dans ce constructeur, on passe 2 paramètres : un nombre de proies, appelé NbProies, et un nombre de prédateurs, appelé NpPredateurs. Ensuite, on initialise 2 attributs, qui représent respectivement des listes de proies, et des listes de prédateurs (lignes notées // 1 et // 2).

Puis en //3, on ajoute une instance de classe Proie dans la liste de proies. Comme la question de l'enoncé est d'ajouter autant de proie que NbProies, il suffit de répéter cette opération NbProies fois. Evidemment, on va faire une boucle pour ça. Une boucle for, par exemple. Je ne sais pas s'il y a des for, ou d'autres types de structure, en MAPLE, mais là aussi, il est indispensable que tu apprennes (par toi-même) les bases de la programmation structurée ( les sequences, les options, les alternatives, les boucles...), si tu ne les connais pas déjà.

Voir Tutoriel Oracle.

A la fin on créé une Fenêtre pour l'affichage.

Ensuite, si tu regardes la classe Proie et son constructeur :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

Proie (int xx, int yy ) { this.x = xx; this.y = yy;   this.duréeVie = DUREEVIE; this.gaugeFaim = Aleatoire(3,8); this.pasX = Aleatoire( -2, 2 ); this.pasY = Aleatoire( -2, 2 );     }

---

On voit qu'on initialise la variable duréeVie avec la valeur de DUREEVIE qui est déclarée comme suit :

Code:

---

public static final int DUREEVIE = 300;

---

Donc tu devrais au moins pouvoir répondre à la première partie de la question "La durée de vie d'une proie est de combien normalement ?"; Pour la seconde partie, pour pouvoir y répondre, on voit que cette variable est décrémentée dans la méthode déplacement() :

Code:

---

this.duréeVie--; // il viellit

---

A chaque déplacement, on enlève 1 à duréeVie. Ensuite, il suffit de regarder si dans cette classe, il existe un test qui détermine que si duréeVie==0 (vaut 0) alors la proie est morte. Non. Et comme l'attribut duréeVie est private, seul l'instance peut le tester. Tu peux donc répondre en toute logique à la seconde partie.

Pour le point 2c), on demande justement de coder la méthode mortalité() qui va devoir tester les valeurs de duréeVie de toutes les proies (et prédateurs à priori), pour savoir si elles sont encore vivantes ou mortes. En cas de mort, il faut la supprimer de la liste respective, avec la méthode remove(), ou.

J'ai pas tout compris mais d'accord ! Je vais essayer !

La durée de vie au départ est de 300 pour toutes les proies ?

Citation:

---

Envoyé par TheRogerFederer

La durée de vie au départ est de 300 pour toutes les proies ?

---

Exactement.

Pour la 2ieme partie, je comprend qu'il y est pas besoin de test, mais je comprend pas comment on peut la tester dans la méthode d'instance................. Que faut t'il écrire comme algo pour le tester ?? :(

Si, justement, il faut tester la vie de chaque proie pour savoir si elle est encore vivante.

Donc, il faut parcourir toutes les proies de la liste de proies, pour tester sur chacune d'elles, la vie.

Tu as un exemple de boucle, dans la méthode deplacements() qui fait les déplacements de chaque proie :

Code:

---

1 2 3 4 5 6 7 8

private void deplacements() { for( int j=0; j< this.lesProies.size(); j++) { (this.lesProies.get(j)).deplacement(); }   }

---

donc dans la méthode mortalité, on va avoir une telle boucle, mais au lieu d'appeller la méthode deplacement(), on va tester si la vie vaut zéro. Or la vie est donnée par l'attribut duréeVie de la classe Proie, qui est private, donc non accessible depuis la classe Aquarium. Mais, il y a, dans la classe Proie, une méthode getVie() qui permet de récupérer cette information.

Donc, en gros, on aura quelque chose comme ça :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

private void mortalité() {   // 1) vielles proies for( int j=0; j< this.lesProies.size(); j++) { if ( this.lesProies.get(j).getVie() == 0 ) { // la proie meurt, donc devrait être retirée de la liste lesProies } }   // 2) vieux predateurs   // 3) predation     }

---

On pourrait aussi ajouter une méthode à la classe Proie comme ça :

Code:

---

1 2 3 4

public boolean estMort() { if ( duréeVie==0 ) return true; else return false; }

---

Et appeler cette méthode au lieu de faire le test directement dans mortalité.

Ensuite, il y a une petite difficulté : pour retirer la proie de la liste, si elle est morte, on devrait écrire, par exemple :

Code:

---

1 2 3 4

if ( this.lesProies.get(j).getVie() == 0 ) { // la proie meurt, donc devrait être retirée de la liste lesProies this.lesProies.remove(j); }

---

Mais, lorsque la boucle continue et qu'on passe à l'itération suivante, on va faire j++. Or on vient de retirer un élément de la liste, donc tous les éléments suivant se sont en quelque sorte décalés vers le début de la liste. Donc l'élément suivant immédiatement celui qu'on vient de supprimer, qui était à l'index j+1 est à l'index j maintenant. Puisqu'on fait j++, on "saute" donc le traitement de cet élément.

Exemple : on supprime le j=3, le 4 passe en 3, le 5 en 4, etc... On fait j++, donc j vaut 4, et on ne traite pas celui qui vient de passer en 3.

Comment résoudre ce problème ? Si tu avais déjà une certaine expérience en Java, tu pourrais opter par une autre solution pour faire la boucle (en utilisant un Iterator et sa méthode remove()), mais ce n'est pas le cas. Comment faire alors ? On ne faisant pas le j++ quand on supprime. Ou, autrement dit, en ne le faisant que si on ne supprime pas :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

// 1) vielles proies for( int j=0; j< this.lesProies.size(); ) { // j'ai enlevé l'incrémentation systématique de j à chaque itération if ( this.lesProies.get(j).getVie() == 0 ) { // la proie meurt, donc doit être retirée de la liste lesProies this.lesProies.remove(j); // toutes les proies suivantes dans la liste se décale vers le début de la liste : on a pas besoin d'incrémenter j pour traiter le suivant } else { j++; // on passe à la proie suivante } }

---

Maintenant, si tu veux tester ce code, il faut qu'il soit appelé, or la méthode mortalité() n'est appelée nulle part. Il faut donc l'appeler, probablement dans la boucle principale qui traite toute la vie dans notre aquarium :

Code:

---

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

public void simulation(int nb ) { int temps=0; while (temps != nb) { deplacements(); Proie.regenererNourritureProies(5); System.out.println("Predateurs :"+this.lesPredateurs.size()+" Proies :"+this.lesProies.size() ); mortalité(); // J'AI AJOUTE ICI L'APPEL A MORTALITE temps++; // affichage dans la vue maFenetre.mise_a_jour(this.lesProies, this.lesPredateurs, temps); // mise en jour des variables modèle maFenetre.repaint(); // on redessine la vue try { Thread.sleep(100); // on ralentit la simulation 0.1s ici } catch(InterruptedException e){ } } }

---

Ici, toute la question est "où mettre l'appel à mortalité" : au début de l'itération avant de faire les déplacements et le reste, ou après. Tout dépend de la logique qu'on veut mettre dans l'algo. On peut considérer qu'après avoir évoluer (une étape de l'évolution), on fait un bilan, et on supprime tout ce qui est mort. Mais on peut considérer également qu'avant d'évaluer les déplacements, les prédateurs qui mangent des proies, etc, on veut supprimer les morts, comme ça on aura pas traiter leur déplacement, leur prédation, etc... qui n'a pas vraiment de sens logique.
Dans le procédure globale de succession des itérations ça n'a pas d'importance, qu'on soit au début d'une itération, ou à la fin de la précédente (sauf si l'index de boucle est utilisé dans le traitement, puisque sa valeur pourrait avoir une influence différente). Toutefois, on peut se dire que le faire au début de la première itération ne sert à rien : toute nos créatures ont une vie à 300, donc ne risque pas d'être morte.

Ensuite, appelle-t-on mortalité() avant de mettre à jour l'affichage ou après. Si on le fait après, on va voir des créatures normalement morte, qui ne devrait donc pas apparaitre. A moins qu'on fasse un affichage particulier pour afficher les morts, mais dans ce cas-là aussi, il faut bien faire le traitement avant pour pouvoir l'afficher.

Donc, c'est pourquoi j'ai mis mon appel à l'endroit où je l'ai mis : après les traitements, mais avant l'affichage. Je l'ai mis toutefois avant l'évolution du temps : il me semblait logique que ce bilan fait par la méthode mortalité() devrait être en toute logique dans la même unité de temps que tout le reste, même si en l'occurence, ça n'a pas d'impact, puisque la variable temps n'est pas utilisé dans mortalité(). Mais on pourrait par la suite (genre, à intervalle régulier (pour simuler une saison froide), une créature meurt si sa vie est inférieur à 5 par exemple.

Merci pour le coup de main !! C'était très instructif :D