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
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
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).
qui dit Dieu n'existe pas dis que les programmes tournent sans processeur.
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
... tandis qu'il est tout simplement impossible d'hériter en même temps de plusieurs classes (abstraites ou non)
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
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
"Le plug gros problème des citations trouvées sur internet, c'est qu'on ne peut jamais garantir leur authenticité"
Confucius, 448 av. J-C
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(){...} }
Non il ne peut y avoir deux méthodes avec la même signature dans une classe.
Sinon avec l'appel:
Comment le compilateur saurais laquelle appeler?
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4 Point p = new Point(); //du code p.modif();
-"Tout ça me paraît très mal organisé. Je veux déposer une réclamation. Je paye mes impôts, après tout!"
-"JE SUIS LA MORT, PAS LES IMPÔTS! MOI, JE N'ARRIVE QU'UNE FOIS".
Pieds d'argile (1996), Terry Pratchett 1948 - 2015
(trad. Patrick Couton)
non effectivement on peut pas. et @overide ne sert pas du tout a ca
C'est à cela que sertEnvoyé par Man_Utd
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4 /* COMMENTAIRES!!! */
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.Envoyé par Descent
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
1)Expliquer brièvement pourquoi on a besoin d'un super-type Node
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);} ........... }
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
crée l'arbre ci-dessous(l'arbre est comme cela:
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);
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.
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èmeEnvoyé par lunatix
Vous avez un bloqueur de publicités installé.
Le Club Developpez.com n'affiche que des publicités IT, discrètes et non intrusives.
Afin que nous puissions continuer à vous fournir gratuitement du contenu de qualité, merci de nous soutenir en désactivant votre bloqueur de publicités sur Developpez.com.
Partager