Java: Operadores de incremento e decremento

Em várias questões sobre código na Linguagem Java, os examinadores usam os operadores de incremento e decremento. É importante entender como eles são usados para que saibamos como será resultado da execução dos códigos das questões de concursos. Então simbora!

Fala, meus consagrados! Tudo beleza com vocês?

Em várias questões sobre código na Linguagem Java, os examinadores usam os operadores de incremento e decremento. É importante entender como eles são usados para que saibamos como será resultado da execução dos códigos das questões de concursos. Então simbora!

Introdução

São os seguintes operadores unários:

Nome
Símbolo
Descrição
Mais
+
Indica valor positivo
Não é necessário usá-lo em números positivos
Menos
Nega uma expressão ou um número
Incremento
++
Incrementa um valor em um
Decremento
Diminui um valor em um
Complemento lógico
!
Inverte o valor de um boolean

São unários porque são aplicados em apenas um operando.

Por exemplo:

int x = 15;
System.out.println(“x: ” + ++x); // O resultado gerado é x: 16.

Operadores de incremento e decremento

Operador de incremento

Incrementa um valor em um.

Suponhamos que temos uma variável x do tipo int, se temos x++ é como se fosse x = x + 1.

Operador de decremento

Diminui um valor em um.

Suponhamos que temos uma variável x do tipo int, se temos x– é como se fosse x = x – 1.

Eles podem ser:

  • Pré-fixados; ou
  • Pós-fixados.

Pré-fixados

É avaliado o valor incrementado ou decrementado de uma variável. O valor trabalhado já é o incrementado ou decrementado.

Exemplo:

int x = 15, y = 15;
System.out.println(“x: ” + ++x); // O resultado gerado é x: 16.
System.out.println(“y: ” + --y); // O resultado gerado é y: 14.

No código acima, o valor impresso da variável x é o valor já incrementado e o valor impresso da variável y  é o valor decrementado.

Pós-fixados

É avaliado o valor original, ou seja, o valor trabalhado é o valor original de uma variável. Depois o valor da variável é incrementado ou decrementado.

Exemplo:

int x = 15;
System.out.println(“x: ” + x++); // O resultado gerado é x: 15.
System.out.println(“x: ” + x); // O resultado gerado é x: 16.

Na primeira impressão do valor da variável x, o valor dessa variável é o valor original (15), depois a variável é incrementada. Depois, na segunda impressão, o valor incrementado é impresso (16).

Faremos uma série de questões de concursos para entendermos como esses operadores são cobrados.

Questões de Concursos

[1] [Instituto AOCP 2019 IBGE – Analista Censitário – Análise de Sistemas – Desenvolvimento de Aplicações] A linguagem Java, possibilita trabalhar com operadores de pós-incremento e pré-incremento. Sabendo disso, analise o seguinte trecho de código e assinale a alternativa que apresenta o resultado correto do código dado.

(...)
int n = 100;
System.out.printf("%d%n", n);
System.out.printf("%d%n", n++);
System.out.printf("%d%n", n);
(...)

 

[A] 100, 100, 101.

[B] 100, 101,101.

[C] 100, 100, 100.

[D] 100, 200,100.

[E] 100, 200, 200.

Comentários:

Para dar contexto ao trecho do código da questão, vamos colocar em uma classe e comentá-lo:

01.public class Questao01 {
02.    public static void main(String []args) {
03.        int n = 100;
04.
05.        System.out.printf("%d%n", n); // Imprime 100.
06.        System.out.printf("%d%n", n++); // Imprime 100.
07.        System.out.printf("%d%n", n); // Imprime 101.
08.    }
09.}

O trecho de código da questão foi colocado dentro do método main da classe Questao01. Esse método faz com que a classe seja executável.

O resultado da execução da classe é:

100
100
101

Na linha 03, dentro do método main, há a variável local n do tipo int. Ela foi inicializada com o valor 100.

printf (System.out.printf()) é uma função que imprime um valor formatado. No caso, o valor da variável n será formatado na sua impressão (%d), seguido de uma quebra de linha (%n).

Não vamos entrar em detalhes nessa função e nos parâmetros de formatação. O importante é saber qual é valor da variável n será impresso:

  • Na linha 05, será impresso o valor de inicialização da variável n (100); e
  • Na linha 06:
    • Há o uso do operador unário pós-fixado na variável n, ou seja:
      • Será impresso valor original da variável n (100); e
      • Depois o valor dessa variável será incrementado (101); e
  • Na linha 07, será impresso o valor da variável n (101).

Com isso, o gabarito da nossa questão é a letra A.

Gabarito: letra A.

[2] [IDIB 2020 CRM/MT – Técnico em Informática] A linguagem de programação Java foi desenvolvida na década de 90, permanecendo até hoje como umas das linguagens de programação orientadas a objeto mais utilizadas em todo o mundo. A respeito das operações matemáticas que podemos fazer com Java, analise o código fonte abaixo e assinale a alternativa que indica corretamente o valor que será exibido em tela após sua execução.

[A] 1

[B] 2

[C] 8

[D] 4

Comentários:

Organizando e comentando o código:

01.public class Main {
02.    public static void main(String[] args) {
03.        int a = 0, b = 0, c = 0;
04.        
05.        a += 3; // a recebe 3.
06.        b = a++ + ++b; // b recebe 4 e a é atualizada para 4
07.        c = b % a; // c recebe 0.
08.        
09.        System.out.println(a + b + c); // Imprime o valor 8.
10.    }
11.}

A classe Main é uma classe executável, pois possui o método main. 90% das questões sobre código Java citam classes executáveis.

O resultado da execução da classe é:

8

O método main possui três variáveis locais do int, todas inicializadas com o valor 0: a, b e c.

Na linha 05 (a += 3):

  • A variável a recebe o valor atual dela (0) mais 3;
    • a += 3 que é equivalente a a = a + 3;
  • A variável a então recebe 3.

Na linha 06 (b = a++ + ++b):

  • Temos a soma do valor original da variável a (3) (depois ela é incrementada para valor 4) com o valor já incrementado da variável b (1);
    • Isso porque:
      • Na variável a é aplicado o operador de incremento pós-fixado; e
      • Na variável b é aplicado o operador de incremento pré-fixado;
  • A variável b então recebe 4;
    • Que é o resultado da soma;
  • A variável a fica com o valor 4;
    • Por conta do incremento do operador unário.

Na linha 07 (c = b % a):

  • A variável c recebe o resultado do resto da divisão do valor da variável b (4) pelo valor da variável a (4);
  • A variável c então recebe 0.

Na linha 09, é impresso o resultado da soma dos valores das variáveis a (4), b (4) e c (0), ou seja, será impresso o valor 8.

Portanto, gabarito é a letra C.

Gabarito: letra C.

[3] [IBADE 2018 IPM/JP – Analista Previdenciário – Analista de Redes e Comunicação] Java disponibiliza operadores aritméticos e relacionais para uso. Nesse sentido, considere as três situações caracterizadas a seguir.

[I] Avaliar o valor do operador w e após incrementar em uma unidade.

[II] Retornar TRUE se x é diferente de y.

[III] Obter o resto da divisão de x por y.

As sintaxes empregadas nas situações I, II e III são, respectivamente:

[A] ++w, x <> y e x $ y

[B] ++w, x != y e x % y

[C] w++, x <> y e x % y

[D] w++, x != y e x % y

[E] w++, x != y e x $ y

Comentários:

Analisando cada item:

  • Item I: “Avaliar o valor do operador w e após incrementar em uma unidade”;
    • Esse item está citando o operador unário de incremento pós-fixado;
      • Pois o incremento é feito após a avaliação do valor do operando;
    • w++;
  • Item II: “Retornar TRUE se x é diferente de y”;
    • Esse item descreve o operador diferente de (!=);
    • x != y;
  • Item III: “Obter o resto da divisão de x por y”;
    • É o operador aritmético módulo ou resto da divisão (%);
    • x % y;

A única letra cita de forma correta as sintaxes vistas na análise de cada item é a letra D.

Gabarito: letra D.

[4] [IADES 2011 PG/DF – Analista Jurídico – Analista de Sistemas] Analise o código fonte em Java a seguir e assinale a alternativa que apresenta o resultado da execução do programa.

Analise o código fonte em Java a seguir e assinale a alternativa que apresenta o resultado da execução do programa.

[A] Valores = 16

[B] Valores = 548

[C] Valores = 18

[D] Valores = 649

[E] Valores = 19

Comentários:

O código desta questão é bem parecido com o código da questão [2].

Organizando e comentando o código:

01.import java.io.*;
02.public class Calculadora {
03.    public static void main(String [] args) {
04.        int a, b, c;
05.
06.        a = 5; // a recebe 5.
07.        b = 3; // a recebe 3.
08.        c = a++ + ++b; // c recebe 9. a é atualizada para 6 e b, para 4.
09.
10.        System.out.println(“Valores = ” + a + b + c); // Imprime a string "Valores = 649".
11.    }
12.}

A classe Calculadora é uma classe executável, pois possui o método main.

O resultado da execução da classe é:

Valores = 649

O método main possui três variáveis locais do int: a, b e c.

Nas linhas 06 e 07, as variáveis a e b recebem 5 e 3, respectivamente.

Na linha 08 (c = a++ + ++b):

  • Temos a soma do valor original da variável a (5) (depois ela é incrementada para valor 6) com o valor já incrementado da variável b (4);
    • Isso porque:
      • Na variável a é aplicado o operador de incremento pós-fixado; e
      • Na variável b é aplicado o operador de incremento pré-fixado;
  • A variável c então recebe 9;
    • Que é o resultado da soma;
  • A variável a fica com o valor 6;
    • Por conta do incremento do operador unário.
  • A variável b fica com o valor 4.

Antes de explicar a linha 10, temos que conhecer como acontece a concatenação de strings na Linguagem Java. Se forem usados vários operadores de adição e vários operandos, a partir do primeiro operando do tipo String, terão a função de concatenar strings:

  • O operador de adição antes desse operando; e
  • Todos os operadores de adição após ele.

Exemplo:

String z = 15 + 8 + “Kal-El” + 15 + 8;
z terá valor de “23Kal-El158”
15 + 8 antes do operando “Kal-El” foram somados (23)
15 + 8 depois do operando “Kal-El” foram concatenados (158)

Voltando ao código, na linha 10, o que será impresso? Há o seguinte código “Valores = ” + a + b + c. Como temos o primeiro operando do tipo String, os operadores + nesse caso terão a função de concatenação de strings: Valores = 649. Ou seja, não teremos a soma dos valores das variáveis a, b e c (9 + 6 + 4 = 19). Isso é uma pegadinha do examinador para levar o candidato a marcar a letra E.

Com isso, o gabarito é a letra D.

Gabarito: letra D.

[5] [FGV 2010 BADESC – Analista de Sistemas – Desenvolvimento de Sistemas – Questão 35] Observe o código em Java a seguir, em que se pode verificar a aplicação dos operadores de pré-decremento e pós-decremento.

Após a execução do código, as variáveis m e n exibirão, respectivamente, os valores:

[A] 42 e 41.

[B] 42 e 42.

[C] 42 e 43.

[D] 43 e 42.

[E] 43 e 43.

Comentários:

Organizando e comentando o código:

01.public class Decrementa { 
02.    public static void main(String[] args) { 
03.        int m, n = 44; // m não foi inicializada e n recebe 44;
04.
05.        m = --n; // m recebe 43 e n é atualizada para 43.
06.        m = n--; // m recebe 43 e n é atualizada para 42.
07.
08.        System.out.println(m); // Imprime o valor 43.
09.        System.out.println(n); // Imprime o valor 42.
10.    } 
11.}

A classe Decrementa é uma classe executável, pois possui o método main.

O resultado da execução da classe é:

43
42

O método main possui duas variáveis locais do int: m e n. A variável n é inicializada com o valor 44.

Na linha  05 (m = –n), a variável m recebe o valor já decrementado da variável n (43):

  • Isso porque,  na variável n é aplicado o operador de decremento pré-fixado;
  • A variável m então recebe 43; e
  • A variável n fica com o valor 43.

Na linha  06 (m = n–), a variável m recebe o valor original da variável n (43) (depois ela é decrementada para valor 42):

  • Isso porque,  na variável n é aplicado o operador de decremento pós-fixado;
  • A variável m então recebe 43; e
  • A variável n fica com o valor 42.

Na linha 08, será impresso o valor da variável m: 43 e , na linha 09, o valor da variável n: 42.

Portanto, o gabarito é a letra D.

Gabarito: letra D.

[6] [FGV 2018 Banestes – Analista em Tecnologia da Informação – Desenvolvimento de Sistemas] O programa Java

produz o número:

[A] 0;

[B] 1;

[C] 2;

[D] 3;

[E] 4.

Comentários:

Organizando e comentando o código:

01.public class enigma { 
02.    public static void main(String[] args) { 
03.        int m = 0, n = 2; // m recebe 0 e n recebe 2;
04.
05.        do {
06.            m = ++m;
07.            n--;
08.        } while (n > 0);
09.
10.        System.out.println(m); // Imprime o valor 2.
11.    } 
12.}

A classe enigma é uma classe executável, pois possui o método main.

O resultado da execução da classe é:

2

O método main possui duas variáveis locais do int: m e n. A variável m é inicializada com o valor 0 e a variável n, com valor 2.

Há uma estrutura de controle do-while (linhas 05 a 08) no método main. Como a condição dessa estrutura é testada no final dela, então pelo menos uma iteração do do-while é feita.

Analisando a estrutura do-while:

  • Na primeira iteração:
    • Na linha 06 (m = ++m), a variável m recebe o seu valor já atualizada (1);
      • Isso porque,  na variável m é aplicado o operador de decremento pré-fixado;
    • Na linha 07 (n–), a variável n é decrementada (1);
    • Na linha 08 (while (n > 0)), é feito o teste se o valor da variável n é maior que 0;
      • Nesse caso, é sim (n tem o valor 1); e
      • Haverá outra iteração no do-while;
  • Na segunda iteração:
    • Na linha 06 (m = ++m), a variável m recebe o seu valor já atualizada (2);
      • Isso porque,  na variável m é aplicado o operador de decremento pré-fixado;
    • Na linha 07 (n–), a variável n é decrementada (0);
    • Na linha 08 (while (n > 0)), é feito o teste se o valor da variável n é maior que 0;
      • Nesse caso, não é (n tem o valor 0); e
      • A estrutura do-while é encerrada.

Na linha 10, será impresso o valor da variável m: 2. Portanto, o gabarito é a letra C.

Gabarito: letra C.

[7] [CESPE 2011 EBC – Cargo 12] A respeito de estruturas de controle de fluxo em algoritmos, julgue o próximo item.

Na linguagem Java, a expressão contador ← contador + 1 é representada, usando-se o operador de incremento  ++, por contador ++.

Comentários:

Em portugol, o operador de atribuição ← existe, mas na Linguagem Java, não. Em Java, usa-se o operador de atribuição =.

O texto correto para a questão seria o seguinte:

“Na linguagem Java, a expressão contador = contador + 1 é representada, usando-se o operador de incremento  ++, por contador ++”.

O gabarito anterior era CERTO, mas foi modificado para ERRADO pela seguinte justificativa:

“A representação proposta para a expressão tratada no item está equivocada, razão suficiente para a alteração do gabarito”.

Gabarito: ERRADO.

[8] [VUNESP 2016 Prefeitura de Presidente Prudente/SP – Programador de Sistemas Júnior] Considere o código Java a seguir:

float x = 0;
System.out.print(++x++);

Esse código

[A] compila e imprime o número 1 (um) quando executado.

[B] compila e imprime o número 0 (zero) quando executado.

[C] compila e imprime o número 2 (dois) quando executado.

[D] não compila, pois não é possível utilizar os operadores de incremento sobre uma constante.

[E] não compila, pois os operadores de incremento apenas podem ser aplicados a números inteiros.

Comentários:

Para dar contexto ao trecho do código da questão, vamos colocar em uma classe e comentá-lo:

01.public class Questao08 {
02.    public static void main(String []args) {
03.        float x = 0;
04.
05.        System.out.printf(++x++); // Não imprime nada porque gera um erro de compilação.
06.    }
07.}

O trecho de código da questão foi colocado dentro do método main da classe Questao08. Esse método faz com que a classe seja executável.

O resultado da execução da classe é:

enigma.java:5: error: unexpected type
        System.out.print(++x++);
                            ^
  required: variable
  found:    value
1 error

Vamos entender qual é o motivo do erro em tempo de compilação.

Na linha 03, dentro do método main, há a variável local x do tipo float. Ela foi inicializada com o valor 0.

Na linha 05, o código tenta imprimir o resultado da operação ++x++:

  • É aplicado na variável x dois operadores de incremento: pré e pós-fixado;
  • A primeira operação é aplicada é a operação de incremento pré-fixado:
    • A variável x é então atualizada para 1;
  • Depois é aplicada a operação de incremento pós-fixado no resultado da operação anterior;
    • Ou seja, seria como aplicar uma operação de incremento pós-fixado em um valor constante 1:
      • 1++;
    • Mas isso geral um erro:
      • Não é possível utilizar os operadores de incremento sobre uma constante.

Portanto, o trecho de código da questão gera um erro de compilação e o motivo é não é possível utilizar os operadores de incremento sobre uma constante. Ou seja, letra D.

Gabarito: letra D.

Espero que gostem e desejo que se preparem conosco durante essa jornada na conquista de uma tão sonhada vaguinha em um concurso público.

Então é isso!
[]’s e até a próxima!
_________________________

Professor Rogerão Araújo

Quer conquistar a sua aprovação em concursos públicos?
Prepare-se com quem mais entende do assunto!
Comece a estudar no Gran Cursos
Rogério Araújo
Rogério Araújo
Auditor Federal do STN, especialista em Governança em TI e professor de Desenvolvimento de Sistemas
Clique para comentar

Deixe seu comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Quer conquistar a sua aprovação em concursos públicos?
Prepare-se com quem mais entende do assunto!
Comece a estudar no Gran Cursos
Para o Topo