Discussion :

[VincentPiet]

Bonjour,

Le polymorphisme fait débat entre ce qui est à considérer comme du polymorphisme ou non :
http://blog.paumard.org/cours/java/chap07-heritage-interface-heritage.html#d0e6086

Si je comprends bien la question soulevée ici c'est :
Faut-il considérer comme polymorphisme quelque chose qui n'est pas universel (et donc le polymorphisme ad-hoc est-il justifié comme appellation) ?

Autre point, pourquoi la coercition n'est-elle pas considérée en java ? Je n'ai pu trouver que peu de discutions sur le sujet bien qu'au sens conceptuel le transtypage implicite semble tomber sous la coupe du polymorphisme.
https://cpp.developpez.com/faq/cpp/?page=Programmation-objet-en-Cplusplus#Qu-est-ce-que-le-polymorphisme

[Songbird]

Hello,

Pour répondre à la question de ton titre: il y en a 3 si l'on s'en réfère à m'sieur wiki:

* Le polymorphisme ad hoc:

Code Java :

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

1
2
3
4
5
6
7
8
9
10
public class MyClass {
 
    private final String foo;
    public MyClass(String foo) {
        this.foo = java.util.Objects.requireNonNull(foo, "foo cannot be null");
    }
    public MyClass() {
        this("Hello there!"); // surcharge
    }
}

* Le polymorphisme paramétré:

Code Java :

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

1
2
3
4
5
6
7
public class MyClass {
 
    public static <T> T foo(T a) { // généricité
        System.out.println("I'm a T objet ! :)");
        return a;
    }
}

* Le polymorphisme par sous-typage:

Code Java :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import java.util.Objects;
 
interface MyTrait {
    public void greetings(); // service hérité, programmation générique
}
class B implements MyTrait {
    private final String foo = "Hi, I'm a B object.";
 
    @Override
    public void greetings() {
        System.out.println(this.foo);
    }
}
public class MyClass implements MyTrait {
 
    private final String foo;
    public MyClass(String foo) {
        this.foo = Objects.requireNonNull(foo, "foo cannot be null");
    }
    public MyClass() {
        this("Hello there!");
    }
    public static void main(String args[]) {
        final B b = new B();
        final MyClass mc = new MyClass("Hi, I'm a MyClass object!");
        MyClass.sayHello(mc);
        MyClass.sayHello(b);
    }
 
    private static void sayHello(MyTrait mt) {
        mt.greetings();
    }
 
    @Override
    public void greetings() {
        System.out.println(this.foo);
    }
 
    public static <T> T foo(T a) {
        System.out.println("I'm a T objet ! :)");
        return a;
    }
}

Pour ce qui de la question "qu'est-ce qui se cache derrière le polymorphisme, qu'est-ce que l'on peut considérer comme du polymorphisme ?", je dirais qu'on peut considérer quelque chose comme du polymorphisme du moment où la mécanique respecte la définition qu'on en donne: polyvalence et traitement générique des types à partir d'une interface commune pouvant, accessoirement, assurer l’existence d'un ou des services sur chaque type implémentant cette interface.

EDIT: My bad, j'avais oublié de reprendre les termes de l'auteur de la page que tu as donné:

En toute rigueur, l' overloading n'est pas vraiment du polymorphisme, seul l' overriding l'est. En écrivant cela, je me rends compte que les polémiques entre les différents ayatollah de la programmation orientée objet sont éternelles. Evitons de rentrer dans ces passionnants débats, et expliquons juste les concepts.

Pour le polymorphisme ad hoc, effectivement on pourrait presque dire (si ce n'est pas totalement ça) que c'est du "match" de signature pour exécuter la bonne portion de code. Cela n'entre pas vraiment dans la définition stricte du polymorphisme, il me semble, mais cela reste quelque chose de polyvalent (dû à ce match justement).

Je ne sais pas si j'ai été clair, n'hésites pas à me le faire savoir.