J'y pense de cette façon
+----------------+
| super |
+----------------+ <-----------------+
| +------------+ | |
| | this | | <-+ |
| +------------+ | | |
| | @method1() | | | |
| | @method2() | | | |
| +------------+ | | |
| method4() | | |
| method5() | | |
+----------------+ | |
We instantiate that class, not that one!
Permettez-moi de déplacer cette sous-classe un peu vers la gauche pour révéler ce qui se trouve en dessous ... (Mec, j'adore les graphiques ASCII)
We are here
|
/ +----------------+
| | super |
v +----------------+
+------------+ |
| this | |
+------------+ |
| @method1() | method1() |
| @method2() | method2() |
+------------+ method3() |
| method4() |
| method5() |
+----------------+
Then we call the method
over here...
| +----------------+
_____/ | super |
/ +----------------+
| +------------+ | bar() |
| | this | | foo() |
| +------------+ | method0() |
+-> | @method1() |--->| method1() | <------------------------------+
| @method2() | ^ | method2() | |
+------------+ | | method3() | |
| | method4() | |
| | method5() | |
| +----------------+ |
\______________________________________ |
\ |
| |
...which calls super, thus calling the super's method1() here, so that that
method (the overidden one) is executed instead[of the overriding one].
Keep in mind that, in the inheritance hierarchy, since the instantiated
class is the sub one, for methods called via super.something() everything
is the same except for one thing (two, actually): "this" means "the only
this we have" (a pointer to the class we have instantiated, the
subclass), even when java syntax allows us to omit "this" (most of the
time); "super", though, is polymorphism-aware and always refers to the
superclass of the class (instantiated or not) that we're actually
executing code from ("this" is about objects [and can't be used in a
static context], super is about classes).
En d'autres termes, citant la spécification du langage Java :
Le formulaire super.Identifier
fait référence au champ nommé Identifier
de l'objet courant, mais avec l'objet courant vu comme une instance de la superclasse de la classe courante.
Le formulaire T.super.Identifier
fait référence au champ nommé Identifier
de l'instance lexicalement englobante correspondant à T
, mais avec cette instance considérée comme une instance de la superclasse de T
.
En termes simples, this
est essentiellement un objet (* l'objet **; le même objet que vous pouvez déplacer dans les variables), l'instance de la classe instanciée, une simple variable dans le domaine des données; super
est comme un pointeur vers un bloc de code emprunté que vous souhaitez exécuter, plus comme un simple appel de fonction, et il est relatif à la classe où il est appelé.
Par conséquent, si vous utilisez à super
partir de la superclasse, vous obtenez le code de la superduper classe [le grand-parent] exécuté), tandis que si vous utilisez this
(ou si elle est utilisée implicitement) d'une superclasse, il continue de pointer vers la sous-classe (car personne ne l'a changé - et personne pourrait).