[JAVA]Problème de compréhension

[Premium]

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

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

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);
}
}

[Sentinel]

Ton interface Node ne doit pas contenir de méthode toString(). Toutes les classes possèdent déjà cette méthode qu'elles héritent de la superclasse Object. Par contre tu peux l'overrider pour changer son comportement.

Les réponses aux questions 1, 2, 3 sont plutôt évidentes. La réponse 4 dépend de ce que tu as choisi en 2, et semble indiquer que ton prof considère qu'il vaut mieux utiliser une classe abstraite (la tournure de la question 6 le suggère fortement aussi).

Pour la question 6, attention elle est en deux parties. D'un côté, l'implémentation de la méthode size() dans Tree, qui ne nécessite pas l'utilisation d'@Override; de l'autre, l'écriture des méthodes permettant de calculer le nombre d'enfants dans les classes de type Node, et là tu auras besoin d'@Override si tu as pris le choix de faire une classe abstraite.

[Premium]

Ton interface Node ne doit pas contenir de méthode toString(). Toutes les classes possèdent déjà cette méthode qu'elles héritent de la superclasse Object. Par contre tu peux l'overrider pour changer son comportement.

Les réponses aux questions 1, 2, 3 sont plutôt évidentes. La réponse 4 dépend de ce que tu as choisi en 2, et semble indiquer que ton prof considère qu'il vaut mieux utiliser une classe abstraite (la tournure de la question 6 le suggère fortement aussi).

Pour la question 6, attention elle est en deux parties. D'un côté, l'implémentation de la méthode size() dans Tree, qui ne nécessite pas l'utilisation d'@Override; de l'autre, l'écriture des méthodes permettant de calculer le nombre d'enfants dans les classes de type Node, et là tu auras besoin d'@Override si tu as pris le choix de faire une classe abstraite.

Salut Sentinel,

comme je n'arrive jamais à savoir quand une interface ou une classe abstraite est préférable,est-ce que tu pourrais m'indiquer comme cela t'es apparu évident car j'ai cru qu'il fallait une interface.

Concernant la question 4,pourquoi dis-tu que cela dépend de ce qui a été choisi à la question 4 car dans une interface ou une classe abstraite ,tous est public

[Premium]

Concernant le fait d'écrire une méthode size() dans la classe Tree,je ne comprends pas pourquoi on demande d'écrire une methode size() alors que dans l'énoncé ,il y a déjà une methode size() de donné

int size(){return root.size()}

[Sentinel]

Une classe abstraite permet de définir :

- des méthodes abstraites, que les classes filles seront obligées d'implémenter.

- des méthodes concrètes qui définissent un comportement commun à toutes les classes filles. Une interface ne peut pas définir de méthodes concrètes.

Quant aux modificateurs, fais attention, tout n'est pas public :

- Une interface définit des méthodes implicitement "public abstract". Point final.

- Une classe abstraite peut posséder des méthodes concrètes ou abstraites, et définies comme privées, protected, publiques, ou package-access (quand on ne met aucun modificateur d'accès).

Ton prof te teste sur l'utilisation du modificateur "protected".

Relis tes cours :)

En ce qui concerne le choix d'une classe abstraite, je l'ai déduit de l'énoncé : utiliser @override. On n'override une méthode que dans lorsqu'une classe fille redéfinit ('override') une méthode de sa classe mère.

Dans ton cas ce serait une méthode de la classe abstraite Node, redéfinie dans les classes Leaf et InternalNode. Avec une interface, il n'y a pas d'héritage, dont pas de redéfinition de méthode... Donc pas d'override.

[Premium]

Bonjour,

à la lecture je comprends mais pour l'appliquer c'est une autre histoire

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

De plus,j'ai bien compris que seul des méthodes de classes héritées peuvent utiliser l'annotation @Override mais comment aurais-tu procéder pour savoir qu'il faille utiliser une classe abstraite si l'utilisation de @Override n'était pas demandé

[fabien29200]

Une classe abstraite peut contenir des méthodes concrètes.

Si tu faise

abstract class a

{

int a;

protected int getA()

{

return this.a;

}

}

Toutes les classes qui étendront a auront par défaut la méthode getA(). Tu peux aussi la redéfinir dans une classe fille pour changer le comportement de la méthode.