Primeiras aulas do curso Java parte 4: Entendendo exceções

Java parte 4: Entendendo exceções

Pilha de execução - Introdução

Olá! Esse curso possui foco em exceções, um assunto complexo, que engloba muitos outros vistos anteriormente. Assim, criamos esse curso para que você, aluno da Alura, saiba:

É um prato cheio para qualquer desenvolvedor Java! Juntos, entenderemos esse complexo tópico, de forma que você se sinta seguro diante às situações que enfrentaremos.

Nos vemos no próximo vídeo!

Pilha de execução - Pilha de execução

Você pode fazer o DOWNLOAD dos projetos criados no curso anterior.


Continuemos a nossa viagem pela plataforma e linguagem Java. Temos a versão 9 instalada, mas caso você tenha instalado uma das anteriores (6, 7 ou 8) em sua máquina, não se preocupe, pois o que veremos não é específico em relação às versões.

Também temos o Eclipse na versão Oxygen.2 instalado. Mas, caso você tenha uma versão mais antiga, não há problema. Usaremos o mesmo workspace do curso anterior, o eclipse-workspace.

Após abrir o Eclipse, criaremos um novo projeto Java para começar. Clicaremos com o botão direito na área do "Package Explorer > New > Java Project". O novo projeto será chamado de java-pilha. É um nome peculiar, pois o foco do primeiro tópico é o tratamento de exceções em geral, sendo esse um dos tópicos iniciais mais complicados do mundo Java. Clicaremos em Finish, para criar o projeto.

Antes de entrar nesses detalhes sobre erros e exceções, entenderemos como funciona o Java, internamente.

Adicionaremos uma nova classe à pasta src, clicando com o botão direito em "src > New > Class". Vamos chamá-la de Fluxo. Para ganharmos tempo, disponibilizaremos o conteúdo dela. Assim, você poderá copiar e colar na sua classe:

public class Fluxo {

    public static void main(String[] args) {
        System.out.println("Ini do main");
        metodo1();
        System.out.println("Fim do main");
    }

    private static void metodo1() {
        System.out.println("Ini do metodo1");
        metodo2();
        System.out.println("Fim do metodo1");
    }

    private static void metodo2() {
        System.out.println("Ini do metodo2");
        for(int i = 1; i <= 5; i++) {
            System.out.println(i);
        }
        System.out.println("Fim do metodo2");
    }
}

Temos então, o nosso querido método main(). Dentro dele, como podemos ver, existe uma chamada para o metodo1(), que é static, assim como a main(). Para chamar um método que não tem uma referência em mãos ou um objeto criado, ele precisa ser static.

No console, para as seguintes mensagens que serão exibidas:

Então, para cada finalização de execução de método, será impressa uma mensagem de conclusão, na seguinte ordem:

Se executarmos esse código, obteremos o seguinte resultado:

Ini do main
Ini do metodo1
Ini do metodo2
1
2
3
4
5
Fim do metodo2
Fim do metodo1
Fim do main

Esse é o resultado do fluxo. Repare que ainda não temos orientação a objetos, mas independente do paradigma de programação, usamos uma pilha de execução. Para entendermos melhor, trabalharemos a seguinte imagem:

Imagem que mostra o console e a pilha(stack), mostrando o seu fluxo

Como sabemos, um programa em Java sempre começa no método main(). A pilha ou stack existe para organizar a execução do código, lembrando o que ainda precisa ser executado.

O Java sempre irá procurar primeiro pelo método main(). Depois, ele cria a pilha e coloca o bloco de código dentro de outro, na pilha. Em seguida, o código do metodo1() é inserido nela.

A pilha existe para executar algo e lembrar o que ainda precisa ser executado.

Nessa imagem, a pilha contém primeiro o método main e, logo em seguida, o metodo1

Agora, é a vez do metodo1() entrar na pilha de execução. Repare que main() ainda não foi finalizado, porém ele não está sendo executado agora. Apenas o método que está no topo da pilha está sendo executado.

A partir do metodo1(), vem a chamada do metodo2, e todo o bloco de código é jogado dentro da pilha.

A pilha contém três métodos, sendo que o último método é o metodo2 que foi chamado a partir do metodo1

Agora, os métodos main() e metodo1() estão parados, pois ainda tem código a ser executado, no caso, as linhas do "Fim do metodo1" e "Fim do main". O metodo2() está sendo executado porque está no topo da pilha, que conseguirá removê-lo assim que terminar de executá-lo, quando não houver mais nada para executar.

Após a mensagem "Fim do metodo2", a pilha remove o metodo2

Quem está sendo executado agora é o metodo1(). O que sobrou nele é a linha que exibe a mensagem "Fim do metodo1". Depois que ele acaba, a pilha o remove e continua com a main(), que ficou por último.

Após a mensagem "Fim do metodo1", a pilha remove o metodo1

Voltando a main(), é exibida a linha que imprime "Fim do main". Com isso, ele é finalizado e retirado da pilha.

Imagem que mostra a pilha vazia, após terminar de executar o método main

Quando acabam os métodos da pilha, o Java entende que o processo foi encerrado.

Recapitulando: A pilha existe para saber qual método está sendo executado — o que está no topo — e lembrar quais ainda precisam ser executados. Entendido como ela funciona, podemos falar sobre os problemas de execução, as exceções.

Pilha de execução - Depuração

Anteriormente, estudamos sobre a pilha de execução, que é criada automaticamente. Em Java, a pilha padrão sempre começará com o método main() e pode crescer ou diminuir, dependendo de quais métodos serão chamados. A seguir, exploraremos como ela funciona, dentro do Eclipse.

Clicaremos duas vezes antes do número da linha que imprime "Ini do main":

Perceba que, à esquerda da coluna de identificação do número de linhas, apareceu o chamado Ponto de Depuração ou também conhecido como Breakpoint. Ele pausa a execução em um ponto específico, caso nós executemos o projeto em modo Debug. Ao debugarmos o programa, será possível ver as mudanças em tempo real, em uma velocidade que podemos acompanhar. Para isso, clicaremos com o botão direito em "main() > Debug As > Java Application".

Nesse momento, o eclipse irá sugerir a mudança de perspectiva, alterando a organização das janelas, pois existe uma perspectiva específica para a depuração. Iremos usá-la, clicando em "Sim". Encontraremos a pilha dentro da classe Fluxo:

O main(), que está na linha quatro, é o primeiro método que está sendo executado. Em função do breakpoint, que colocamos nessa mesma linha, o programa está parado nela. O Java está aguardando as nossas instruções. Para orientá-lo a avançar uma linha, utilizaremos os itens de navegação encontrados na perspectiva de debug:

Itens de navegação encontrados na perspectiva de debugging

Clicaremos no botão correspondente ao atalho "F6", o Step Over. Observe o que acontecerá:

Antes e depois do comando step over

O Java executou a linha que imprimia "Ini do main" e, depois, parou na seguinte, na chamada do metodo1(). E então, foi exibido no console a mensagem "Ini no main".

Entretanto, não queremos que o Java passe por cima desse método e pare na linha que imprime "Fim do main". No momento, queremos que ele acesse o método através dessa chamada. Caso você faça o teste de apertar o "F6" ou Step Over novamente, verá que o console ficará assim:

Ini do main
Ini do metodo1
Ini do metodo2
1
2
3
4
5
Fim do metodo2
Fim do metodo1

Todo o processo foi executado, até que chegasse a linha que imprimisse "Fim do main". Em função disso, não conseguimos ver o passo a passo. Essa foi a nossa primeira experiência com o debug. Vamos refazer esse processo, sem pular fases.

Após a finalização do processo, clicaremos no ícone de Bug, que contém o desenho de Besouro, e em "Debug Fluxo", para que o processo seja refeito. A execução irá parar novamente no método main(), na linha quatro.

Selecionaremos a opção "F6" ou Step Over. Como você pode reparar, a execução está parada na chamada do metodo1() e, em vez de passar pelo método novamente, entraremos nele. Para isso, utilizaremos o atalho "F5" ou Step Into.

O comando F5 entra no método

A partir desse ponto, vamos clicar mais uma vez em "F6". Com isso, a nossa aplicação para na chamada do metodo2(). Para entrar nesse método, utilizaremos novamente o atalho "F5".

Entrada no metodo2 a partir do comando F5

A partir daqui, utilizaremos somente o Step Over. À direita, podemos ver o valor da variável i:

Analisar o valor das variáveis

Feito o primeiro laço, a variável i presente ainda vale 1. Clicaremos em Step Over, novamente, para chegar no final do laço. Veja que o i foi incrementado para 2 e, no console, será impresso o valor 2. Vamos dar uma olhada em como está a pilha:

Em cima de main(), o metodo1() está parado, e acima dele, está o metodo2(), no topo da fila. Clicaremos no Step Over ou teclaremos "F6" para continuar a execução.

Depois de utilizar o Step Over, o metodo2 desaparece da pilha

Note que metodo2() desapareceu da pilha de execução, pois foi finalizado, movendo metodo1() para o topo da lista. Executaremos o "F6", e a mensagem "Fim do metodo1" aparecerá no console. Ao clicar novamente em "F6", o metodo1() sairá da pilha e voltaremos ao método main().

Executaremos, pela última vez, o Step Over para que main() saia da pilha. Finalizaremos o processo, clicando no botão "Resume" ou utilizando o atalho "F8".

Por meio da depuração, é possível ver o Java criando essa pilha passo a passo, trabalhando em uma velocidade mais humana, linha por linha. Assim, acompanhamos cada valor. Esse processo é muito útil quando nos deparamos com um problema e não sabemos o porquê.

Bom, o Eclipse nos mostrou uma nova perspectiva para o Debugging. Para voltar à anterior, repare que, no canto superior direito do Eclipse, temos opções de perspectivas disponíveis.

Perspectivas do Eclipse

A atual perspectiva é a de Debug, que contém um besouro no ícone. Estamos em busca da que contém um "J". Ao clicar nela, todas as janelas mudam de lugar e temos uma visão melhor do código Java.

O principal objetivo foi mostrar a pilha ao vivo. Mas, aproveitamos para aprender a depurar uma aplicação. Existem vários recursos de depuração, e temos também um curso específico sobre o Eclipse que vale a pena assistir.

Adiante, analisaremos as exceções em cima desse simples código que estamos trabalhando.

Sobre o curso Java parte 4: Entendendo exceções

O curso Java parte 4: Entendendo exceções possui 193 minutos de vídeos, em um total de 62 atividades. Gostou? Conheça nossos outros cursos de Java em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

Aprenda Java acessando integralmente esse e outros cursos, comece hoje!

  • 1150 cursos

    Cursos de programação, UX, agilidade, data science, transformação digital, mobile, front-end, marketing e infra.

  • Certificado de participação

    Certificado de que assistiu o curso e finalizou as atividades

  • App para Android e iPhone/iPad

    Estude até mesmo offline através das nossas apps Android e iOS em smartphones e tablets

  • Projeto avaliado pelos instrutores

    Projeto práticos para entrega e avaliação dos professores da Alura com certificado de aprovação diferenciado

  • Acesso à Alura Start

    Cursos de introdução a tecnologia através de games, apps e ciência

  • Acesso à Alura Língua

    Reforço online de inglês e espanhol para aprimorar seu conhecimento

Premium

  • 1150 cursos

    Cursos de programação, UX, agilidade, data science, transformação digital, mobile, front-end, marketing e infra.

  • Certificado de participação

    Certificado de que assistiu o curso e finalizou as atividades

  • App para Android e iPhone/iPad

    Estude até mesmo offline através das nossas apps Android e iOS em smartphones e tablets

  • Projeto avaliado pelos instrutores

    Projeto práticos para entrega e avaliação dos professores da Alura com certificado de aprovação diferenciado

  • Acesso à Alura Start

    Cursos de introdução a tecnologia através de games, apps e ciência

  • Acesso à Alura Língua

    Reforço online de inglês e espanhol para aprimorar seu conhecimento

12X
R$75
à vista R$900
Matricule-se

Premium Plus

  • 1150 cursos

    Cursos de programação, UX, agilidade, data science, transformação digital, mobile, front-end, marketing e infra.

  • Certificado de participação

    Certificado de que assistiu o curso e finalizou as atividades

  • App para Android e iPhone/iPad

    Estude até mesmo offline através das nossas apps Android e iOS em smartphones e tablets

  • Projeto avaliado pelos instrutores

    Projeto práticos para entrega e avaliação dos professores da Alura com certificado de aprovação diferenciado

  • Acesso à Alura Start

    Cursos de introdução a tecnologia através de games, apps e ciência

  • Acesso à Alura Língua

    Reforço online de inglês e espanhol para aprimorar seu conhecimento

12X
R$100
à vista R$1.200
Matricule-se

Max

  • 1150 cursos

    Cursos de programação, UX, agilidade, data science, transformação digital, mobile, front-end, marketing e infra.

  • Certificado de participação

    Certificado de que assistiu o curso e finalizou as atividades

  • App para Android e iPhone/iPad

    Estude até mesmo offline através das nossas apps Android e iOS em smartphones e tablets

  • Projeto avaliado pelos instrutores

    Projeto práticos para entrega e avaliação dos professores da Alura com certificado de aprovação diferenciado

  • Acesso à Alura Start

    Cursos de introdução a tecnologia através de games, apps e ciência

  • Acesso à Alura Língua

    Reforço online de inglês e espanhol para aprimorar seu conhecimento

12X
R$120
à vista R$1.440
Matricule-se
Procurando planos para empresas?
Acesso por 1 ano
Estude 24h/dia onde e quando quiser
Novos cursos toda semana