Entrar Ainda não tem acesso?
Solucionado (ver solução)
Solucionado
(ver solução)
2
respostas

Desenvolva código que mostra o uso de polimorfismo > Exercício 8 ???

Referente ao curso Certificação Java SE 7 Programmer I: relações entre classes, no capítulo Desenvolva código que mostra o uso de polimorfismo e atividade Exercício 8

por Wagner Lima
| 106.3k xp | 14 posts

Boa tarde,

para o código abaixo descrito no exercício da certificação, não consegui entender o porque no momento da execução na classe B, a variável (i) quando volta com o valor negativo (-1) e faz um return voltando para execução na classe C, quando invoca novamente a classe B, pula a linha o if e pula a linha do this.x(-1) indo direto para o System.out.println("c");, dando o resultado de impressão de "b b c", alguém pode me explicar o que houve com o compilador no momento do return vazio???

import java.io.*;
class B {
    void x(int i) throws IOException {
        if(i<0) return;
        this.x(-1);
        System.out.println("c");
    }
}
abstract class C extends B {
    void x(int i) throws IOException {
        System.out.println("b");
        super.x(i);
    }
}
abstract class D extends C {
    void x(int i) throws IOException {
        super.x(i);
    }
}
class E extends D {
}
class A {
    public static void main(String[] args) throws IOException  {
        new E().x(32);
    }
}
2 respostas
solução!
por Joviane Fernandes Jardim
| 587.1k xp | 1013 posts
Instrutor Desenvolvedora e Instrutora

Oi Wagner, tudo bom?

O return vazio faz com que a execução saia daquele método não executando mais o que tem pra baixo.

Lembre-se que os métodos vão tendo a execução colocada numa pilha.

Vamos analisar a execução linha-a-linha:

// Dentro da classe A
1) new E().x(32); // Aqui é chamado o método de D pois E não implementou o método x.

// Dentro da classe D
2) super.x(i); // Aqui é chamado o método de C

// Dentro da classe C
3) System.out.println("b"); // Imprime o primeiro "b"
4) super.x(i); // Aqui é chamado o método de B

// Dentro da classe B
5) if(i<0) // Aqui da false pois i = 32
6) this.x(-1); // Aqui é chamado o método de D pois E não implementou o método x.

// Dentro da classe D
7) super.x(i); // Aqui é chamado o método de C

// Dentro da classe C
8) System.out.println("b"); // Imprime o segundo "b"
9) super.x(i); // Aqui é chamado o método de B

// Dentro da classe B
10) if(i<0) // Aqui da true pois i = -1
11) return; // sai da chamada do método de B voltando para quem tinha chamado

// termina a execução do passo 9, como não tem mais nada para executar, volta para quem tinha chamado
// termina a execução do passo 7, como não tem mais nada para executar, volta para quem tinha chamado
// termina a execução do passo 6, aqui falta um print a ser executado
12) System.out.println("c"); // imprime "c"

// termina a execução do passo 4, como não tem mais nada para executar, volta para quem tinha chamado
// termina a execução do passo 2, como não tem mais nada para executar, volta para quem tinha chamado
// termina a execução do passo 1 e acaba o programa

Ficou um pouco mais claro?

Abraço!

por Wagner Lima
| 106.3k xp | 14 posts

Obrigado Joviane, eu já havia executado no eclipse em modo debug para ver a execução, antes da sua explicação, embora tivesse visto a execução dar o mesmo resultado do exercício, não havia entendido bem o que executou, acho que o que foi mais confuso foi entender que o return em um método de objeto, retorna o controle para o próprio objeto para continuar no ponto de return a concluir a sua linha de execução até que ele libere novamente o restante das linhas de execução do método em questão. Quando vemos return dentro de outras estruturas fica mais fácil de entender o interrompimento da execução, passando para o restante do ciclo do código. O meu erro foi achar que return vazio dentro do método iria abandonar o restante de código que ainda estava por ser executado. Obrigado mais uma vez! Você e o Guilherme tem me ajudado muito.