Ajout d'objets dans un tableau [Résolu]

Je te remercie, je vais tester!

J'ai fixer la taille du tableau à 10, jai la même erreur...

La même erreur mais sur quel code ? Toujours le même ? Parce que

batiments[batiments.length]

sera toujours faux, que ce soit avec 3, 10, ou 999999999...
Les indices de tableau vont de 0 à length-1, donc dans ton cas de batiments[0] à batiments[9] c'est bon, mais batiments[10] plantera.

Il faut que tu mettes en place ce dont j'ai parlé dans ma première réponse avec un suivi du nombre de données présentes dans le tableau et un redimensionnement quand le nombre de données dépassent la taille du tableau.

private static Forme[] batiments = new Forme[10];
private static int nbBatiments = 0;

public void ajouterForme(Forme b){
    if (nbBatiments == batiments.length) {
         // remplacer batiments par un tableau plus grand
    }
    batiments[nbBatiments]=b;
    nbBatiments++;
}

public void afficherTaille(){
    System.out.println("La taille du tableau est " + batiments.length);
    System.out.println("Le nombre de valeurs dans le tableau est " + nbBatiments);
}

Bonsoit KX, désolé pour la réponse tardive.
Je te remercie, je vais tester tout ça.

Quand je teste ton code dans le mien et que j'ajoute une formze, la taille du tableau ne bouge pas et le nb de valeurs du tableau reste à 0

A noter que la taille du tableau était déjà de 3, (lexercice imposé d'insérer 3 objets dans le tableau)

Montre moi la dernière version de ton code.

public class Terrain extends Forme {
	
		private static Forme[] batiments = new Forme[10];
		private static int nbBatiments = 3;

		public Terrain(Forme...bat)
		{batiments=bat;}
		
		public static void main(String argums[])
		
		 {		
		
			//Instanciation des classe Rectangle, Triangle, Cercle et du tableau batiments
			Rectangle r = new Rectangle(3,3);
			Triangle t = new Triangle(2,2);	
			Cercle c = new Cercle(2);
			batiments[0] = r;
			batiments[1] = t;
			batiments[2] = c;
		}	
		
		//Définition de la méthode ajouterForme() qui ajoute une nouvelle forme
		public void ajouterForme(Forme b){

			if (nbBatiments == batiments.length) {
         			// remplacer batiments par un tableau plus grand
    			}
			batiments[nbBatiments]=b;
			nbBatiments++;
		}
		
		//Définition de la méthode calculerSurfaceTotale() qui calcule la surface totale occupée
		public double calculerSurfaceTotale()
		{
			double surfaceTotale=0;
			for ( int i=0 ; i < batiments.length ; i++){
				surfaceTotale=surfaceTotale+batiments[i].calculerSurface();
			}
			return surfaceTotale;		
		}
		
		//Définition de la méthode affichageSurfaceTotale() qui affiche la surface totale occupée
		public void afficherSurfaceTotale()
		{System.out.println("La surface totale est de "+calculerSurfaceTotale());}
		
		//Définition de la méthode affichage de la taille du tableau (méthode utilisée pour test)
		public void afficherTaille()
		{System.out.println(("La taille du tableau est ")+batiments.length);
		 System.out.println("Le nombre de valeurs dans le tableau est " + nbBatiments);}
		
		
	
}

public class TestAppliSurface {

	public static void main(String[] args) {
		Rectangle r=new Rectangle(4,4);
		Triangle t=new Triangle(2,2);
		Cercle c =new Cercle(2);
		Terrain te=new Terrain(new Rectangle(4,4), new Triangle(2,2), new Cercle(2));
		System.out.println("La longueur du rectangle est de "+r.getLongueur()+" et la largeur est de "+r.getLargeur());
		System.out.println("La surface du rectangle est de "+r.calculerSurface());
		System.out.println("La hauteur du triangle est de "+t.getHauteur()+" et la base est de "+t.getBase());
                System.out.println("La surface du triangle est de "+t.calculerSurface());
		System.out.println("Le rayon du cercle est de "+c.getRayon());
                System.out.println("La surface du cercle est de "+c.calculerSurface());
		te.afficherSurfaceTotale();
		te.ajouterForme(new Cercle2(2));
		te.afficherTaille();
		
	}

}

du coup j'ai initaliser nbBatiments à 3 car la taille initale est de 3... A 0 ca ne marchait également pas

Essaye avec ceci (je n'ai pas testé)

public class Terrain extends Forme {
   private Forme[] batiments;
   private int nbBatiments;

   public Terrain(Forme...bat) {
        batiments = new Forme[2 * bat.length + 10];
        nbBatiments = 0;
        for (Forme f : forme) {
            ajouterForme(f);
        }
    }

    public void ajouterForme(Forme f) {
        if (nbBatiments == batiments.length - 1) { // on agrandit le tableau
            batiments = new Terrain(batiments).batiments;
        }
        batiments[nbBatiments] = f;
        nbBatiments++;
    }
}

Bonjour KX,
Quel est le sens de cette ligne : batiments = new Forme[2 * bat.length + 10]; .
Pourquoi multiplier par 2 et additionner par 10 ? Pour agrandir la taille du tableau au fur et à mesure ?

Oui, ça permet de créer un tableau plus grand que la taille des éléments à insérer en prévision que l'on va en rajouter.

Par exemple : Tu crées le tableau vide, donc bat.length = 0, on va avoir 2*0+10, donc batiments.length = 10
Après avoir rempli les 10 cases, on va créer un nouveau tableau, avec bat.length = 10, on va avoir 2*10+10, donc batiments.length = 30, ce qui va te permettre d'ajouter encore 20 valeurs. Une fois arrivée à 30, ça redimensionne à 70, etc.

Autre exemple : Tu crées le tableau avec 3 valeurs, donc bat.length = 3, on va avoir 2*3+10, donc batiments.length = 16.
Après avoir rempli les 16 cases, on va créer un nouveau tableau, avec bat.length = 16, on va avoir 2*16+10, donc batiments.length = 42, ce qui va te permettre d'ajouter encore 26 valeurs. Une fois arrivée à 42, ça redimensionne à 94, etc.

Mais à la limite les valeurs importent peu, que ce soit 70 ou 94 ça ne change pas grand chose, tant que le tableau se redimensionne suffisamment à chaque fois.
Ce qu'il faut éviter c'est d'agrandir trop souvent le tableau, car vu qu'il faut copier toutes les valeurs du premier tableau vers le deuxième à chaque redimensionnement, c'est très coûteux.

D'accord, mais on peut éventuellement fixer une limite de taille ? Par exemple à 10 ? Donc inutile d'aller au delà de 10?

Oui, mais c'est dommage de se limiter à 10 alors que le système de redimensionnement automatique est quand même très simple à mettre en place...

Bonjour KX,

Désolé de ma réponse tardive. La limite de taille à 10 est imposée par l'exercice.

Du coup voici la dernière version de mon code, ca m'affiche encore une erreur...

public class Terrain extends Forme {
	
		private static Forme[] batiments = new Forme[10];
		private static int nbBatiments = 3;

		public Terrain(Forme...bat)
		{batiments=bat;}
		
		public static void main(String argums[])
		
		 {		
		
			//Instanciation des classe Rectangle, Triangle, Cercle et du tableau batiments
			Rectangle r = new Rectangle(3,3);
			Triangle t = new Triangle(2,2);	
			Cercle c = new Cercle(2);
			batiments[0] = r;
			batiments[1] = t;
			batiments[2] = c;
		}	
		
		//Définition de la méthode ajouterForme() qui ajoute une nouvelle forme
		public void ajouterForme(Forme b){

			batiments[nbBatiments]=b;
			nbBatiments++;
		}
		
		//Définition de la méthode calculerSurfaceTotale() qui calcule la surface totale occupée
		public double calculerSurfaceTotale()
		{
			double surfaceTotale=0;
			for ( int i=0 ; i < batiments.length ; i++){
				surfaceTotale=surfaceTotale+batiments[i].calculerSurface();
			}
			return surfaceTotale;		
		}
		
		//Définition de la méthode affichageSurfaceTotale() qui affiche la surface totale occupée
		public void afficherSurfaceTotale()
		{System.out.println("La surface totale est de "+calculerSurfaceTotale());}
		
		//Définition de la méthode affichage de la taille du tableau (méthode utilisée pour test)
		public void afficherTaille()
		{System.out.println(("La taille du tableau est ")+batiments.length);
		 System.out.println("Le nombre de valeurs dans le tableau est " + nbBatiments);}
		
		
	
}

J'ai l'impression de revoir encore et toujours le même code, tu ne prends pas en compte les corrections au fur et à mesure que je te fournis du code...

Donc, relis tous les messages précédents, pour comprendre le code suivant, qui fonctionne.

public class Terrain extends Forme {
    private Forme[] batiments;
    private int nbBatiments;

    public Terrain(Forme... formes) {
        batiments = new Forme[10];
        nbBatiments = 0;
        for (int i = 0; i < formes.length; i++) {
            ajouterForme(formes[i]);
        }
    }

    public void ajouterForme(Forme forme) {
        batiments[nbBatiments] = forme;
        nbBatiments++;
    }

    @Override
    double calculerSurface(){
        double surfaceTotale = 0;
        for (int i = 0; i < nbBatiments; i++) {
            surfaceTotale = surfaceTotale + batiments[i].calculerSurface();
        }
        return surfaceTotale;
    }

    public void afficherSurfaceTotale(){
        System.out.println("La surface totale est de " + calculerSurface());
    }

    public void afficherTaille(){
        System.out.println("La taille du tableau est " + batiments.length);
        System.out.println("Le nombre de valeurs dans le tableau est " + nbBatiments);
    }

    public static void main(String argums[]) {
        Rectangle r = new Rectangle(3, 3);
        Triangle t = new Triangle(2, 2);
        Cercle c = new Cercle(2);
        Terrain terrain = new Terrain(r, t, c);
        terrain.afficherTaille();
        terrain.afficherSurfaceTotale();
    }
}

Merci KX, je vais analyser ce code.