Problème de compréhension

Problème de compréhension - Java - Programmation

Marsh Posté le 23-02-2006 à 13:57:02    

Bonjour,
 
 
J'ai un probème de compréhension de l'énoncé qui me demandait de faire cet exo.
 
On me dit que la classe Tree à telle méthode et on me demande d'utiliser @Override pour réécrire les méthodes size(),toString() dans Tree ,or on ne peut pas utiliser 2 méthodes d'une même classe ayant la même signature,profil,...
 
Je voudrais savoir si quelqu'un avait une idée de ce qui doit être fait car je bloque.
 
Merci
 
Voici l'énoncé et ce que j'ai fait

Citation :

Une classe Tree implémente des arbres dont les noeuds (noeuds internes ou feuilles) contiennent une donnée de nom data (un int) et ont un nombre quelconque de fils.Pour éviter de stocker une liste de fils dans les noeuds sans fils (les feuilles),on utilise 2 classes Leaf et InternalNode.
La classe Leaf représente les noeuds sans fils ayant un ou plusieurs fils .Dans les noeuds internes ,les fils sont représentés par un champ children de type List<Node>.  
La classe Tree comprend  
 

Code :
  1. public class Tree { 
  2. private final Node root; 
  3. public String toString() { return root.toString();} 
  4. public int size() { return root.size();} 
  5. public boolean contains(int i) { return root.contains(i);} 
  6. ........... 
  7. }


 
1)Expliquer brièvement pourquoi on a besoin d'un super-type Node
 
2)Doit-on utiliser une interface ou une classe abstraite pour représenter le super-type Node?Justifier votre choix.
 
3)Expliquer pourquoi il faut un constructeur dans la classe Tree qui prend en ragument la racine de l'arbre.Écrire le code correspondant.
 
4)Indiquer l'ensemble des modificateurs de visibilité possibles pour la méthode size() de Node.
 
5)Écrire les autres classes (déclarations ,champs et constructeurs).Attention aux modificateurs de visibilité.Par exemple le code suivant
 

Code :
  1. List<Node> listThree = new ArrayList<Node>(); 
  2. listThree.add(new Leaf(5)); 
  3. listThree.add(new Leaf(6)); 
  4. List<Node> listOne = new LinkedList<Node>(); 
  5. listOne.add(new InternalNode(3,listThree)); 
  6. listOne.add(new Leaf(4)); 
  7. Node one = new InternalNode(1,listOne); 
  8. Tree tree = new Tree(one);


crée l'arbre ci-dessous(l'arbre est comme cela:  
l'arbre a pour racine 1 qui a trois fils 2,3,4(de gauche a droite), 3 a deux fils 5 et 6 )  
 
6)Écrire une méthode size() dans la classe Tree.La taille d'un arbre est son nombre de noeuds.
Indiquer le code des méthodes à ajouter dans les autres classes.Utiliser l'annotation @Override.
 
<...>


 
 
j'ai écrit l'interface et les différentes classes que l'on me demandait de faire dans un exercice.
 

Code :
  1. interface Node{
  2. String toString();
  3. int size();
  4. /*boolean contains(int i);*/
  5. }


 

Code :
  1. public class Leaf implements Node{
  2. private int data;
  4. public Leaf(int data){
  5. this.data = data;
  6. }
  8. public String toString(){
  9. return (new Integer(data)).toString();
  10. }
  12. public int size(){
  13. return 1;
  14. }
  16. public boolean contains(int i){
  17. return data == i;
  18. }
  19. }


 

Code :
  1. import java.util.*;
  3. public class InternalNode implements Node{
  4. private int data;
  5. private List<Node> childrens;
  7. public InternalNode(int data, List<Node> childrens){
  8. this.data = data;
  9. this.childrens = childrens;
  10. }
  12. public String toString(){
  13. StringBuilder sb = new StringBuilder();
  14. sb.append(data);
  15. sb.append(childrens.toString());
  16. return sb.toString();
  17. }
  19. public int size(){
  20. return 1 + childrens.size();
  21. }
  22. }


 

Code :
  1. import java.util.*;
  3. public class Tree{
  4. private final Node root;
  6. public Tree(Node root){
  7. this.root = root;
  8. }
  10. public String toString() {
  11. return root.toString();
  12. }
  14. public int size() {
  15. return root.size();
  16. }
  18. /*public boolean contains(int i) {  
  19.   return root.contains(i);
  20.   }*/
  22. public static void main(String [] args){
  24. List<Node> listThree = new ArrayList<Node>();
  25. listThree.add(new Leaf(5));
  26. listThree.add(new Leaf(6));
  28. List<Node> listOne = new LinkedList<Node>();
  29. listOne.add(new InternalNode(3,listThree));
  30. listOne.add(new Leaf(4));
  32. Node one = new InternalNode(1,listOne);
  34. Tree tree = new Tree(one);
  36. System.out.println(tree);
  37. }
  38. }

Reply

Marsh Posté le 23-02-2006 à 13:57:02   

Reply

Marsh Posté le 23-02-2006 à 16:59:45    

Citation :

On me dit que la classe Tree à telle méthode et on me demande d'utiliser @Override pour réécrire les méthodes size(),toString() dans Tree ,or on ne peut pas utiliser 2 méthodes d'une même classe ayant la même signature,profil,...


 
Non, on te demande d'ajouter le tag (javadoc) @Override aux méthodes que tu aura redéfinies dans une des classes fille.
 
PS : j'aurais vu Node comme classe abstraite plutot que comme une interface.

Message cité 1 fois
Reply

Marsh Posté le 23-02-2006 à 22:59:06    

(#Override est une annotation pas un tag javadoc, mais à priori n'a qu'un interet documentaire)


---------------
Hey toi, tu veux acheter des minifigurines Lego, non ?
Reply

Marsh Posté le 24-02-2006 à 08:10:08    

Bidem a écrit :

Citation :

On me dit que la classe Tree à telle méthode et on me demande d'utiliser @Override pour réécrire les méthodes size(),toString() dans Tree ,or on ne peut pas utiliser 2 méthodes d'une même classe ayant la même signature,profil,...


 
Non, on te demande d'ajouter le tag (javadoc) @Override aux méthodes que tu aura redéfinies dans une des classes fille.
 
PS : j'aurais vu Node comme classe abstraite plutot que comme une interface.


Bonjour,
 
est ce que tu pourrais m'indiquer comment tu fais pour savoir qu'il est préférable d'utiliser une classe abstraite plutot qu'une interface dans le cas de cet exercice et dans un cas général.
 
Pour cet exo,si je définis la classe Node comme étant une classe abstraite,il n'y aura que des méthodes abstraites de définit car dans cette classe Node,il n'y a pas possibilites d'écrire un constructeur ou d'autres méthodes communes à InternalNode et Leaf.
Cela sera donc comme si c'était une interface  :??:

Reply

Marsh Posté le 24-02-2006 à 08:36:33    

la question est simple, si les deux classes qui vont dérivé ou implémenté ont du code commun, alors Classe abstraite, sinon Interface...

Reply

Marsh Posté le 24-02-2006 à 09:54:15    

Une interface ne définit que des signatures de méthodes (que des méthodes abstraites).
 
Une classe abstraite est une classe qui ne sera jamais instanciée mais qui peut quand même définir quelques méthodes non abstraites.
 
Dans ton cas, il y a l'attribut data est définit dans Leaf et InternalNode et je pense qu'il devrait se trouver au niveau de Node et la méthode contains() aussi.
Après il faut voir si tu dois redéfinir contains() dans les classes filles (ou pas ;)).

Message cité 1 fois
Message édité par Bidem le 24-02-2006 à 09:55:35
Reply

Marsh Posté le 24-02-2006 à 12:01:14    

Bidem a écrit :

Une interface ne définit que des signatures de méthodes (que des méthodes abstraites).
 
Une classe abstraite est une classe qui ne sera jamais instanciée mais qui peut quand même définir quelques méthodes non abstraites.
 
Dans ton cas, il y a l'attribut data est définit dans Leaf et InternalNode et je pense qu'il devrait se trouver au niveau de Node et la méthode contains() aussi.
Après il faut voir si tu dois redéfinir contains() dans les classes filles (ou pas ;)).


Salut,je n'avais pas mis l'énoncé en entier mais il faut redenir toutes les methodes suivantes :

Citation :


7)Expliquer pourquoi le constructeur d'InternalNode peut priendre en paramètre une List<?extends Node>.
 
8)Écrire une méthode boolean contains(int i) dans la classe Tree.Cette méthode renvoie true si l'arbre contient un noeud dont la valeur du cham est data est i.Indiquer le code des méthodes à ajouter dans les autres classes.  
 
9)Écrire une méthode toString() dans la classe Tree.Cette méthode renvoie une forme préfixe de l'arbre.Sur l'exemple ci-dessus,on obtient 1 2 3 4 5 6.Indiquer le code des méthodes à ajouter dans les autres classes.
 
10)Écrire une méthode boolean equals(Object o) dans la classe Tree.Cette méthode teste si l'objet passé en paramètre est un arbre égal a l'arbre this : meme forme ,et memes données.
 
11)Écrire une méthode traverse dans la classe Tree qui renvoie la liste des noeuds (List<Node> ) en ordre préfixe.
 
12)On ajoute le fait que la classe Tree implémente l'interface Iterable<Node>.Comment peut-on utiliser cette propriété?Donner un exemple.
 
13)Indiquer quelle est la méthode à implémenter pour que la classe Tree respecte l'interface Iterable<Node>.Écrire le code correspondant
 
14)Dans le but d'écrire une classe PrefixIterator qui parcourt l'arbre dans l'ordre préfixe(ordre identique à celui du toString()),quelle structure de données doit-on utiliser?
 
15)Donner le code de la classe PrefixIterator.On implémentera la méthode void remove() pour dire qu'elle n'est pas supportée.
 


 
Donc en faite ma classe Node sera comme ceci  
abstract class Node {
private int data;
int size();
boolean contains(int i);
}
 :??:

Reply

Marsh Posté le 24-02-2006 à 12:19:02    

D'après moi contains devrait être implémentée ici (et redéfinie dans InternalNode).
 
Mais cela n'engage que moi, quand on modélise un truc comme ça, il y a toujours plusieurs solutions valides ;)
 

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed