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

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:

public class Tree {  
 private final Node root;  
 public String toString() { return root.toString();}  
 public int size() { return root.size();}  
 public boolean contains(int i) { return root.contains(i);}  
 ...........  
}  

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:

List<Node> listThree = new ArrayList<Node>();  
listThree.add(new Leaf(5));  
listThree.add(new Leaf(6));  
List<Node> listOne = new LinkedList<Node>();  
listOne.add(new InternalNode(3,listThree));  
listOne.add(new Leaf(4));  
Node one = new InternalNode(1,listOne);  
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.

interface Node{
    String toString(); 
    int size();
    /*boolean contains(int i);*/
}

public class Leaf implements Node{
    private int data;
    
    public Leaf(int data){
    this.data = data;
    }
    
    public String toString(){
    return (new Integer(data)).toString();
    }
    
    public int size(){
    return 1;
    }
    
    public boolean contains(int i){
    return data == i;
    }
}

import java.util.*;

public class InternalNode implements Node{
    private int data;
    private List<Node> childrens;
    
    public InternalNode(int data, List<Node> childrens){
    this.data = data;
    this.childrens = childrens;
    }
    
    public String toString(){
    StringBuilder sb = new StringBuilder();
    sb.append(data);
    sb.append(childrens.toString());
    return sb.toString();
    }
    
    public int size(){
    return 1 + childrens.size();
    }
}

import java.util.*;

public class Tree{
    private final Node root;
    
    public Tree(Node root){
    this.root = root;
    }
    
    public String toString() { 
    return root.toString();
    } 
    
    public int size() { 
    return root.size();
    }
    
    /*public boolean contains(int i) { 
      return root.contains(i);
      }*/
    
    public static void main(String [] args){
    
    List<Node> listThree = new ArrayList<Node>(); 
    listThree.add(new Leaf(5)); 
    listThree.add(new Leaf(6)); 
    
    List<Node> listOne = new LinkedList<Node>(); 
    listOne.add(new InternalNode(3,listThree)); 
    listOne.add(new Leaf(4)); 
    
    Node one = new InternalNode(1,listOne); 
    
    Tree tree = new Tree(one); 
    
    System.out.println(tree);
    }
}