// 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(), ...

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();
}

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;
        }
    }
}

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;

    }
}

public enum Sexe {
    MALE, FEMELLE;
}

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;
    }

    
}

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;
    }
}

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();
    }

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();
	}

}

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);
			}
		}
	}
}

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);
		}
	}

		
	
}

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;
	}
	
	
	
}

• 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).

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 ?");
	}

}

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());
		}
	}

}

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();
}

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);
	}
	
}

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
		
	}

}

/** 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!

/** 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() {
    }
}

}

/** 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);
}

/** 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());
    }
}

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;
        }
    }
}

public class Main {

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

}

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();
	}
}

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;
	}
}

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 +")";
	}
}

public class Algue extends EtreVivant {
	
}

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;
	}
	
}

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();
}

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);
	}

}

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);
					}
					
				}
	}

}

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();
	}
	
}

public interface Vieillir {

	abstract void vieillir();
}

/**
 * 
 */

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

}

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;
			}
			
		}
	}
}

• 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