Oi Priscila, tudo bem?

• No exercício anterior, ele não entra em loop devido não ter o this, mas porque tem um ++ antes do i:

...
void x(int i) throws IOException {
     if(++i<0) return; // incremento aqui (++i)
        this.x(-1);
        System.out.println("c");
   }
...

Nesse caso, sempre que i cai no if como -1 primeiro é incrementado 1 no valor, pois o operador é de pré-incremento, passando a ser 0. Quando ocorre a valiação 0 < 0 retorna-se false. Nunca cai no return e entra em loop.

• Nesse execercício, que não a esse incremento em i, ele volta para imprimir b devido o polimorfismo. Se você tiver o código:

class Veiculo {
    void foo() {
      liga();
    }

    public void liga() {
        System.out.println("Ligando veículo");
    }
}

class Carro extends Veiculo {
    public void liga() {
        System.out.println("Carro está sendo ligado!");
    }
}

class Test {
  public static void main(String[] args) {
    new Carro().foo();
  }
}

Ele irá imprimir "Carro está sendo ligado."; mesmo tendo um liga() na classe veículo, ele invoca o liga() que foi sobrecrito na classe Carro.

Por fim esse exercício.

Perceba que temos uma instância de E, subclasse indireta de B.

Até chegar no x() da classe B você entendeu. Nesse momento i é 32, e portanto maior que zero. Então próxima instrução: this.x(-1);; aqui ele não vai chamar o x() da classe B, mas sim o da subclasse imediata, que é C, devido o polimorfismo.

Perceba que nesse momento a execução de x() em B ainda não terminou.

Quando o método em C é executado com -1, ele imprime "b" novamente e chama o x() de B através do super, mas passando -1 como argumento. Nesse momento o if passa e o return encerra a execução de x() em B, retorna o controle pra x() em C que não tem mais nada a executar.

Por fim, a chama de x() em B ainda estava ativa, e é encerrada imprimindo C.

É complicado explicar em texto e ficou bem grande.

Se não consegui ser claro, e só confundi mais, por favor me diga que tentamos de outra forma. :)

Abs.

Priscila, Boa Tarde!

Vou te mostrar o que está acontecendo com o programa :

no metodo main chama instacia E e chama x onde passa valedo 32 .

o E herda de D , onde i = 32 e vai para X do classe Pai que é C.

entra no metodo X de C , imprime b e passa para método X de B com valor 32 ;

Aqui que está a grande mudança , 32 é maior que zero dai ele chama this.x(-1);

a palavra this neste caso está invocando o método X no objeto , e não o método X da classe B , então ele retorna para o método x da classe E, que herda de D, passando -1

dai chama x da classe C , imprime novamente a letra b , chama o método x da classe B , ele verifica o valor que é menor que 0 , sai do if e imprime c

dando a resposta b,b,c

espero ter ajudado , Bons estudos

Lucas ,

respondeu enquanto escrevia , mas tudo bem espero ter ajudado !

Bons estudos

Haha, acontece! Quem sabe com as duas respostas fique mais claro. :)

Mas qualquer dúvida nos avise, Priscila.

Abraço!

Hahaha, duas explicações ficou melhor ainda, consegui entender o uso do this, mto obrigada Lucas e Celso! Abçs!

Pq quando ele dá retorno no método "x" da class "B" dentro do if, ele não sai do método sem executar a impressão de "c"?

void x(int i) throws IOException {
    if(i<0) return; // retorno
    this.x(-1);
    System.out.println("c"); // pq ele executa essa instrução após dar retorno no if
}

Pq quando ele dá retorno no método "x" da class "B" dentro do if, ele não sai do método sem executar a impressão de "c"?

void x(int i) throws IOException {
    if(i<0) return; // retorno
    this.x(-1);
    System.out.println("c"); // pq ele executa essa instrução após dar retorno no if
}