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 Exact, je supposait plutôt que tu lui donnais son âge à la main mais cette solution est tout à fait valable.
Je comprend pas le "Algue : le type "booléen" existe en Java." J'ai bien utilisé des variable boléenne à plusieurs reprise ? Je ne crois pas. Par exemple , pourquoi "vivant" est de type "char" ?
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 :/ Cf les système de portée des variables et méthodes (private, package, protected, public)
Citation : SpaceFox
PoissonHerbivore : on peut modifier un champ directement ; encore attention aux variables inutiles
Pareil je suis pas sur de comprendre :/ Tu as tendance à ajouter des variables intermédiaires inutiles et qui ne rendent pas le code plus clair.
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 :/ Poisson_clown devrait s'appeler PoissonClown
La méthode Maj de Aquarium devrait s'appeler maj.
De mémoire il y a un topic en post-it dans ce forum qui explique tout ça en détail.
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 Ce n'est pas toujours facile de déterminer ce qui doit être statique ou non, surtout avec cet exercice.
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 C'est exactement le but de l'exercice
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 Les .append et .logger sont des méthodes pour gérer la sortie. Regarde surtout la structure de classes et d'héritage, c'est ça le plus intéressant. Revoir les concepts d'interfaces, il n'est pas toujours bien compris et je pense que tu peux t'améliorer sur ce point.
Super exo SpaceFox, ça m'a fait travaillé !
Pour moi, je me suis arrêté après la reproduction, mais ce que j'ai fait est trop "Bourrin", ça marche assez bien, en tous cas assez pour que je le poste :
Aquarium.java
import java.util.*;
public class Aquarium
{
private ArrayList<Poisson> poissons = new ArrayList<Poisson>();
private ArrayList<Algue> algues = new ArrayList<Algue>();
public void addPoisson(Poisson p)
{
poissons.add(p);
}
public void addAlgue(Algue a)
{
algues.add(a);
}
public void passerTour()
{
System.out.println("Il y a (algues mortes comprises) " + algues.size() + " algues dans l'Aquarium.");
for(Poisson fish : this.poissons)
{
if(fish.vivant() == true)
{
System.out.println("Nom : " + fish.nom() + "\n" + "Genre : " + fish.genre() + "\n" + "PV : " + fish.pv());
fish.vieillir();
fish.degats(1);
if(fish.pv() <= 5)
{
if(fish instanceof Herbivore)
{
((Herbivore) fish).manger(this);
}
else if(fish instanceof Carnivore)
{
((Carnivore) fish).manger(this);
}
}
}
}
for(Algue algue : this.algues)
{
algue.gagnerPv(1);
}
}
public ArrayList<Poisson> fishes()
{
return this.poissons;
}
public ArrayList<Algue> algues()
{
return this.algues;
}
}
Poisson.java
import java.util.*;
public abstract class Poisson
{
protected String nom;
protected Genre genre;
protected int pv;
protected boolean vivant = true;
protected int age;
protected Espece espece;
public Poisson(String name, Genre g, Espece sp)
{
this.nom = name;
this.genre = g;
this.vivant = true;
this.pv = 10;
Random rand = new Random();
int agep = rand.nextInt(20) + 1;
this.age = agep;
this.espece = sp;
}
public Poisson(String name, Genre g, Espece sp, int agep)
{
this.nom = name;
this.genre = g;
this.vivant = true;
this.pv = 10;
this.age = agep;
this.espece = sp;
}
public void vieillir()
{
this.age++;
if(this.age > 20)
{
this.vivant = false;
}
}
public void augmenterPv(int nbre)
{
if (vivant)
{
this.pv += nbre;
if(this.pv > 10)
{
this.pv = 10;
}
}
}
public void degats(int nbre)
{
this.pv -= nbre;
if(this.pv <= 0)
{
this.vivant = false;
}
}
public void seReproduire(Aquarium a)
{
ArrayList<Poisson> array = a.fishes();
Random rand = new Random();
if(array.size() > 1)
{
int hasard = rand.nextInt(array.size());
Poisson cible = array.get(hasard);
if(isGenreOppose(this, cible))
{
int genre = rand.nextInt(2);
Genre gr = (genre == 0) ? Genre.MALE : Genre.FEMELLE;
Poisson child;
if(this.espece.toString().equalsIgnoreCase("CARPE"))
{
child = new Carpe(this.nom + " Junior", gr);
}
else if(this.espece.toString().equalsIgnoreCase("THON"))
{
child = new Thon(this.nom + " Junior", gr);
}
else if(this.espece.toString().equalsIgnoreCase("POISSON_CLOWN"))
{
child = new PoissonClown(this.nom + " Junior", gr);
}
else if(this.espece.toString().equalsIgnoreCase("SOLE"))
{
child = new Sole(this.nom + " Junior", gr);
}
else if(this.espece.toString().equalsIgnoreCase("BAR"))
{
child = new Bar(this.nom + " Junior", gr);
}
else if(this.espece.toString().equalsIgnoreCase("MEROU"))
{
child = new Merou(this.nom + " Junior", gr);
}
else
{
child = new Carpe(this.nom + " Junior", gr); // On mets un herbivore pour être gentil
}
a.addPoisson(child);
}
}
}
public boolean isGenreOppose(Poisson p, Poisson p2)
{
if(p.genre().equals(Genre.FEMELLE))
{
if(p2.genre().equals(Genre.MALE))
{
return true;
}
else
{
return false;
}
}
else
{
if(p2.genre().equals(Genre.FEMELLE))
{
return true;
}
else
{
return false;
}
}
}
public Espece espece()
{
return this.espece;
}
public String nom()
{
return this.nom;
}
public Genre genre()
{
return this.genre;
}
public int pv()
{
return this.pv;
}
public boolean vivant()
{
return this.vivant;
}
}
Herbivore.java
import java.util.ArrayList;
import java.util.Random;
public abstract class Herbivore extends Poisson
{
public Herbivore(String name, Genre g, Espece sp)
{
super(name, g, sp);
}
public void manger(Aquarium a)
{
Random rand = new Random();
ArrayList<Algue> array = a.algues();
if(array.size() > 0)
{
int hasard = rand.nextInt(array.size());
Algue victime = array.get(hasard);
victime.degats(2);
this.augmenterPv(3);
System.out.println(this.nom + " a voulu manger une algue !");
}
}
}
class Sole extends Herbivore
{
public Sole(String name, Genre g)
{
super(name, g, Espece.SOLE);
}
}
class Bar extends Herbivore
{
public Bar(String name, Genre g)
{
super(name, g, Espece.BAR);
}
}
class Carpe extends Herbivore
{
public Carpe(String name, Genre g)
{
super(name, g, Espece.CARPE);
}
}
Carnivore.java
import java.util.ArrayList;
import java.util.Random;
public abstract class Carnivore extends Poisson
{
public Carnivore(String name, Genre g, Espece sp)
{
super(name, g, sp);
}
public void manger(Aquarium a)
{
Random rand = new Random();
ArrayList<Poisson> array = a.fishes();
Poisson victime;
if(array.size() > 1)
{
do
{
int hasard = rand.nextInt(array.size());
victime = array.get(hasard);
} while(victime.nom().equals(this.nom()) || victime.espece().equals(this.espece) || victime.vivant() == false);
victime.degats(4);
this.augmenterPv(5);
System.out.println(this.nom + " a voulu manger " + victime.nom + " !");
}
else
{
System.out.println(this.nom() + " est carnivore, et il y n'y a personne à manger... :(");
}
}
}
class Merou extends Carnivore
{
public Merou(String name, Genre g)
{
super(name, g, Espece.MEROU);
}
}
class Thon extends Carnivore
{
public Thon(String name, Genre g)
{
super(name, g, Espece.THON);
}
}
class PoissonClown extends Carnivore
{
public PoissonClown(String name, Genre g)
{
super(name, g, Espece.POISSON_CLOWN);
}
}
Algue.java
public class Algue
{
public int pv;
public boolean vivant;
public Algue()
{
this.pv = 10;
this.vivant = true;
}
public void gagnerPv(int nbre)
{
this.pv += nbre;
if(this.pv > 10)
{
this.pv = 10;
}
}
public void augmenterPv(int nbre)
{
if (vivant)
{
this.pv += nbre;
if(this.pv > 10)
{
this.pv = 10;
}
}
}
public void degats(int nbre)
{
this.pv -= nbre;
if(this.pv <= 0)
{
this.pv = 0;
this.vivant = false;
}
}
}
Espece.java
public enum Espece
{
CARPE, THON, BAR, SOLE, POISSON_CLOWN, MEROU;
}
Genre.java
public enum Genre
{
MALE, FEMELLE;
}
Test.java (main)
public class Test
{
public static void main(String[] args)
{
Aquarium aq = new Aquarium();
Poisson bouboule = new Thon("Bouboule", Genre.MALE);
Poisson baballe = new Thon("Baballe", Genre.FEMELLE);
Poisson dejeuner = new Sole("Dejeuner", Genre.MALE);
Poisson spectateur = new Carpe("Spectateur", Genre.FEMELLE);
Algue a1 = new Algue();
Algue a2 = new Algue();
aq.addPoisson(bouboule);
aq.addPoisson(baballe);
aq.addPoisson(dejeuner);
aq.addPoisson(spectateur);
aq.addAlgue(a1);
aq.addAlgue(a2);
for(int i = 0; i < 25; i++)
{
aq.passerTour();
System.out.println("\n========== Tour " + (i + 1) + " ==========");
if(i == 15)
{
Poisson nouveau = new Carpe("Nouveau", Genre.MALE);
aq.addPoisson(nouveau);
}
}
}
}
Bonjour à tous, après trois mois de cours de java ... j'avais envie de tester un peu mon niveau, donc j'ai essayer de faire cet exercice, très intéressant.
Je me suis arrêté à la question 3.2, voici ce que ça donne :
etreVivant.java
public abstract class etreVivant {
protected int nombreDePv;
protected int age;
public etreVivant() {
this.nombreDePv = 10;
this.age = 0;
}
public etreVivant(int age, int Pv) {
this.nombreDePv = Pv;
this.age = age;
}
public abstract void etreMange();
public int obtenirNbrPv() {
return this.nombreDePv;
}
public void retirerPv(int nbr) {
this.nombreDePv -= nbr;
}
public void ajouterPv(int nbr) {
this.nombreDePv += nbr;
}
public void modifierPv(int nbr) {
this.nombreDePv = nbr;
}
public void incrementerAge() {
this.age++;
}
public int obtenirAge() {
return this.age;
}
}
Algue.java
public class Algue extends etreVivant {
public Algue() {
super();
}
public Algue(int age) {
super(age, 10);
}
public Algue(int age, int Pv) {
super(age, Pv);
}
public String toString() {
return "Algue PV: " + nombreDePv + "\n";
}
public void grandir() {
this.ajouterPv(1);
}
public void etreMange() {
this.retirerPv(2);
}
}
Poisson.java
public abstract class Poisson extends etreVivant {
private String nomDuPoisson = new String();
private char sexeDuPoisson;
private String raceDuPoisson = new String();
public Poisson(String nom, char sexe, String race) {
this.nomDuPoisson = nom;
this.sexeDuPoisson = sexe;
this.raceDuPoisson = race;
}
public Poisson(String nom, char sexe, String race, int age) {
this.nomDuPoisson = nom;
this.sexeDuPoisson = sexe;
this.raceDuPoisson = race;
this.age = age;
}
public String toString() {
return "nom: " + this.nomDuPoisson + " sexe: " + this.sexeDuPoisson
+ " race: " + this.raceDuPoisson + " PV: " + this.nombreDePv
+ "\n";
}
public char obtenirSexe() {
return this.sexeDuPoisson;
}
public String obtenirNom() {
return this.nomDuPoisson;
}
public void faim() {
this.retirerPv(1);
}
public String obtenirRace() {
return this.raceDuPoisson;
}
public void etreMange() {
this.retirerPv(4);
}
public abstract void manger(etreVivant etreVivantCible);
public boolean peuventSeReproduire(Poisson poissonCibleReproduction) {
return poissonCibleReproduction.obtenirRace()
.equals(this.obtenirRace())
&& poissonCibleReproduction.obtenirSexe() != this.obtenirSexe();
}
}
PoissonHerbivore.java
import java.util.Random;
public class PoissonHerbivore extends Poisson {
Random r = new Random();
public PoissonHerbivore(String nom, char sexe, String race) {
super(nom, sexe, race);
}
public void manger(etreVivant algueCible) {
algueCible.etreMange();
this.ajouterPv(3);
}
public String toString() {
return "Poisson herbivore : " + super.toString();
}
}
PoissonCarnivore.java
public class PoissonCarnivore extends Poisson {
public PoissonCarnivore(String nom, char sexe, String race) {
super(nom, sexe, race);
}
public void manger(etreVivant poissonCible) {
if (poissonCible != this
&& !(this.obtenirRace().equals(((Poisson) poissonCible)
.obtenirRace()))) {
poissonCible.etreMange();
this.ajouterPv(5);
}
}
public String toString() {
return "Poisson carnivore : " + super.toString();
}
}
Aquarium.java
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class Aquarium {
private int tour;
private List<Poisson> listeDesPoissons;
private List<Algue> listeDesAlgues;
Random r = new Random();
public Aquarium() {
listeDesPoissons = new ArrayList<Poisson>();
listeDesAlgues = new ArrayList<Algue>();
tour = 0;
}
public void ajoutePoisson(String nom, char sexe, String race) {
if (race.equals("Mérou") || race.equals("Thon")
|| race.equals("Poisson-clown")) {
listeDesPoissons.add(new PoissonCarnivore(nom, sexe, race));
} else {
listeDesPoissons.add(new PoissonHerbivore(nom, sexe, race));
}
}
public void ajouteAlgue() {
listeDesAlgues.add(new Algue());
}
public void ajouteAlgue(int age, int Pv) {
listeDesAlgues.add(new Algue(age, Pv));
}
public String toString() {
String poissons = new String();
String algues = new String();
for (Poisson P : listeDesPoissons) {
poissons += P;
}
poissons = listeDesPoissons.size() + " Poissons :\n" + poissons;
for (Algue A : listeDesAlgues) {
algues += A;
}
algues = listeDesAlgues.size() + " Algues :\n" + algues;
return "----------------------------------\n"
+ "Composition de l'aquarium (tour " + this.tour + ")\n"
+ "----------------------------------\n" + poissons + algues;
}
public void nettoyer() {
Poisson poissonASupprimer = null;
for (Poisson p : listeDesPoissons) {
if (p.obtenirAge() > 20 || p.obtenirNbrPv() <= 0) {
poissonASupprimer = p;
}
}
listeDesPoissons.remove(poissonASupprimer);
Algue algueASupprimer = null;
for (Algue a : listeDesAlgues) {
if (a.obtenirAge() > 20) {
algueASupprimer = a;
}
}
listeDesAlgues.remove(algueASupprimer);
}
public void nouveauTour() {
int nbrAlgueAAjouter = 0;
for (Algue a : listeDesAlgues) {
if (a.obtenirNbrPv() >= 10) {
a.modifierPv(a.obtenirNbrPv() / 2);
nbrAlgueAAjouter++;
}
a.grandir();
a.incrementerAge();
}
for (int i = 0; i < nbrAlgueAAjouter; i++) {
this.ajouteAlgue(0, 5);
}
List<Poisson> listeDesParents = new ArrayList<Poisson>();
for (Poisson p : listeDesPoissons) {
p.faim();
p.incrementerAge();
if (p.obtenirNbrPv() <= 5) {
if (p instanceof PoissonCarnivore) {
int indiceDeLaCible = r.nextInt(listeDesPoissons.size());
p.manger(listeDesPoissons.get(indiceDeLaCible));
} else {
int indiceDeLaCible = r.nextInt(listeDesAlgues.size());
p.manger(listeDesAlgues.get(indiceDeLaCible));
}
} else {
Poisson PoissonCibleRepro = listeDesPoissons.get(r
.nextInt(listeDesPoissons.size()));
if (p.peuventSeReproduire(PoissonCibleRepro)) {
listeDesParents.add(p);
}
}
}
for (Poisson p : listeDesParents) {
if (r.nextInt(2) == 0) {
this.ajoutePoisson("enfant de " + p.obtenirNom(), 'M',
p.obtenirRace());
} else {
this.ajoutePoisson("enfant de " + p.obtenirNom(), 'F',
p.obtenirRace());
}
}
this.nettoyer();
tour++;
}
}
Tests.java
public class Tests {
public static void main(String[] args) {
Aquarium aq1 = new Aquarium();
aq1.ajoutePoisson("Orus", 'M', "Thon");
aq1.ajoutePoisson("Ré", 'M', "Carpe");
aq1.ajoutePoisson("Anubis", 'M', "Poisson-clown");
aq1.ajoutePoisson("Isis", 'F', "Poisson-clown");
aq1.ajouteAlgue();
aq1.ajouteAlgue();
for (int i = 0; i < 5; i++) {
System.out.println(aq1);
aq1.nouveauTour();
}
}
}
Voilà, vous en pensez quoi ? Comment je peux améliorer mon programme ?
salut je sais pas si il existe encore des gens qui regardent par ici ... ;)(et c'est dommage je trouve l'exo très marrant)
Pour résoudre le problème j'ai crée une classe générique non instanciée (avec des membres et fonctions static) qui gere l'ArrayList, en partant du principe que les poissons et algues l'implémenterais directement
ci joint mon code pour la partie 1.1. Commentaires et remarques bienvenus
classe aquarium
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*
* Le site du ZERO
*
* http://www.siteduzero.com/forum/sujet/exo-javaquarium-26798#r4816050
*
* 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 :
L'initialisation : les poissons et les algues sont ajoutés dans l'aquarium
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.
*/
package aquarium;
import java.util.ArrayList;
import java.util.Scanner;
/**
*
* @author Stéphane KERESZTES
*/
public class Aquarium {
// variables de classe
static int saisieMenuNum = 255; // variable saisie de menu numérique
static String saisieMenuTxt = "255"; // variable saisie de menu txt
static String attente; // variable de saisie pour temps d'attente apres un affichage de message de traitement
static ArrayList aquarium = new ArrayList(); // tableau d'objet contenant les objets de l'aquarium
static Scanner lectureSaisie = new Scanner(System.in);
static char attenteChar;
static char attenteString;
/**
* MAIN de la gestion d'un aquarium Affichage du Menu principal du
* programme, Appel des traitements en fonction du choix du menu, Sortie du
* programme,
*
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
Scanner lectureMenu = new Scanner(System.in);
//
// Affichage du Menu principal du programme
//
while (saisieMenuNum != 0) {
effaceEcran();
System.out.println("-------------------------------------");
System.out.println("- Gestion d'un aquarium virtuel -");
System.out.println("-------------------------------------");
System.out.println();
System.out.println();
System.out.println();
System.out.println("Menu principal");
System.out.println();
System.out.println("Creer un poisson 1");
System.out.println("Creer une algue 2");
System.out.println("Simuler temps qui passe 3");
System.out.println("Fin du programme 0");
//
// Appel des traitements en fonction du choix du menu
//
System.out.println();
System.out.print("Votre choix ? : ");
saisieMenuTxt = lectureMenu.next();
saisieMenuNum = controleSaisieMenu(saisieMenuTxt);
System.out.println();
switch (saisieMenuNum) {
case 1: {
addPoisson();
break;
}
case 2: {
addAlgue();
break;
}
case 3: {
simuleTempsQuiPasse();
afficheContenuAquarium();
break;
}
default: {
break;
}
}
}
//
// Sortie du programme
//
System.out.println("Fin du programme, au revoir .... ");
System.exit(0);
}
/**
* Simule un efface écran ou clearscreen en ecrivant plusieurs lignes
* blanches dans le System.out
*
* @param none
* @return none
*/
public static void effaceEcran() {
int nombreSautDeLigne = 10;
for (int i = 1; i <= nombreSautDeLigne; i++) {
System.out.println();
}
}
/**
* Créé une nouvelle instance de poisson
*
* @param none
* @return none
*/
public static void addPoisson() {
String finMethode = "0";
String saisieMenuPoisson = "zz";
String saisieNomPoisson = "initial";
char saisieSexePoisson = 'I';
Scanner lectureClavier = new Scanner(System.in);
System.out.print("saisir le nom du poisson (0 pour fin de saisie) : ");
saisieMenuPoisson = lectureClavier.next();
if (!saisieMenuPoisson.equals(finMethode)) {
System.out.println();
saisieNomPoisson = saisieMenuPoisson;
while ((saisieSexePoisson != 'm') && (saisieSexePoisson != 'f')) {
System.out.print("saisir le sexe du poisson m(male) f(femmelle): ");
saisieSexePoisson = lectureClavier.next().charAt(0);
System.out.println();
}
Poisson Poisson = new Poisson();
Poisson.setNomPoisson(saisieNomPoisson);
Poisson.setSexePoisson(saisieSexePoisson);
sauvegardeInstance(Poisson);
//Message du traitement
//System.out.println("Un poisson nommé " + saisieNomPoisson + " de sexe " + saisieSexePoisson + " a été créé");
//attente = lectureSaisie.next();
}
}
/**
* Créé une nouvelle instance Algue
*
* @param none
* @return créé une instance de algue
*/
public static void addAlgue() {
Algue Algue = new Algue();
Algue.setAlgueExiste(true);
sauvegardeInstance(Algue);
}
/**
* Simule le temps qui passe ne fait rien au stade 1.1
*
* @param none
* @return none
*
*/
public static void simuleTempsQuiPasse() {
}
/**
* test la numéricité d'une saisie
*
* @param champ saisi dans le menu principale
* @return le champ saisi est retourné si l'entree est numerique sinon
* retourne 255
*
*/
public static int controleSaisieMenu(String saisie) {
int i = 0;
try {
i = Integer.parseInt(saisie);
} catch (NumberFormatException nfe) {
i = 255;
}
return i;
}
/**
* Sauvegarde l'instance d'un objet de l'aquarium dans un tableau d'objet
*
* @param l'objet à sauvegarder
* @return none *
*/
public static void sauvegardeInstance(Object objet) {
aquarium.add(objet);
}
/**
* Affiche le contenu de l'aquarium, stocké dans un tableau d'objet.
*
* @param none
* @return none *
*/
public static void afficheContenuAquarium() {
//affichage du nombre d'algues
int nombreAlgue = 0;
for (int i = 0; i < aquarium.size(); i++) {
if (aquarium.get(i) instanceof Algue) {
nombreAlgue++;
}
}
System.out.println("nombre d'algues présente " + nombreAlgue);
//affichage de la liste des poissons avec nom et sexe
for (int i = 0; i < aquarium.size(); i++) {
if (aquarium.get(i) instanceof Poisson) {
Poisson Poisson = new Poisson();
Poisson = (Poisson) aquarium.get(i);
System.out.println(" présent poisson nommé " + Poisson.getNomPoisson() + " sexe " + Poisson.getSexePoisson());
}
}
// //Message de fin de traitement
// //System.out.print("( taper le caractère 'c' pour continuer )");
// attenteChar = lectureSaisie.next().charAt(0);
// while (attenteChar != 'c') {
// attenteChar = lectureSaisie.next().charAt(0);
// }
}
}
class poisson
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package aquarium;
/**
*
* @author sccvt
*/
public class Poisson {
private String nomPoisson;
private char sexePoisson;
static int nombrePoissonCréé = 0;
public Poisson() {
nombrePoissonCréé ++;
nomPoisson = "initial";
sexePoisson = 'i';
}
/**
* @return the nomPoisson
*/
public String getNomPoisson() {
return nomPoisson;
}
/**
* @return the sexePoisson
*/
public char getSexePoisson() {
return sexePoisson;
}
/**
* @param nomPoisson the nomPoisson to set
*/
public void setNomPoisson(String nomPoisson) {
this.nomPoisson = nomPoisson;
}
/**
* @param sexePoisson the sexePoisson to set
*/
public void setSexePoisson(char sexePoisson) {
this.sexePoisson = sexePoisson;
}
}
class algue
*
* @author sccvt
*/
public class Algue {
private boolean algueExiste;
static int nombreAlgueCréé = 0;
public Algue() {
nombreAlgueCréé ++;
algueExiste = false;
}
/**
* @return the algueExiste
*/
public boolean AlgueExiste() {
return algueExiste;
}
/**
* @param algueExiste the algueExiste to set
*/
public void setAlgueExiste(boolean algueExiste) {
this.algueExiste = algueExiste;
}
}
- Edité par skeres95250 7 septembre 2013 à 15:45:19
Ce qui m'étonne dans les différentes tentatives, c'est de ne pas voir d'extension de classe Mérou ou Thon qui hériterait de Poisson. Ce n'est vraiment pas nécessaire ?
Cet exo, quoique très ancien, m'intéresse fortement. Je crois que je vais essayer de le programmer sur le champ. Mais j'ai une petite question : peut-on créer une IHM si on est suffisamment motivé ? Perso je suis très motivé pour n'importe quel programme.
Bon exos, je me suis arrêté à la partit 3(c'est à dire exe 3.3) voilà mon code:
Aquarium.java:
package Javaquarium;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
public class Aquarium {
private List<Fish> fishes;
private List<Algue> algues;
private int tours;
public Aquarium() {
this.fishes = new ArrayList<>();
this.algues = new ArrayList<>();
this.tours = 0;
}
public void addAlgue(Algue a) {
this.algues.add(a);
}
public void addFish(Fish p) {
this.fishes.add(p);
}
public void removeDeadFish() {
this.fishes = this.fishes.stream().filter(p -> ! p.isDead).collect(Collectors.toList());
}
public void removeDeadAlgues() {
this.algues = this.algues.stream().filter(p -> ! p.isDead).collect(Collectors.toList());
}
public void showFish() {
for (Fish e : this.fishes) {
System.out.println("\t- " + e.name + "(age: " + e.age + ", pv: " + e.pv + ", sexe: " + e.sexe + " specie: " + e.getClass() + " )");
}
}
public void showAlgues() {
for (Algue e : this.algues) {
System.out.println("\t- (age: " + e.age + ", pv: " + e.pv + " )");
}
}
public void removeFish(Fish fish) {
this.fishes.remove(fish);
}
public void diviseAlgue() {
List<Algue> list_algue = new ArrayList<>();
for (Algue algue : this.algues) {
Algue children = algue.divise();
if (children != null) {
list_algue.add(children);
}
}
this.algues.addAll(list_algue);
}
public void updateAlgue() {
for (Algue algue: this.algues) {
algue.heal(1);
algue.old(1);
}
}
public void updateFish() {
for (Fish fish: this.fishes) {
fish.update();
}
this.fishes.removeIf(fish -> fish.age >= 20);
}
public void fishBirth() {
List<Fish> children = new ArrayList<>();
for (Fish fish: this.fishes) {
Fish auth = getRandomFish();
if (fish.wantHaveChild(auth)) {
Fish s = fish.giveBirth();
System.out.println(fish.getName() + " + " + auth.getName() + " => " + s.getName());
children.add(s);
}
}
this.fishes.addAll(children);
}
public void deleteAlgueVeryOld() {
this.algues = this.algues.stream().filter(e -> e.age < 15).collect(Collectors.toList());
}
public void show() {
System.out.println("==== poisson ====");
showFish();
System.out.println("==== algue ====");
showAlgues();
}
public Fish getRandomFish() {
Random r = new Random();
int index = r.nextInt(this.fishes.size());
return (index > 0) ? this.fishes.get(index) : null;
}
public Algue getRandomAlgue() {
Random r = new Random();
int index = r.nextInt(this.algues.size());
return (index > 0) ? this.algues.get(index) : null;
}
public void fishEating() {
for (Fish fish: this.fishes) {
if (fish.getPV() <= 5) {
if (fish instanceof CarnivorFish) {
Fish f = getRandomFish();
if (f != null) {
fish.eat(f);
}
} else if (fish instanceof HerbivorFish) {
Algue a = getRandomAlgue();
if (a != null) {
fish.eat(a);
}
} else {
throw new RuntimeException("this should not happen");
}
}
}
}
public void update() {
this.removeDeadAlgues();
this.removeDeadFish();
this.updateAlgue();
this.updateFish();
this.fishBirth();
this.deleteAlgueVeryOld();
this.diviseAlgue();
this.fishEating();
this.show();
this.tours += 1;
}
}
Fish.java:
package Javaquarium;
public abstract class Fish {
protected String name;
protected Sexe sexe;
protected int pv = 10;
protected int age = 1;
public boolean isDead = false;
public Fish(String name, Sexe sexe) {
this.name = name;
this.sexe = sexe;
}
public Fish(String name, Sexe sexe, int age) {
this.name = name;
this.sexe = sexe;
this.age = age;
}
public int getAge() {
return this.age;
}
public int getPV() {
return this.pv;
}
public String getName() {
return this.name;
}
public Sexe getSexe() {
return this.sexe;
}
public void hurt(int n) {
if (this.pv - n < 0) {
this.pv = 0;
this.isDead = true;
} else {
this.pv = this.pv - n;
}
}
public void old(int year) {
this.age += year;
}
public void soigner(int pv) {
this.pv += pv;
}
public boolean wantHaveChild(Fish fish) {
if (fish == null) {
return false;
}
return (this.pv > 5 && this.getClass().equals(fish.getClass()) && this.sexe != fish.getSexe());
}
public void update() {
this.hurt(1);
this.old(1);
}
public boolean eat(Fish f) {return true;}
public boolean eat(Algue a) {return true;}
public abstract Fish giveBirth();
}
HerbivorFish.java:
package Javaquarium;
public abstract class HerbivorFish extends Fish {
public HerbivorFish(String name, Sexe sexe) {
super(name, sexe);
}
public HerbivorFish(String name, Sexe sexe, int age) {
super(name, sexe, age);
}
@Override
public boolean eat(Algue algue){
if (algue.isDead) {
return false;
}
algue.hurt(2);
this.pv += 3;
return true;
}
public abstract Fish giveBirth();
CarnivorFish.java:
package Javaquarium;
public abstract class CarnivorFish extends Fish {
public CarnivorFish(String name, Sexe sexe) {
super(name, sexe);
}
public CarnivorFish(String name, Sexe sexe, int age) {
super(name, sexe, age);
}
@Override
public boolean eat(Fish e) {
System.out.println(this.getName() + "(" + this.getClass() + ") eat " + e.getName() + "(" + e.getClass() + ")");
if (this.isDead || e.getClass().equals(this.getClass())) {
return false;
}
e.hurt(4);
this.pv += 5;
return true;
};
public abstract Fish giveBirth();
}
Bar.java:
package Javaquarium;
public class Bar extends HerbivorFish implements HermaphroditeAge {
public Bar(String name, Sexe sexe) {
super(name, sexe);
}
public Bar(String name, Sexe sexe, int age) {
super(name, sexe, age);
}
@Override
public Fish giveBirth() {
return new Bar(this.getName() + " Jr", Sexe.MALE);
}
@Override
public void update() {
super.update();
checkAge();
}
@Override
public void checkAge() {
if(this.age <= 10) {
this.sexe = Sexe.MALE;
} else {
this.sexe = Sexe.FEMELLE;
}
}
}
Sole.java:
package Javaquarium;
public class Sole extends HerbivorFish implements HermaphroditeOpportunist {
public Sole(String name, Sexe sexe) {
super(name, sexe);
}
public Sole(String name, Sexe sexe, int age) {
super(name, sexe, age);
}
@Override
public Fish giveBirth() {
return new Sole(this.getName() + " Jr", Sexe.getRandom());
}
@Override
public boolean wantHaveChild(Fish f) {
if (f == null) {
return false;
}
setSexe(f);
return super.wantHaveChild(f);
}
@Override
public void setSexe(Fish f) {
this.sexe = (f.getSexe() == Sexe.FEMELLE) ? Sexe.MALE : Sexe.FEMELLE;
}
}
PoissonClown.java:
package Javaquarium;
public class PoissonClown extends CarnivorFish implements HermaphroditeOpportunist{
public PoissonClown(String name, Sexe sexe) {
super(name, sexe);
}
public PoissonClown(String name, Sexe sexe, int age) {
super(name, sexe, age);
}
@Override
public Fish giveBirth() {
return new PoissonClown(this.getName() + " Jr", Sexe.getRandom());
}
@Override
public boolean wantHaveChild(Fish f) {
if(f == null) {
return false;
}
setSexe(f);
return super.wantHaveChild(f);
}
@Override
public void setSexe(Fish f) {
this.sexe = (f.getSexe() == Sexe.FEMELLE) ? Sexe.MALE : Sexe.FEMELLE;
}
}
Merou.java:
package Javaquarium;
public class Merou extends CarnivorFish implements HermaphroditeAge {
public Merou(String name, Sexe s) {
super(name, s);
}
public Merou(String name, Sexe s, int age) {
super(name, s, age);
}
@Override
public void update() {
super.update();
checkAge();
}
@Override
public Fish giveBirth() {
return new Merou(this.getName() + " Jr", Sexe.MALE);
}
@Override
public void checkAge() {
if (this.age <= 10) {
this.sexe = Sexe.MALE;
} else {
this.sexe = Sexe.FEMELLE;
}
}
}
Thon.java:
package Javaquarium;
public class Thon extends CarnivorFish{
public Thon(String name, Sexe sexe) {
super(name, sexe);
}
public Thon(String name, Sexe sexe, int age) {
super(name, sexe, age);
}
@Override
public Fish giveBirth() {
return new Thon(this.getName() + " Jr", Sexe.getRandom());
}
}
Carpe.java:
package Javaquarium;
public class Carpe extends HerbivorFish {
public Carpe(String name, Sexe sexe) {
super(name, sexe);
}
public Carpe(String name, Sexe sexe, int age) {
super(name, sexe, age);
}
@Override
public Fish giveBirth() {
return new Carpe(this.getName() + " Jr", Sexe.getRandom());
}
}
Algue.java;
package Javaquarium;
public class Algue {
public int age = 1;
public int pv = 10;
public boolean isDead = false;
public Algue() {}
public Algue(int age) {
this.age = age;
}
public int getAge() {
return this.age;
}
public int getPV() {
return this.pv;
}
public void old(int year) {
this.age += year;
}
public void hurt(int degat) {
if (this.pv - degat < 0) {
this.isDead = true;
} else {
this.pv -= degat;
}
}
public void heal(int vie) {
if (! this.isDead) {
this.pv += Math.max(vie, 0);
}
}
public void setAge(int age) {
this.age = age;
}
public void setPV(int pv) {
this.pv = pv;
}
public boolean canDivise() {
return this.pv >= 10;
}
public Algue divise() {
if (canDivise()) {
Algue children = new Algue();
children.setPV(Math.round(this.pv / 2F));
this.pv = Math.round(this.pv / 2F);
return children;
} else {
return null;
}
}
}
Sexe.java:
package Javaquarium;
public enum Sexe {
MALE,
FEMELLE;
public static Sexe getRandom() {
return values()[(int) (Math.random() * values().length)];
}
}
HermaphroditeAge.java:
package Javaquarium;
public interface HermaphroditeAge {
void checkAge();
}
HermaphroditeOpportunist.java:
package Javaquarium;
public interface HermaphroditeOpportunist {
void setSexe(Fish f);
}
Main.java:
package Javaquarium;
import java.lang.Thread;
public class Main {
public static void main(String[] args) {
Fish p1 = new Merou("Charle", Sexe.MALE);
Fish p2 = new Thon("Papi", Sexe.FEMELLE);
Fish p3 = new PoissonClown("CoCo", Sexe.MALE);
Fish p4 = new Sole("Gii", Sexe.FEMELLE);
Fish p5 = new Bar("fii", Sexe.MALE);
Fish p6 = new Carpe("boli", Sexe.FEMELLE);
Fish p7 = new Merou("CiCi", Sexe.FEMELLE);
Algue a1 = new Algue(5);
Algue a2 = new Algue(67);
Aquarium aquarium = new Aquarium();
aquarium.addAlgue(a1);
aquarium.addAlgue(a2);
aquarium.addFish(p1);
aquarium.addFish(p2);
aquarium.addFish(p3);
aquarium.addFish(p4);
aquarium.addFish(p5);
aquarium.addFish(p6);
aquarium.addFish(p7);
while (true) {
try {
Thread.sleep(1000);
} catch(InterruptedException ex) {
Thread.currentThread().interrupt();
System.out.println("### ERROR ###");
}
aquarium.update();
}
}
}
Une première remarque serait de revoir le concept d'encapsulation et te demander si c'est normal qu'un acteur extérieur aie la possibilité de changer l'âge, les points de vie...
× 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.
Le cours en Java le plus géniale de la terre : Super cours de Cysboy
le code FAIT le bonheur (pour moi en tous cas)
PXL Le retro gaming facile Thread sur le forum: https://openclassrooms.com/forum/sujet/retro-pxl
le code FAIT le bonheur (pour moi en tous cas)