Olá pessoal, tudo bom?
Esse é um post básico da linguagem Java, mas que pode ser útil para vários níveis de desenvolvedores. O operador de incremento é utilizado para acrescentar uma unidade inteira ao valor de uma variável inteira. Existem diversos aspectos ligados a isso. Vamos explorar mais nesse post, confira na continuação.
Observações
Todos os códigos presentes aqui utilizam-se do JUnit para rodar. Se você nunca executou um teste unitário, existem alguns tutoriais aqui no site (link).
Além disso, para facilitar a execução desses códigos, eles estão disponíveis no projeto Exemplos no Repositório Git do Bitbucket. Se você não sabe como clonar um repositório, veja meus tutoriais Versionamento Git na IDE Eclipse.
Operador de Incremento
O operador de incremento é responsável por acrescentar uma unidade ao valor de uma variável. Ele é um operador unário, ou seja, não necessita de outra variável para realizar seu processo. Assim pense no seguinte código:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package br.com.mauda.exemplos.incremento.exemplos; import org.junit.Test; public class TesteIncremento001 { @Test public void teste(){ int variavel = 0; variavel++; System.out.println("Valor da variavel = " + variavel); } } |
Qual será o valor impresso no console?
|
1 |
Valor da variavel = 1 |
Assim a operação de incremento pode ser traduzida como o seguinte código:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package br.com.mauda.exemplos.incremento.exemplos; import org.junit.Test; public class TesteIncremento001 { @Test public void teste(){ int variavel = 0; variavel++; //variavel = variavel + 1; System.out.println("Valor da variavel = " + variavel); } } |
Operações de Pré Incremento e Pós Incremento:
Agora pense no seguinte código e responda o que será impresso no console:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package br.com.mauda.exemplos.incremento.exemplos; import org.junit.Test; public class TesteIncremento002 { @Test public void teste(){ int variavel = 0; System.out.println("Valor inicial da variavel = " + variavel); System.out.println("Pré incremento na variavel = " + ++variavel); System.out.println("Pós incremento na variavel = " + variavel++); System.out.println("Valor final da variavel = " + variavel); } } |
E aí quais foram os valores? Não vamos responder de uma vez, mas vamos observar linha a linha. Vamos pensar na linha 10, qual será o valor impresso? Se você verificar o código não há nenhuma diferença. O sinal de adição (“+”) ali é apenas o concatenador de Strings. Assim a impressão da linha 10 será a seguinte:
|
1 |
Valor inicial da variavel = 0 |
Agora vamos para a linha 11. Existe um operador ++ antes da variavel. Esse operador é chamado de pré incremento. A Java Virtual Machine (JVM) irá aumentar o valor da variável em 1 unidade durante o inicio da execução da linha. Assim antes de iniciar a impressão a JVM aumentou o valor da variável em 1 unidade, logo a impressão no console será:
|
1 |
Pré incremento na variavel = 1 |
Por fim a linha 12. Existe um operador ++ após a variavel. Esse operador é chamado de pós incremento. A JVM irá aumentar o valor da variável em 1 unidade após a execução da linha. Assim o valor da impressão no console será:
|
1 |
Pós incremento na variavel = 1 |
Não acredita então veja o que foi impresso durante a execução da linha 13:
|
1 |
Valor final da variavel = 2 |
Assim o console ficará da seguinte forma:
|
1 2 3 4 |
Valor inicial da variavel = 0 Pré incremento na variavel = 1 Pós incremento na variavel = 1 Valor final da variavel = 2 |
Aprofundando com operações de adição e pré incremento
Agora vamos pensar no seguinte exemplo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package br.com.mauda.exemplos.incremento.exemplos; import org.junit.Test; public class TesteIncremento003 { @Test public void teste(){ int varA = 0; int varB = 0; varB = ++varA + varB; System.out.println("Valor varA = " + varA); System.out.println("Valor varB = " + varB); } } |
Quais serão os valores impressos no console?
Vamos pensar na linha 11. No primeiro ponto o valor da variavel varA é zero. Ao utilizar o operador de pré incremento, varA passa a ter valor um. Já varB tem ao inicio da execução da linha 11 o valor de zero. Assim após essas explicações podemos substituir os valor por:
|
1 |
varB = 1 + 0; |
Logo o valor de varB ao fim da execução será 1. Em ambos os casos o valor será 1, conforme a impressão abaixo:
|
1 2 |
Valor varA = 1 Valor varB = 1 |
Aprofundando com operações de adição e pós incremento
Agora vamos colocar um operador de pós incremento no lugar do pré incremento, conforme o código abaixo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package br.com.mauda.exemplos.incremento.exemplos; import org.junit.Test; public class TesteIncremento004 { @Test public void teste(){ int varA = 0; int varB = 0; varB = varA++ + varB; System.out.println("Valor varA = " + varA); System.out.println("Valor varB = " + varB); } } |
Quais serão os valores impressos no console?
Vamos pensar na linha 11. No primeiro ponto o valor da variavel varA é zero. O operador de pós incremento será acionado apenas ao final da execução da linha 11 quando varA passará a ter valor um. Já varB tem ao inicio da execução da linha 11 o valor de zero. Assim após essas explicações podemos substituir os valor por:
|
1 |
varB = 0 + 0; |
Logo o valor de varB ao fim da execução será 0. Após o fim da execução da linha 11 o valor de varA passa a ser um, conforme a impressão abaixo:
|
1 2 |
Valor varA = 1 Valor varB = 0 |
Existem várias formas de brincar com os operadores de pré incremento e pós incremento futuramente iremos tratar disso em outros posts.
finnaly{
Duvidas ou sugestões? Deixe seu feedback! Isso ajuda a saber a sua opinião sobre os artigos e melhorá-los para o futuro! Isso é muito importante!
Até um próximo post!
Leave a Reply