Hello,

D'après ton algo, je vois que la quantité de feuille et de racines est fixée au départ et ne bouge plus, j'ai donc retiré de mon code, les méthodes qui permettaient à la plante de créer feuilles et racines.

J'ai juste ajouté une méthode qui simule le comportement de vie d'une plante.
En gros la simulation se résume à ceci :
Toutes les unités de temps, la plante absorbe des ressources, et décide si elle doit faire grandir ses feuilles ou ses racines en fonction des quantités d'azote et carbone disponibles.
Ensuite la méthode affiche juste à chaque période, la quantité d'azote et de carbone dispo dans la plante.
Par rapport à ton besoin il faudrait aussi ajouter les surfaces des feuilles et des racines, je te laisserais le soin de faire ca.

Une petite chose que je n'ai pas bien compris, tu as parlé de feux facteurs supplémentaires, eau et lumière, or dans ton algo, il n'est nul part mentionné leur impact sur la plante. Pour l'instant donc je n'en ai pas tenu compte.

Voici l'implémentation :

Feuille

package bean;

public class Feuille {
	
	private static double sCoefficientAbsorbCarbone = 1;
	private static double sNeededAzotePourGrandir = 1;
	private static double sNeededCarbonePourGrandir = 1;
	
	private double mSurface;

	public Feuille() {
		mSurface = 0;
	}
	
	public double getSurface() {
		return mSurface;
	}

	public void setSurface(Double surface) {
		mSurface = surface;
	}
	
	public double absorbeCarbone() {
		return mSurface * sCoefficientAbsorbCarbone;
	}
	
	public void faireGrandirFeuille(double pQuantiteAzoteDispo, double pQuantiteCarboneDispo) {
		pQuantiteAzoteDispo = pQuantiteAzoteDispo - sNeededAzotePourGrandir;
		pQuantiteCarboneDispo = pQuantiteCarboneDispo - sNeededCarbonePourGrandir;
		mSurface += 1;
	}
	
}

Racine

package bean;

public class Racine {
	
	private static double sCoefficientAbsorbAzote = 1;
	private static double sNeededAzotePourGrandir = 1;
	private static double sNeededCarbonePourGrandir = 1;
	
	private double mSurface;

	public Racine() {
		mSurface = 0;
	}
	
	public double getSurface() {
		return mSurface;
	}

	public void setSurface(Double surface) {
		mSurface = surface;
	}
	
	public double absorbeAzote() {
		return sCoefficientAbsorbAzote * mSurface;
	}
	
	public void faireGrandirRacine(double pQuantiteAzoteDispo, double pQuantiteCarboneDispo) {
		pQuantiteAzoteDispo = pQuantiteAzoteDispo - sNeededAzotePourGrandir;
		pQuantiteCarboneDispo = pQuantiteCarboneDispo - sNeededCarbonePourGrandir;
		mSurface += 1;
	}
	
}

Plante

package bean;

import java.util.ArrayList;
import java.util.List;

public class Plante {
	
	private double mQuantiteAzote;
	
	private double mQuantiteCarbone;
	
	private double mTempEcoule;
	
	private List<Feuille> mFeuilles;
	
	private List<Racine> mRacines;

	public Plante() {
		mTempEcoule = 0;
		mQuantiteAzote = 0;
		mQuantiteCarbone = 0;
		mFeuilles = new ArrayList<Feuille>();
		mRacines = new ArrayList<Racine>();
	}
	
	public List<Feuille> getFeuilles() {
		return mFeuilles;
	}

	public void setFeuilles(List<Feuille> feuilles) {
		mFeuilles = feuilles;
	}

	public List<Racine> getRacines() {
		return mRacines;
	}

	public void setRacines(List<Racine> racines) {
		mRacines = racines;
	}
	
	public double getQuantiteAzote() {
		return mQuantiteAzote;
	}

	public double getQuantiteCarbone() {
		return mQuantiteCarbone;
	}
	
	private void absorbeRessources() {
		for (Feuille vFeuilleTmp : mFeuilles) {
			mQuantiteCarbone += vFeuilleTmp.absorbeCarbone();
		}
		
		for (Racine vRacineTmp : mRacines) {
			mQuantiteAzote += vRacineTmp.absorbeAzote();
		}
	}
	
	private void faireGrandirFeuilles() {
		for (Feuille vFeuilleTmp : mFeuilles) {
			vFeuilleTmp.faireGrandirFeuille(mQuantiteAzote, mQuantiteCarbone);
		}
	}
	
	private void faireGrandirRacines() {
		for (Racine vRacineTmp : mRacines) {
			vRacineTmp.faireGrandirRacine(mQuantiteAzote, mQuantiteCarbone);
		}
	}
	
	public void simulePlanteLife() {
		for(int i = 0; i < 200; i++) {
			displayPlanteStatus();
			absorbeRessources();
			
			if (mQuantiteAzote == mQuantiteCarbone) {
				faireGrandirFeuilles();
				faireGrandirRacines();
			} else if (mQuantiteAzote > mQuantiteCarbone) {
				faireGrandirFeuilles();
			} else {
				faireGrandirRacines();
			}
			
			mTempEcoule++;
		}
	}
	
	private void displayPlanteStatus() {
		System.out.println(
				"Seconde : " + mTempEcoule +
				" Quantite Carbone : " + mQuantiteCarbone +
				" Quantite Azote : " + mQuantiteAzote);
	}
	
	public static Plante buildSamplePlante() {
		Plante vPlante = new Plante();
		List<Feuille> vFeuilles = new ArrayList<Feuille>();
		List<Racine> vRacines = new ArrayList<Racine>();
		
		Feuille vFeuille0 = new Feuille();
		vFeuille0.setSurface(1d);
		vFeuilles.add(vFeuille0);
		
		Feuille vFeuille1 = new Feuille();
		vFeuille1.setSurface(1d);
		vFeuilles.add(vFeuille1);
		
		Racine vRacine0 = new Racine();
		vRacine0.setSurface(1d);
		vRacines.add(vRacine0);
		
		vPlante.setFeuilles(vFeuilles);
		vPlante.setRacines(vRacines);
		
		return vPlante;
	}
	
}

Program

import bean.Plante;


public class Program {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Plante.buildSamplePlante().simulePlanteLife();
	}

}

Dans mon program j'ai crée une Plante à deux feuilles et une racine, si tu veux avoir un comportement moins "linéaire", il faut jouer sur les coefficient d'absorbtion des racines et des feuilles.

Bonne chance,
Niroken

Hello,

En java, pour représenter une collection on peut utiliser des tableaux :

Feuille[] vFeuilles = new Feuille[2];

Des listes :

List<Feuille> vFeuilles = new ArrayList<Feuille>();

Des maps, des sets, vectors....

L'avantage des listes par rapport aux tableaux, c'est qu'on a pas besoin de préciser la taille de la liste a l'avance, de sorte que si l'on veut ajouter ou retirer un élément cela se fait sans problème, or dans le cas d'un tableau, il faut redéclarer un tableau de taille +1 ou -1 et recopier les éléments du tableau initial dans le nouveau.

Ici dans le cas de la plante, ca s'y prétait bien puisque j'avais pensé qu on avait un nombre de feuilles et de racines indéterminés.

Pour parcourir un élément de type collection à partir de java 1.5 on peut utiliser :

for (Feuille vFeuilleTmp : mFeuilles) {
    mQuantite += vFeuilleTmp.absorbeCarbone();
}

Sinon on peut parcourir cette collection de facon plus classique :

for (int i = 0; i < mFeuilles.size(); i++) {
    mQuantite += mFeuilles.get(i).absorbeCarbone();
}

Dans l exemple ci dessus, je parcours la liste de feuille de la plante, et j 'ajoute a la quantité de carbone de la plante, les quantités de carbones absorbées de chacune de feuilles.

Enfin pour finir, j'avais ajoutés des paramètres sCoefficientAbsorbeCarbone, ce paramètre est utilisé pour savoir quelle est la quantité de carbone absorbée pour chaque feuille par unité de surface.
Ainsi, si tu modifies ce paramètre, ta plante absorberas bcp de carbone. dans le cas contraire, elle n'en absorbera pas beaucoup.

Ce paramètre ainsi que les autres vont donc modifier le comportement de la vie de ta plante.

Bonne chance,
Niroken

Hello,

J'ai corrigé ton code,je te transmets juste les classes modifiées :

Milieu :

import java.util.*;

import javaapplication5.Plante;
public class Milieu {

/**
    * @param args
    */
   public static void main(String[] args) {
     Plante Pt = new Plante();
     
     double tabAz[] = new double [300];
     double tabCarb[] = new double [300];
     double tabSfFe[] = new double [300];
     double tabSfRa [] = new double [300];

     for (int i = 0; i<0;i++){
         tabAz[i] = 0;
         tabCarb[i] = 0;
         tabSfFe[i] = 0;
         tabSfRa[i] = 0;
    }
     Random alea = new Random ();
     double mQuantiteAzoteSol = alea.nextDouble();
     double mQuantiteCarboneAtm = alea.nextDouble();

     for (int i = 0; i<200;i++) {
         Pt.absorbeRessources();
         Pt.simulePlanteLife();
         tabAz[i] = Pt.getQuantiteAzote();
         tabCarb[i] = Pt.getQuantiteCarbone();
         System.out.println(  "QuantiteCarbone :"+tabCarb[i]+
                 "QuantiteAzote:"+tabAz[i]+"Surface feuille :"
                 +tabSfFe[i]+"Surface racine:"+ tabSfRa[i]);
     }

   }
}

Plante :

package javaapplication5;

/**
*
* 
*/



public class Plante {

    private double mQuantiteAzote;

    private double mQuantiteCarbone;

    private double mQuantiteCarboneAtm;

    private double mQuantiteAzoteSol;

    private double mTempEcoule;

    private Feuille [] feuilles;

    private Racine [] racines;



    public Plante () {

      mTempEcoule = 0;
      mQuantiteAzote = 0;
      mQuantiteCarbone = 0;
      feuilles  = new Feuille [3];
      racines   = new Racine [5];
        for (int f = 0;f<3 ; f ++){
         feuilles [f] = new Feuille();
        }
        for (int r = 0; r<5 ; r++) {
         racines [r] = new Racine ();
        }
     }

   public Feuille [] getFeuilles() {
      return feuilles;
   }

   public void setFeuilles(Feuille [] feuilles) {
      this.feuilles = feuilles;
   }

   public Racine [] getRacines() {
      return racines;
   }

   public void setRacines(Racine[]racines) {
	   this.racines = racines;
   }

   public double getQuantiteAzote() {
      return mQuantiteAzote;
   }

   public double getQuantiteCarbone() {
      return mQuantiteCarbone;
   }
   public double getQuantiteCarboneAtm() {
       return mQuantiteCarboneAtm;
   }
   public double getQuantiteAzoteSol(){
       return mQuantiteAzoteSol;
   }
   public double getTempEcoule (){
       return mTempEcoule;
   }

  public void absorbeRessources() {
      for (int f= 0;f<3 ;f++) {
         mQuantiteCarbone += feuilles[f].absorbeCarbone();
      }

      for (int r = 0; r < 5;r++) {
         mQuantiteAzote += racines[r].absorbeAzote();
      }
   }

  private void faireGrandirFeuilles() {
      for (int f = 0;f<3;f++) {
         feuilles[f].faireGrandirFeuille(mQuantiteAzote, mQuantiteCarbone);
      }
   }

  private void faireGrandirRacines() {
      for (int r = 0; r<5; r++) {
         racines[r].faireGrandirRacine(mQuantiteAzote, mQuantiteCarbone);
      }
   }

  public void simulePlanteLife() {
       
      if (mQuantiteAzote == mQuantiteCarbone) {
            faireGrandirFeuilles();
            faireGrandirRacines();
      }
      else if (mQuantiteAzote > mQuantiteCarbone) {
            faireGrandirFeuilles();
      }
      else {
            faireGrandirRacines();
      }

       
      
   }


   }

En revanche, je ne vois pas trop à quoi sert ta classe Milieu.
Apparemment tu as essayé de faire un système de sauvegarde de l'état de la plante à chaque instant t.
Mais il aurait mieux valu que tu fasses, une méthode interne a la classe Plante qui te renvoit à la limite un String pour l'état de la plante, ou alors au mieux une structure de données qui te sauvegarde ces infos en vue de les écrire plus tard dans un fichier par exemple.

A l'heure atuelle ce qui marche donc, c'est que tu affiches les quantités de carbone et d azote absorbées par la plante en fonction du temps.

Bonne chance,
Niroken