Java 101

Um bloco de código é uma estrutura que pode ser tanto obrigatória quanto opcional. Essa estrutura é definida {} e dentro desse bloco teremos um novo escopo de variáveis assim como as instruções que vão definir esse bloco. Por escopo entenda que toda variável definida dentro de um bloco será conhecida apenas por aquele bloco e todo bloco definido dentro dele. Vamos ver a definição de variável no próximo tópico.

Observe o código abaixo. Nele temos os blocos B1 a B4. Os blocos B1 e B2 fazem parte de estruturas mais complexas e são obrigatórios, que no caso são uma classe e um método respectivamente (não vamos falar da definição de classe e método por enquanto). Já os blocos B3 e B4 são opcionais e estão aí para mostrar que podemos criar um bloco quando bem entendermos, apesar dessa não ser uma prática comum no desenvolvimento Java. 🤓

Se você começar a brincar com esse código, vai ver que a variavel2 só pode ser usada dentro do B4. Isso é o que chamamos de escopo, ao finalizar a execução de B4 ela é completamente desnecessária e poderá ser eliminada da memória.

Se você pegar um código Java, ou de qualquer outra linguagem C-Like, vai perceber que o comportamento dele é sempre similar. Existe um método/função main que deve ter uma assinatura especifica e uma série de declarações.

No código acima, temos o mais simples Hello World escrito em Java. Quando a JVM vai executar esse código será feito como é feito em qualquer outra linguagem imperativa, primeiro a JVM lê a primeira declaração, executa ela alterando o estado do programa, e depois executa a próxima até não existirem mais declarações ou o programa for finalizado por alguma instrução.

Podemos dizer que toda estrutura Java é uma declaração e toda declaração tem significado. Declarações em Java devem ser separadas por ; ou devem conter um Bloco de código. Tudo que devemos entender de uma declaração é que ela tem um significado e que elas são executadas em sequencia.

Vamos imaginar um outro código hipotético que é composto pela chama de 3 métodos. Tudo que podemos supor é que as três declarações são executadas em sequência, desde que não aconteça nada excepcional.

Variáveis são posições da memória usadas para armazenar informações necessárias durante a execução do código. Uma variável pode ser de um tipo primitivo (byte, short, int, long, float double, boolean ou char) ou um objeto. Tipos primitivos diferem de objeto porque armazenam apenas um valor sem ter nenhum método associado a ele. Uma variável irá pertencer a um bloco de código e sua existência existe do momento da declaração até a finalização do bloco. Como falamos, variáveis são posições de memória, mas existem dois tipos de memória em Java, que vamos falar posteriormente, a heap e a stack. Tipos primitivos são declarados na heap, enquanto objetos são declarados na heap, isso significa que para tipos primitivos cada variável é uma posição única enquanto um mesmo objeto pode ser compartilhado por várias variáveis.

— Ein?!?!

Sim! A princípio é difícil de entender. Todo bloco de código possui um valor associado a uma variável, no tipo primitivo temos na variável o valor exato enquanto nos objetos temos uma referência ao valor. Vamos demonstrar por um exemplo? Dê uma olhada no código abaixo. Observer que uma definição de variável sempre é acompanhada no formato <tipo> <nome da variável> = <valor>;.

No código acima vemos os dois tipos de dados, temos a classe Usuario e temos o tipo primitivo int. Quando criamos uma variável do tipo primitivo a partir de outro valor, podemos alterar livremente o outro valor que a nova variável permanecerá inalterada. Mas o mesmo não acontece com a classe Usuario, que apesar de todos terem valores iguais, usr1 e usr2 por algum momento apontam para o mesmo objeto. usr3 nunca se altera porque é um objeto distinto mesmo tendo o mesmo valor que usr1 e usr2.

Na última linha do trecho de código usamos o valor null. null não é um tipo, apenas significa nulo em tradução livre, mas em computação significa a ausência de valor. É quando dizemos que uma variável não contem valor, ela não aponta para lugar nenhum. Variáveis que são tipos primitivos não pode ser nulas, elas deve sempre ter um valor associado.

Comentários são trechos de código que serão ignorados durante o processo de compilação. Apesar que alguns autores falam que todo comentário é uma falha, afirmação que eu discordo veementemente, eles são necessários para documentar informações que não podem ser documentadas no código. Tenha sempre em mente que comentários são necessários, com o tempo e a experiência você vai aprender sobre o que escrever nos comentários. Por enquanto vamos nos contentar em como comentar.

Existem 3 tipos de comentários em Java: 1. Comentários de fim de linha 2. Comentários tradicionais 3. Javadoc

Para criar um comentário em linha, adicione os dois caracteres // e tudo que você escrever até o fim da linha será desconsiderado durante a compilação. O exemplo abaixo foi retirado do código do Apache Kafka, apesar de estar em inglês ele contém informações relevantes ao código.

Para criar um comentário tradicional, inicie com / e todo caractere até encontrar o final / será desconsiderado. Abaixo temos mais um comentário retirado do código do Apache Kafka, ele explica a decisão de não existir um break naquela posição como veremos mais a frente.

O Javadoc é um tipo especial de comentário tradicional que nos permite gerar uma documentação oficial a partir do código. Ele se diferencia do comentário tradicional por iniciar com /**, não apenas /, e pode estar acima de classes, métodos e campos. Javadoc segue uma linguagem de marcação deve ser usada sempre, pois além de poder ser usada como documentação oficial, ela também será exibida pelas IDEs em funcionalidades que irão lhe auxiliar durante o desenvolvimento. Javadoc também aceita tags HTML, as não tente usar CSS e Javascript.

No exemplo abaixo temos um trecho da documentação oficial do Apache Kafka. É interessante notar que o autor desse código se preocupou em descrever a funcionalidade do método, e os motivos pelo qual as exceções são lançadas, mas ignorou a descrição do parâmetro porque é intuitivo. Evite comentários desnecessários.

Comentar código não é uma atividade simples, ela será trabalhada com a maturidade. Com o tempo você vai aprende que informações devem ser consideradas auxiliar ao código. Você não precisa comentar o que está no código, mas a informação que falta ao código, não é o como, mas o porque do código. Eu gosto de comentar pressupostos e escolhas arquiteturais porque em alguns meses eu não vou lembrar ou outra pessoa que pegar meu código também não vai saber o motivo de alguns escolhas.

Agora vamos ver a primeira declaração de fluxo que também é a mais comum. Mais conhecida como if, ou condicional, é composto por if (expressão booleana) <bloco> else <bloco>, onde expressão booleana é qualquer função que retorne um boolean ou uma expressão lógica que veremos em Operadores Lógicos. A expressão pode ser resumida para if (expressão booleana) <bloco> ou pode ser encadeada em várias outras declarações condicionais if (expressão booleana) <bloco> else if (outra expressão booleana) <bloco> else <bloco>.

No exemplo acima temos 3 expressões lógica. A primeira calcula se o valor é par então logicamente o bloco else será executado para todo valor impar. A segunda calcula se o valor é divisível por 3, isso significa que o bloco else será chamado para todo valor não divisível, mas com o if encadeado fazemos a visão daquele que são no formato 3x + 1 e 3x + 2. Vamos ver as expressões mais a frente.

Enquanto define que um bloco de código será executado até que uma expressão lógica seja falsa. A execução do bloco de código é feita continuamente logo depois do teste da expressão lógica. Exemplo?

O bloco de código acima será executado continuamente até que venha um valor 0 ou negativo.

O Faça enquanto funciona de forma bem similar, a diferença é que o teste é feito depois que o bloco de código é executado. Ele é muito similar a declaração anterior, a diferença é a ordem de execução entre o teste lógico e o bloco de código.

O famoso for é um pouco mais complexo. Ele é composto por 3 blocos que podem ser chamados de inicialização, condição e passo. Ao iniciar será executado uma única vez o trecho de código inicialização e em cada iteração será executado o trecho de código condição, que deve retornar uma expressão booleana, depois será executado o bloco de código para depois ser executado o trecho passo. O exemplo mais comum é para se iterar em um array.

O switch escolhe o código de acordo com o valor de uma variável. O switch é uma estrutura que pode facilmente induzir a erros porque cada bloco não é exclusivo, o fluxo de execução passar de um bloco ao outro até que seja encontrada a instrução break. Vamos ver um exemplo?

O que aconteceria se o valor de x for igual a 3? Seriam executados os blocos de 3 até o default.

Se quisermos um valor exato, podemos usar o break:

Agora você deve ter se perguntado porque no texto do bloco default eu usei menor que 1? Isso porque o switch não é usado para intervalos de valores, mas para valores exatos e caso nenhum valor seja igual aos valores declarados é chamado o bloco default.

Vale lembrar que o switch pode ser usado para números, enumeradores e qualquer valor constante, inclusive String.

Uma quebra deve ser chamada dentro bloco switch, while, do ou for. Ao se deparar com essa instrução o programa irá finalizar a execução do bloco externo imediatamente.

Vamos demonstrar isso com um exemplo básico? No código abaixo vamos criar um for que será finalizado usando break. Observe que o ponto de parada do for seria no máximo inteiro possível, mas através do break finalizamos em 10.

Quando usamos break dentro de um switch evitamos que os blocos de códigos abaixo dele seja executados.

O continue tem um comportamento parecido, mas ao invés de finalizar o bloco será apenas finalizada a iteração. Ele só é aceito em iterações como while, do ou for. Vamos incrementar o exemplo acima para imprimir apenas números impares. Observe que no código abaixo foi preciso mudar a condição de execução do break porque ele nunca seria executado se usássemos i == 10.

Se você leu a documentação atentamente, viu que break e continue podem aceitar rótulos. O que isso significa? Vamos imaginar que temos um loop encadeado em que buscamos um valor dentro de uma matrix. Como as linhas dessa matrix são ordenadas, se o valor em uma coluna for maior que o valor desejado, podemos pular para próxima linha. A decisão do break e do continue é feita usando os rótulos que todo bloco de código aceita.

Se não fosse usado um rótulo, o break e o continue iriam atuar somente no bloco de código mais interno.

O throw deve ser usado quando algo excepcional acontece. Algo inesperado, tanto que ele lança uma Exception, que significa exceção.

Exceções podem ser tratadas em código, mas as vezes elas não podem ser tratadas o que implica a finalização da execução. Ao se lançar uma exception, a JVM vai criar uma estrutura que contem o contexto da execução que chamamos de Stacktrace.

Para entender o que é uma Stacktrace, é preciso entender como um programa lida com contextos. Quando executamos um bloco de código é criado uma posição no topo da pilha de execução (stack é pilha em inglês). Ao terminar esse bloco, essa posição é removida da pilha. Vamos olhar o programa abaixo:

A pilha vai ter como fundação o método main, depois ela será formada por um encadeamento de chamadas ao métodos m1 e m2. Nenhum dos elementos é removido da pilha porque os métodos nunca terminam, els ficam se chamando até que a exceção do tipo RuntimeException seja lançada.

Esse exemplo é meramente didático para mostrar como funciona o uso do throw. Mas se alterarmos o tipo de RuntimeException para apenas Exception vemos que não será possível de compilar porque há uma exceção não tratada (Unhandled exception type Exception). Isso acontece porque existem 3 tipos de exceções:

Error não deve ser definido em um programa. Ele será lançado quando a JVM não souber lidar com uma situação especifica, o exemplo mais comum é o OutOfMemoryError quando a JVM não conseguir alocar mais memória.

Uma RuntimeException é uma exceção que acontece em tempo de execução, mas poderia ser resolvido com pequenas validações, ou seja, é algo deveria ter sido previsto. É o que acontece quando valores nulos não são validados (NullPointerException) ou quando acontece a divisão por zero (ArithmeticException).

Os demais casos devem estender a classe Exception, mas ela adicionará uma peculiaridade ao código. Se um método não trata um Exception, ele deve declarar que lança a mesma. Isso porque ela é um resultado esperado, mas que pode ou não ser tratado em código. Um exemplo? Quando estamos lidando com conexões de rede, sempre existe a possibilidade de a conexão ser finalizada, por isso sempre temos a IOException. Essa declaração se dá usando o throws e este não pode ser ignorado. Ou a exceção é tratado no método acima ou lançada para o próximo método.

synchronized deve ser usada com muita parcimônia. Nós vamos ver o seu uso mais a fundo quando formos falar de threads. Mas sendo sucinto, ela pode ser usada tanto para métodos quanto para objetos.

Para entender o conceito de sincronia, é preciso entender o que é paralelismo e concorrência. Eu tenho duas atividades que rodam em paralelo quando elas acontecem ao mesmo tempo e não há interferência entre si. Mas elas se tornam concorrentes quando existem recursos compartilhados que não podem ser acessados ao mesmo tempo.

Difícil de entender, não? Então vamos criar um modelo real. Digamos que uma loja tenha um livro caixa que deve registrar todas as vendas. Mas esse livro caixa só é atualizado no final do dia através das anotações de cada vendedor. Assim quando o vendedor realiza uma venda, ele faz uma anotação que depois será repassada para o livro caixa. As vendas acontecem em paralelo. Mas ao finalizar a venda existe o registro do estoque que é um caderno único que registra a entrada e saída de itens do estoque. Ou seja, quando o vendedor finaliza a venda, ele deve pegar o registro do estoque e adicionar uma saída. Se o vendedor A está em posse do registro, o vendedor B precisará ficar esperando, logo a baixa no caixa são operações concorrentes.

synchronized irá definir sob qual objeto será definida a sincronia da execução. Ele pode ser usado tanto para método (estático ou de instância) ou objeto avulso.

Para que a sincronia seja bem elaborada, devem ser usados também os métodos wait, notify e notifyAll. Mas nós veremos como isso deve ser feito mais a frente, caso você precise lidar com valores compartilhados, prefira usar AtomicReference ou outras classes do pacote java.util.concurrent.atomic.

Os operadores lógicos do Java são usados para se criar expressões booleanas. Uma expressão booleana só pode retornar dois tipos de valores: verdadeiro ou falso.

Como vimos no uso do if, devemos sempre definir um valor booleano, mas as vezes ele pode ser uma série de valores encadeados em uma expressão.

É muito importante saber resolver esses tipos de expressão, essa é um campo da matemática que se chama Algebra Booleana e, na minha opinião, é um dos requisitos mais básicos para desenvolvimento de software.

No Java tempos três operadores booleanos &&, || e !

Operadores binários realizam operações binárias. Para entender como funcionam operações binárias é preciso entender que toda informação é armazenada em formato binário, isso significa que o número 6544 é o mesmo valor de 0b0001100110010000 e 0x1990.

Operadores matemáticos realizam operações matemáticas básicas.

Operadores unários realizam operações matemáticas básicas usando uma única variável. Os operadores unários mais comuns são ++ e -- que fazem duas operações sequenciais: retornam o valor e alteram o valor da variável. A posição do operador irá influenciar na ordem das operações. Veja o código abaixo a diferença.

O operador unário pode ser usado também com expressões, mas para isso deve acompanhar o =. Veja no código abaixo.

O cast é uma conversão. Java é uma linguagem orientada a objetos, por isso todo valor estende a classe Object, mas todo valor tem uma própria classe. Usamos o cast em duas situações distintas, quando vamos lidar com classes mais especificas ou quando precisamos mudar o tipo de números.

O primeiro caso vamos ver mais a frente, já o segundo é quando precisamos alterar um tipo de valor para calculo matemático.

O operador condicional é como se fosse um if em uma só linha. Ele é composto de uma expressão booleana e dois blocos que devem retornar um valor.

Vamos supor que precisamos calcular o valor absoluto de um número inteiro, isso pode ser feito com uma linha só.