Bonjour, j'écris ce post car j'ai du mal dans la réussite de mon exercice.

Le sujet : crée une maison dans le fichier main. Cette maison comporte des etages, chaque étages comprte des pieces et chaques pièces comporte des equipements.
Un exercice classique de programmation, mais je n'ai pas le droit d'utiliser l'héritage ni une classe toute faite de Liste comme LinkedList ou autres.

Mon problème est qu'une classe me pose problème lorsque je créer un equipement supplémentaire dans la liste ou lorsque je veux afficher cette liste.

Mon second problème est que mon delai de rendu expire ce soir à minuit.

Voici les classes du code :

La classe equipement :

public class equipement 
{	
	static String nomEquipement;
	
	
	public equipement()
	{
		nomEquipement = null;
	}
	
	public equipement (String nom)
	{
		nomEquipement = nom;
	}
}

La classe ListeEquipement :

class ListeEquipement {
  /**
   * attribut permettant de stocker le premier élément d'une liste non vide
   */
  equipement   _premier;
  
  /**
   * attribut permettant de stocker le reste d'une liste non vide
   */
  ListeEquipement _reste;
  
  /**
   * réalisation de l'opération 'vide' : constante (variable statique finale)
   * définissant la liste vide
   */
  static final ListeEquipement vide = null;
  
  /**
   * réalisation de l'opération 'estVide', retournant vrai ou faux
   * selon que la liste est vide ou non, respectivement
   */
  static boolean estVide(ListeEquipement L) { return L == vide; }

  /**
   * réalisation de l'opération 'premier', retournant le premier élément d'une
   * liste non vide (lève une exception si la liste est vide)
   */
  static equipement premier(ListeEquipement L) {
    if (estVide(L)) throw new operationIllegaleSurListeVide();
    else            return L._premier;
  }
  
  /**
   * réalisation de l'opération 'reste', retournant le reste d'une
   * liste non vide (lève une exception si la liste est vide)
   */
  static ListeEquipement reste(ListeEquipement L) {
    if (estVide(L)) throw new operationIllegaleSurListeVide();
    else            return L._reste;
  }

  /**
   * constructeur exploité par 'ajout'
   */
   ListeEquipement(equipement e, ListeEquipement L) {
    this._premier = e;
    this._reste   = L;
  }
  
  /**
   * réalisation de l'opération 'ajout', retournant une liste
   */
  static ListeEquipement ajout(equipement e, ListeEquipement L) { return new ListeEquipement(e, L); }

  /**
   * fonction permettant de construire rapidement une liste à partir d'un tableau d'entiers
   */
  static ListeEquipement depuisTableau(equipement[] T) {
    ListeEquipement L = vide;
    for (int i=T.length-1; i>=0; i--) L = ajout(T[i], L);
    return L;
  }
  
 
  /**
   * fonction produisant la représentation d'une liste sous forme de texte
   */
  static String versString(ListeEquipement L) {
    String représentation = "[", séparateur = "";
    for (; ! estVide(L); L = reste(L)) {
      représentation += séparateur+premier(L);
      séparateur = " ";
    };
    return représentation+"]";
  }

  

  /**
   * fonction retournant le nombre d'éléments d'une liste
   */
  static int longueur(ListeEquipement L) {
    if (estVide(L)) return 0;
    else            return 1+longueur(reste(L));
  }
  
  /**
   * fonction retournant le dernier élément d'une liste non vide, -1 sinon
   */
  static equipement dernier(ListeEquipement L) {
    if (estVide(L))             throw new operationIllegaleSurListeVide();
    else if (estVide(reste(L))) return premier(L);
    else                        return dernier(reste(L));
  }

  /**
   * fonction comptant le nombre d'occurences d'un entier e dans une liste L
   */
  static int compter(ListeEquipement L, equipement e) {
    if (estVide(L))           return 0;
    else if (premier(L) == e) return 1+compter(reste(L), e);
    else                      return compter(reste(L), e);
  }
  
  
  /**
   * fonction effaçant toutes les occurences d'un entier e dans une liste L
   */
  static ListeEquipement effacer(ListeEquipement L, equipement e) {
    if (estVide(L))           return L;
    else if (premier(L) == e) return effacer(reste(L), e);
    else                      return ajout(premier(L), effacer(reste(L), e));
  }
}

Le classe piece :

public class piece 
{
	String nomPiece;
	ListeEquipement listEquip;
	
	piece()
	{
		nomPiece = null;
		listEquip = null;
	}
	
	piece(String nom)
	{
		this.nomPiece = nom;
		this.listEquip = null;
	}
	
	piece(String nom, ListeEquipement list)
	{
		this.nomPiece = nom;
		this.listEquip = list;
	}
	
	
	public boolean ajoutEquipement(String nom)
	{
		equipement e = new equipement(nom);
		
		listEquip = new ListeEquipement(e, listEquip);
		
		if (listEquip._premier != e)
			return false;
		else
			return true;
	}
	
	public ListeEquipement effacer(equipement e)
	{
		return listEquip.effacer(listEquip,  e);
	}
	
	public ListeEquipement modifier(ListeEquipement L, equipement eOriginal, equipement eNouveau)
	{
		if (listEquip._premier == eOriginal)
			listEquip._premier = eNouveau;
		else 
			modifier(listEquip._reste, eOriginal, eNouveau);
		
		return listEquip;
	}
	
	public void afficher(ListeEquipement L)
	{
		if(L.estVide(L))
			throw new operationIllegaleSurListeVide();
		else if (L.estVide(L.reste(L)))
			Terminal.ecrireString("\n\t\t" +L._premier.nomEquipement);
		else
		{
			Terminal.ecrireString("\n\t\t" + L._premier.nomEquipement);
			Terminal.ecrireString(L.dernier(listEquip).nomEquipement);
		}
	}
}

Le fichier main :

public static void main(String[] args) {
		
		
		piece p = new piece("rdz");
		
		p.ajoutEquipement("chaise");
		p.afficher(p.listEquip);
		
		p.ajoutEquipement("table");
		p.afficher(p.listEquip);
		
		//p.ajoutEquipement("bureau");		
		//p.afficher(p.listEquip);
		
	}

Lorsque j'exécute le code en console, il affiche :

chaise
tabletable


J'ai donc l'impression que dans la fonction ajoutEquipement, il s'ajoute deux fois l'equipement envoyé ou que la fonction affichage n'affiche pas toutes les ligne de la liste.

pour l'instant je n'ai que ces classe là, la suite je la ferait dès que celle ci fonctionneront.

Merci pour votre aide

bonjour,

• Titre incorrect, je t'invite à les choisir de manière plus explicite à l'avenir.
• Nous ne sommes pas ici pour faire ton devoir à ton place ! Tu viens ici pour exposer une erreur précise avec des bouts de code précis qui concerne ton erreur. Donner l'entièreté de ton code et sous-entendre "Voici ce que j'ai fais, débrouillez-vous avec, il faut que ça marche !". Non !

Je ferme.