Problème polymorphisme - @Override

Version imprimable

Bonsoir
Je cherche à comprendre le polymorphisme Java et j'ai trouvé cet exemple sur le net :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
package Fruit;
 
public class Fruit {
    public void name(){
        System.out.println("C'est du fruit");
    }
}
 
class Orange extends Fruit {
    @Override
    public void name(){
        System.out.println("C'est de l'orange");
    }
}
 
class Pamplemousse extends Fruit{
    @Override
    public void name(){
        System.out.println("C'est du Pamplemousse");
    }
}

Et pour exécuter le code j'utilise :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
package Fruit;
 
public class ExecuteFruit {
 
    public static void main(String[] args) {
    Fruit fruit=new Fruit();
    Fruit or=new Orange();
    Fruit pamp=new Pamplemousse();
 
    fruit.name();
    or.name();
    pamp.name();
 
 
    }
}

L'exemple fonctionne bien ! Mais je l'ai testé en supprimant @Override et ça marche ! Où est le rôle d'@Override ?

Merci pour l'aide.

12/03/2017, 21h58
Gugelhupf
Bonsoir,

Il existe plusieurs type de polymorphisme, pour ton exemple il s'agit là de polymorphisme d'inclusion.
Sachant que les méthodes sont virtuelles par défaut en Java, l'annotation @Override sert surtout à :
- A t'assurer que tu redéfinies bien une méthode (sinon le compilateur t'empêches de compiler)
- Documenter ton code source
Utilise cette annotation dès que tu peux.

A+
12/03/2017, 22h33
young077

Merci beaucoup Gugelhupf pour la réponse !
Est ce que vous pouvez me donner un exemple le plus simple qu'il soit là où le terme @Override se révèle indispensable ! juste pour comprendre ! Merci !
13/03/2017, 00h04
thelvin
Il est à la fois

- jamais indispensable, parce qu'on pourra toujours tout faire marcher sans lui

- toujours indispensable, parce que le service qu'il rend est toujours meilleur que ne pas l'avoir, donc tu ne peux pas en avoir trop.

Voici un exemple. Hier soir tu avais un peu bu et tu étais aussi fatigué, alors tu as tapé :
Code:

1 2 3 4 5 class Ananas extends Fruit { public void namme(){ System.out.println("C'est de l'ananas"); } }
Et tu n'as pas vraiment trop bien testé parce que bon, il y en avais des dizaines à faire, alors c'était un peu vite.

Malheureusement, la méthode namme() n'est jamais appelée et n'a aucun intérêt, et quand tu cherches à savoir le nom d'un Ananas, tu te chopes "C'est un fruit".
La raison en est que la méthode namme() est là et bien là, mais elle ne redéfinit pas la méthode name(), bien qu'elle ne pouvait évidemment pas servir à autre chose. Comment c'est possible ? Parce que tu es juste un humain et que tu as fait une erreur, en tapant deux fois sur 'm' au lieu d'une.

Mais alors, que faire ?? Toujours mettre @Override, notamment à ta méthode namme(). Le compilateur va alors te dire immédiatement que ta méthode namme() ne redéfinit rien du tout, donc, puisque tu dis que tu voulais redéfinir un truc, clairement tu t'es planté quelque part, toi pauvre humain.
13/03/2017, 00h41
Gugelhupf

@young077,

Dis-toi aussi que les annotations sont apparues avec Java 5, ce qui n'a jamais empêché le langage d'avoir du polymorphisme d'inclusion avant.
Idem pour d'autres langages tels que le C++ où le mot clé override n'est apparu qu'à partir de C++11, ce qui n'a jamais empêché le langage d'avoir du polymorphisme d'inclusion (à condition d'utiliser le mot-clé virtual par rapport à Java).
Utiliser le mot-clé @Override sert à s'assurer qu'on redéfinit bien une méthode, c'est aussi se rendre service à soi-même où à ses collègues lors d'une relecture de code.