Discussion :

[Premium]

Bonjour,

je voudrais savoir si quelqu'un avait une méthode pour savoir quand c'est mieux d'utiliser une interface plutot qu'une classe abstraite et inversement .

Merci

[let_me_in]

une interface quand toute tes methodes doivent etre redefinies(possible avec classe abstraite).
une classe abstraite quand tu peux ne modifier qu'une seule methode(impossible avec interface).

[Pill_S]

Hello,

la classe abstraite t'empêche d'hériter d'autre chose que d'elle-même pour implémenter les méthodes abstraites

l'interface, c'est un niveau supérieur d'abstraction, cela agit comme un genre de "greffe" de fonctionnalités diverses sur la classe qui l'implémente

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
// Désigne une classe capable d'écouter la souris et des actions
class MyClass implements MouseListener, ActionListener

... tandis qu'il est tout simplement impossible d'hériter en même temps de plusieurs classes (abstraites ou non)

Les interfaces amènent un semblant d'héritage multiple (sous une forme dérivée, puisque qu'on hérite d'aucune implémentation)

Les interfaces (bien utilisées) sont plus souples d'emploi, et plus puissantes (lorsqu'un algo traite avec des interfaces, il n'utilise qu'une description d'un fonctionnement: l'implémentation est complètement inconnue de l'utilisateur de l'interface, et peut donc être modifiée sans gêner personne)

Les classes abstraites sont à utiliser lorsqu'une classe n'est pas terminée, par exemple pour déterminer les comportements communs à plusieurs classes, et ne laisser que les comportements spécifiques à chaque classe concrète sous forme de méthodes abstraites
(ex pour un jeu d'échecs: 1 classe abstraite "Piece" et des classes Roi, Dame, Fou, Cavalier... qui en héritent)

Le schéma que j'utilise souvent c'est:

• 1 interface qui définit le comportement globale
  1 classe abstraite qui implémente l'interface et toutes les méthodes qui peuvent l'être
  Plusieurs classe finales qui héritent de la classe abstraite et implémentent le reste

[Premium]

Je voudrais également savoir s'il est possible de rédefinir une méthode d'une même classe en utilisant @Override.

Par exemple si j'ai une classe Point qui a une methode modif,est ce que ceci est possible

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
class Point{
 
public void modif(){...}
 
@Override public void modif(){...}
}

[Deadpool]

Non il ne peut y avoir deux méthodes avec la même signature dans une classe.

Sinon avec l'appel:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
Point p = new Point();
//du code
p.modif();

Comment le compilateur saurais laquelle appeler?

[lunatix]

non effectivement on peut pas. et @overide ne sert pas du tout a ca

[fearyourself]

Je voudrais également savoir s'il est possible de rédefinir une méthode d'une même classe en utilisant @Override.

Par exemple si j'ai une classe Point qui a une methode modif,est ce que ceci est possible

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
class Point{
 
public void modif(){...}
 
@Override public void modif(){...}
}

C'est à cela que sert

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
/*
COMMENTAIRES!!!
*/

[Premium]

Non il ne peut y avoir deux méthodes avec la même signature dans une classe.

Sinon avec l'appel:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
Point p = new Point();
//du code
p.modif();

Comment le compilateur saurais laquelle appeler?

C'est ce que je pensais ègalement mais dans l'énoncé d'un exo qu'on me demande de faire,il m'est donné une classe Tree avec des méthodes et on me demande d'écrire ces mêmes méthodes dans la classe.

Je n'ai peut-être pas compris l'énoncé

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
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.

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.

[Premium]

non effectivement on peut pas. et @overide ne sert pas du tout a ca

Je sais,cela sert à redéfinir des méthodes mères par exemple la méthode toString() de Object mais l'énoncé d'un exo me demande d'utilser @Override sur des méthodes d'une même classe ,d'ou mon problème