JVM - Java é Verboso Mesmo? Parte II (A saga continua...)
Tags: java, beginners, jvm
Published: 2023-01-19 23:10:18

Fala Galera!
Bom, voltando aos estudos, hoje vamos trazer pra vocês a parte dois do estudo que iniciamos sobre a JVM e vou confessar, que doidera, quer mergulhar nesse conteúdo comigo? Vamos nessa!
No [artigo anterior](https://dev.to/eguadorodrigo/jvm-java-e-verboso-mesmo-parte-i-1fcc) falamos um pouco da JVM e agora vamos detalhar um pouco mais esse assunto...
No artigo anterior, ao fim dele, tivemos o problema da nossa execução no terminal não funcionar e o abismo se abrir diante de nós, certo? certo. Só que não só de abismos vive o ser humano!! 
Nos sistemas operacionais, quando temos casos semelhantes a este, significa que falta alguma coisa pra que aquele comando seja aceito, então, lembram do primeiro desenho das camadas de uma aplicação? Se não, olhem [aqui](https://dev.to/eguadorodrigo/e-a-certificacao-hein-3p6a).
A JVM fica guardada dentro de uma outra camada também conhecida como JRE, que por sua vez fica guardada dentro de outra camada que é a JDK, se tiver duvidas sobre o que é, revisita o link aí de cima que explico o que é cada camada.
E até aqui não fizemos nada além de escrever *uma classe Java* e como queremos ser desenvolvedores, né? então a JRE não é suficientemente capaz para apoiar a vida de um dev cabuloso do Java e por isso precisaremos do poder da JDK! 
Então por isso o sistema diz que "javac not found", ou seja, o sistema não encontrou o executável responsável pelo comando _javac_ que está contido na JDK. Claro, não fizemos a instalação de nada pra isso ser possível...ainda.
Então queridona, queridão, veja como fazer a instalação do JDK no seu sistema e vamos continuar em frente!! :)
Aqui, supondo que você já tenha uma JDK instalada no ambiente e o comando javac finalmente foi salvo o que será que você virá quando rodar o comando: 

```
javac Programa.java
```

A resposta é um sonoro:  Nenhum Acontecimento Deliberadamente Aconteceu ou podemos dizer também: *N.A.D.A.*

Calma!! Isso é bom, significa que sua classe Java COMPILOU!!! (uhull \o/)

No diretório que sua classe está, aparecerá agora um arquivo chamado Programa.class que também já expliquei nos artigos anteriores quem que lê e trata dele. E é agora que a brincadeira de verdade começa... 
Antes de continuar, acho que aqui é legal deixar duas dicas bem importantes por causa desse momento:

## Erros de Compilação Vs Erros de Execução

Você então aprendeu a compilar uma classe .java para um Bytecode .class.
Então, primeiramente: 
## Parabéns!! <3

Dito isto, um conceito essencial dentro do Java é o de erros. 
Na certificação é comum haver um enunciado dizendo "Dado o código abaixo, diga se ele compila", "Qual das opções há erro de execução?" ou qualquer coisa semelhante... e saber esse conceito vai te ajudar bastante.
Na prova ele tá perguntando é: Hey, essa classe ai, segue as semanticas da linguagem, está correta e se eu usar o comando de compilação vai dar bom? e caso não esteja, isso é o que dizemos ser *erros de compilação*. Uma classe compilada está escrita de, maneira tal, a passar pelo compilador e obtermos o Bytecode dela.
_Ah Rodrigo! e aquele erro de execução então? Eu não to executando o comando javac pra compilar? como é isso ai...?_
Os erros de execução são erros de lógica de escrita, quando você por descuido ou desconhecimento não cobre completamente um trecho do seu código e *durante a execução dele, isto é, após a classe já compilada*, dá erro. A execução neste caso não é o do comando de compilação, mas sim de dentro da tua classe Java por quaisquer que sejam os motivos.

Vejamos:

```
public class Programa {
    public static void main(String[] args) {
        System.out.println("Hello Programa!" + args[0]);
    }
}
```
Se fizermos essa alteração no nosso código a classe *compila*? Siiiim. 

_Ah cara, mas tá, eu sei que pra compilar usamos o *javac*, mas tu comentou ai de executar, como que eu faço?_

Bom, se você conseguiu compilar uma classe, a execução dela é bem simples, chamamos o famoso comando *java*. Vamos ver ele usando o nosso exemplo:

```
java Programa
```

Diferente da compilação, não precisamos dizer agora que vamos executar uma classe .java ou usar o Bytecode .class, o comando java entende que onde ele é invocado, existe uma ou mais classes compiladas pra execução, ele passa a classe invocada (no nosso caso a Programa) e envia ela para quem? para a JRE que possui quem? A JVM, muito bem! 
O arquivo Programa.class então é recebido para a execução, porém neste momento...

```
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 0 out
of bounds for length 0
        at Programa.main(Programa.java:3)
```
E esse é um exemplo prático de um *erro de execução*.

_- Rodrigo, mas que erro foi esse?_

Essas, meus amigos, são as queridinhas Exceções ! Nesse exemplo, vemos a *ArrayIndexOutOfBoundsException* uma das muitas exceções possíveis de serem lançadas durante uma execução.
Ela está dizendo que em um dado Array, ou seja, numa lista de objetos, foi feita a tentativa de se obter um dado no índice 0, mas tal indice não existe e por isso a execução falha. 

Sacou a diferença? 
```
* javac - comando de compilação (que pode gerar erros de compilação) 
* java - comando de execução (que pode gerar erros de execução) 
```

Por agora é isso pessoal, espero que estejam gostando da nossa jornada, se quiser tirar dúvidas, no meu perfil tem meu linktr com todas as minhas redes, sintam-se a vontade pra se conectarem comigo. Vamos juntos e até mais!! :)