Eu penso assim
+----------------+
| super |
+----------------+ <-----------------+
| +------------+ | |
| | this | | <-+ |
| +------------+ | | |
| | @method1() | | | |
| | @method2() | | | |
| +------------+ | | |
| method4() | | |
| method5() | | |
+----------------+ | |
We instantiate that class, not that one!
Deixe-me mover essa subclasse um pouco para a esquerda para revelar o que está por baixo ... (Cara, eu adoro gráficos 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).
Em outras palavras, citando a Especificação da linguagem Java :
O formulário super.Identifier
se refere ao campo nomeado Identifier
do objeto atual, mas com o objeto atual visto como uma instância da superclasse da classe atual.
O formulário T.super.Identifier
se refere ao campo nomeado Identifier
da instância envolvente lexicamente correspondente a T
, mas com essa instância vista como uma instância da superclasse de T
.
Em termos leigos, this
é basicamente um objeto (* o ** objeto; o mesmo objeto que você pode mover em variáveis), a instância da classe instanciada, uma variável simples no domínio de dados; super
é como um ponteiro para um bloco de código emprestado que você deseja que seja executado, mais como uma mera chamada de função e é relativo à classe onde é chamado.
Portanto, se você usar super
da superclasse, você obterá o código da classe superduper [o avô] executado), enquanto se você usar this
(ou se for usado implicitamente) de uma superclasse, ele continuará apontando para a subclasse (porque ninguém a alterou - e ninguém poderia).