Javaquarium

Ton problème vient du fait que tu enlève des éléments de ta collection pendant que tu itère dessus. Plus de détails ici.

Merci. J'ai trouvé une solution de contournement en utilisant un booléen isAlive. Mais comment faire sinon pour supprimer un poisson autre que celui retourné par l'itérateur, et comment supprimer depuis une autre méthode ? Il faut passer l'itérateur à la méthode qui va supprimer le poisson (eat()) ?

Je pense que le plus simple est de simplement modifier le booléen isAlive dans les méthodes et de nettoyer l'aquarium à chaque fin de "tour" dans la boucle principale (en utilisant une boucle comme dans le lien indiqué par Praetonus).

C'est ce que j'ai fais louk, parce que j'aime la simplicité Mais je demande quand même pour savoir.

Je me suis lancé dans l'exo 1. Dites moi ce que vous en pensez : https://github.com/pouet/javaquarium L'objet c'est pas mon truc, hésitez pas a critiquer ! J'ai commencé le java ya 2 jours… si ya des trucs choquants c'est ptete narmol !

Parce que Kotlin c’est le langage à JVM qui monte, je tente mon propre exercice dans ce langage : https://github.com/SpaceFox/kotlinquarium – pour l’instant jusqu’à l’étape 2.1 qui pose des problèmes de modification concurrente rigolos si on y va naïvement.

À noter que c’est fait avec la doc sous la main, j’ai pour ainsi dire jamais codé dans ce langage avant. J’ai essayé d’être proche de ce que je perçois de la philosophie du langage Kotlin, quitte à m’éloigner de ce qu’on ferait en Java.

Voici ma version en Ruby, c’est mon tout premier programme "sérieux" dans ce langage que je découvre depuis fin 2016

Normalement toutes les étapes sont implémentées, avec quelques petits écarts cependant:

4.2/4.3 La sortie sur console est effectuée dans un format identique à celui du chargement, donc je n’ai pas prévu l’enregistrement dans un fichier séparé, la sortie console si elle est redirigée dans un fichier peut être réutilisée directement en entrée pour charger les êtres vivants

4.4 Au lieu d’être à part en entête, le tour initial est précisé pour chaque être vivant (c’est un attribut de la classe LivingBeing).

Quelques précisions supplémentaires:

• Les espèces sont également chargées depuis un fichier, on peut donc en définir autant qu’on veut (animaux ou végétaux) avec des propriétés différentes (en terme de points de vie, longévité, valeur nutritive, etc).

• J’ai rajouté également la gestion des omnivores (pour le fun et ça ne coûtait vraiment pas beaucoup plus cher à coder), donc au lieu d’avoir 7 comportements différents il y en a 10.

• Le fichier public.txt contient un résumé des classes avec leurs attributs et méthodes publiques. Pour résumer il y 10 classes pour les espèces (classe de base Species) et 10 pour les êtres vivants (classe de base LivingBeing), j’utilise les mixins Ruby pour implémenter les différents comportements.

• La correspondance entre la classe de l’espèce et la classe de l’être vivant et faite grâce une table de correspondance consultée lors du chargement des êtres vivants.

• Un numéro séquentiel est utilisé pour nommer les nouveaux-nés

Un exemple de sortie pour un tour de simulation

J’ai remarqué comme d’autres que les hermaphrodites opportunistes se multipliaient très vite, a priori ils ont 2 fois plus de chance de se reproduire donc j’en ai mis 2 fois moins au départ pour équilibrer l’évolution, du coup le "vainqueur" est assez souvent différent.

Ce pourrait être assez drôle de voir s’il est possible de trouver des équilibres dans cette population ^^. J’avais essayé de générer un modèle de Lotka-Voltera mais sans grand succès (faut dire que ma lib d’algo génétique était foireuse)

Salut, une idée de projet pour entrainer l’OOP un peu plus léger que le Javaquarium pour me faire la main avant de passer au Javaquarium ?

Salut,

J’ai tenté l’exercice en R avec des classes S3, ce qui s’est avéré peu pratique puisque ce genre de classe empêche la modification d’un objet. Du coup, a chaque fois qu’une opération modifiant l’aquarium est effectué, la totalité de l’aquarium est recopié puis l’ancienne version est écrasée. Utiliser des classe de type ReferenceClass, qui fonctionnent de la même façon qu’en Java, C# ou C++, aurait sans doute été plus simple (et oui, car en R il y a plusieurs style de programmation objet).

Je me suis arrêté à la partie 3.2 (La reproduction), la suite arrivera peut être, peut être pas. Quoi qu’il en soit vous pouvez trouver le code ici sous la forme d’un package R. Vous pouvez l’installer avec devtools::install_bitbucket("gcaillaut/raquarium") après avoir préalablement installé le package devtools avec install.packages("devtools").

Il y a un example d’aquarium que vous pouvez charger avec data(sample_aquarium), si vous voulez créez le votre, il y a un exemple de script de création dans le dossure data-raw/.

Un exemple d’utilisation ressemblerait à ça :

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

library(Raquarium)

data(sample_aquarium)

step0 <- sample_aquarium
step1 <- next_step(step0)
step2 <- next_step(step1)
# ...
# stepN <- next_step(stepN-1)

# Si on veut sauvegarder un aquarium
save(step2, file = "step2.Rda") # Créer un fichier step2.Rda
load("step2.Rda") # Pour charger le fichier step2.Rda (construit la variable step2)

Bonjour,

Ça faisait un moment que je voulais comprendre et essayer l’ECS. J’ai donc fait le Javaquarium. Je l’ai fait en Python, parce que c’est le langage que je maitrise le mieux.

J’ai fait la partie 2, je veux bien vos retours :

import random


class Carnivore():
    def __init__(self):
        pass

    def cherche_repas(self, mangeur, poissons):
        if len(poissons) == 1:
            raise ValueError
        mangé = random.choice(poissons)
        while mangé == mangeur:
            mangé = random.choice(poissons)
        return mangé

    def mange(self, mangeur, mangé):
        mangé.vie.change_vie(-4)
        mangeur.vie.change_vie(5)

class Herbivore():
    def __init__(self):
        pass
    
    def cherche_repas(self, algues):
        return random.choice(algues)

    def mange(self, mangeur, algue):
        algue.vie.change_vie(-2)
        mangeur.vie.change_vie(3)


class Vivant():
    def __init__(self, vie=10):
        self.vie = vie

    def change_vie(self, quantite):
        self.vie += quantite
    
    def est_vivant(self):
        return self.vie > 0


class Poisson:
    def __init__(self, nom, sexe, race=""):
        self.nom = nom
        self.sexe = sexe
        self.race = race
        if race in ["mérou", "thon", "poisson-clown"]:
            self.repas = Carnivore()
        else:
            self.repas = Herbivore()
        self.vie = Vivant()
    
    def affiche(self):
        print(f"Le poisson {self.nom} est un {self.sexe}, de race {self.race}, avec {self.vie.vie} points de vie.")
    
    def mange(self, truc):
        self.repas.mange(truc)
        
    def update(self):
        self.vie.change_vie(-1)

class Algue:
    def __init__(self):
        self.vie = Vivant()
    
    def update(self):
        self.vie.change_vie(1)


class Aquarium():
    def __init__(self):
        self.poissons = []
        self.algues = []
    
    def ajoute_poisson(self, poisson):
        self.poissons.append(poisson)
    
    def ajoute_algue(self, algue):
        self.algues.append(algue)
    
    def update(self):
        trucs_en_vie = self.poissons + self.algues
        # Phase de croissance des algues et faim des poissons
        for truc in trucs_en_vie:
            truc.update()
        print("Tous les poissons perdent un point de vie, toutes les algues en gagnent deux.")
        # Ménage des morts
        for poisson in self.poissons:
            if not poisson.vie.est_vivant():
                self.poissons.remove(poisson)
        random.shuffle(self.poissons)
        # Recherche de repas
        for poisson in self.poissons:
            if poisson.vie.vie > 5:
                continue
            if isinstance(poisson.repas, Carnivore):
                try:
                    mangé = poisson.repas.cherche_repas(poisson, self.poissons)
                except ValueError:
                    pass
                else:
                    poisson.repas.mange(poisson, mangé)
                    print(f"{poisson.nom} a mangé {mangé.nom}.")
                    if not mangé.vie.est_vivant():
                        self.poissons.remove(mangé)
                        print(f"{mangé.nom} est mort. :(")
            elif isinstance(poisson.repas, Herbivore):
                mangé = poisson.repas.cherche_repas(self.algues)
                poisson.repas.mange(poisson, mangé)
                print(f"{poisson.nom} a mangé une algue.")
                if not mangé.vie.est_vivant():
                    self.algue.remove(mangé)
                    print("Une algue est morte.")

    def affiche(self):
        for poisson in self.poissons:
            poisson.affiche()
        
        print(f"Il y a {len(self.algues)} algue{'s' if len(self.algues) >= 2 else ''} dans l'aquarium. Elles ont comme vie :")
        for algue in self.algues:
            print(f"{algue.vie.vie}")    

Et le code pour tester :

aqua = Aquarium()
poisson1 = Poisson("Albert", "H", "mérou")
poisson2 = Poisson("Jeannette", "F", "bar")
poisson3 = Poisson("Gontrand", "H", "bar")
poisson4 = Poisson("Gudrune", "F", "mérou")
aqua.ajoute_poisson(poisson1)
aqua.ajoute_poisson(poisson2)
aqua.ajoute_poisson(poisson3)
aqua.ajoute_poisson(poisson4)
aqua.ajoute_algue(Algue())
aqua.ajoute_algue(Algue())
aqua.ajoute_algue(Algue())
aqua.affiche()

for t in range(50):
    aqua.update()
    aqua.affiche()

L’idée de l’ECS, si j’ai bien compris, c’est d’éviter l’héritage, permettre une composition arbitraire de caractéristique en donnant aux classes une instance d’une autre classe, qui contient la logique.

Donc l'Entity, c’est Albert le poisson, le Component, c’est mon aquarium, et mon System, ce sont mes sous-classes Carnivore, Vivant…

Si c’est bien ça, je crains d’avoir violé le principe dans la recherche des repas. Deux remarques / questions au passage :

• J’ai facilement tendance à faire de la duplication de code avec de principe de programmation. Sur le produit final, ça va, mais dans les étapes intermédiaires, ça arrive facilement. Typiquement, entre les végétariens et carnivores.
• J’ai l’impression que le décès des poissons et algues ne peut se gérer que tout en haut, dans l’aquarium. C’est normal et OK, ou c’est une erreur de programmation de ma part ?

Bonjour, Je suis débutant en Java et j’ai peur que ce projet soit un peu trop compliqué pour débuter, auriez-vous d’autres exemples de projets à faire avant pour être sûr de maîtriser les bases ? Merci !

Bonjour, Je me permet de déterrer ce sujet pour vous présenter ma version en Ada, langage que j’apprends dans le cadre de mon premier emploi.

Vous trouverez l’exercice implémenté jusqu’à la question 3.3 incluse sur ce dépôt Github. Je suis preneur de tout retour pour l’améliorer.

je suis nouveau sur zds , je ne sais pas si il a une date limite pour poster un poste comme sur oc donc ne m’en voudrez pas si je déterre le sujet et ne le fermez pas a cause de moi , voila mon code pour javaquarium : javaquarium-github desole si il n’y a pas de commentaire ou de readme.md

(Salut ! Déterrer ne pose pas de problème tant que c’est des sujets comme ça qui rassemblent toutes les tentatives au même endroit. C’est juste à éviter dans un contexte de poser une autre question après le fil de quelqu’un, mais ici c’est totalement légitime )

Au vu de ton pseudo je m’attendais à un code en Python et en fait pas du tout !

ah oui , je me penche sur une version en python , c’est que le nom javaquarium(java|quarium) m’a embrouillé et en faite j’avais déjà fait l' exercice d’oc qui disait de le faire en java donc je l’avais fait d’avance

Salut, voici mon implémentation en Java 17 que j’ai réalisée en deux semaines durant ces dernières vacances.

Si vous avez des remarques particulières, je suis preneur . Normalement le README est assez détaillé (et y’a même un logo )

J’ai utilisé la preview du pattern matching (que sur un bout de code).

Merci d’avance pour vos retours