Operações aritméticas em Java

As operações aritméticas em Java seguem a mesma lógica encontrada em outras linguagens baseadas em C. Elas podem ser classificadas como unárias, quando envolvem um único operando, ou binárias, quando operam sobre dois operandos. Além disso, há a operação ternária, que utiliza três operandos. Um operando pode ser uma variável ou um valor numérico.

Operações Aritméticas Binárias

As operações aritméticas binárias realizam cálculos entre dois operandos numéricos. Elas incluem:

• Adição (+)

  Soma dois valores numéricos:

  content_copyopen_in_new

  int a = 10;
  int b = 7;
  int c = a + b;  // 17
  int d = 4 + b;  // 11

• Subtração (-)

  Subtrai um número de outro:

  content_copyopen_in_new

  int a = 10;
  int b = 7;
  int c = a - b;  // 3
  int d = 4 - a;  // -6

• Multiplicação (*)

  Multiplica dois valores:

  content_copyopen_in_new

  int a = 10;
  int b = 7;
  int c = a * b;  // 70
  int d = b * 5;  // 35

• Divisão (/)

  Divide um número pelo outro:

  content_copyopen_in_new

  int a = 20;
  int b = 5;
  int c = a / b;  // 4
  double d = 22.5 / 4.5;  // 5.0

  Quando a divisão envolve apenas números inteiros, o resultado também será um número inteiro, mesmo que seja armazenado em uma variável float ou double:

  content_copyopen_in_new

  double k = 10 / 4;  // 2.0
  System.out.println(k);

• Para obter um valor de ponto flutuante, pelo menos um dos operandos deve ser um número de ponto flutuante:

  content_copyopen_in_new

  double k = 10.0 / 4;  // 2.5
  System.out.println(k);

• Resto da divisão (%)

  Retorna o restante da divisão entre dois números:

  content_copyopen_in_new

  int a = 33;
  int b = 5;
  int c = a % b;  // 3
  int d = 22 % 4; // 2 (22 - 4 * 5 = 2)

Operações Aritméticas Unárias

As operações unárias operam sobre um único operando. Java possui duas principais operações aritméticas unárias: incremento (++) e decremento (--). Ambas possuem versões prefixadas e pós-fixadas.

• Pré-incremento (++x)

  A variável é incrementada antes de seu valor ser utilizado:

  content_copyopen_in_new

  int a = 8;
  int b = ++a;
  System.out.println(a);  // 9
  System.out.println(b);  // 9

• Pós-incremento (x++)

  O valor original da variável é utilizado antes de ser incrementado:

  content_copyopen_in_new

  int a = 8;
  int b = a++;
  System.out.println(a);  // 9
  System.out.println(b);  // 8

• Pré-decremento (--x)

  A variável é decrementada antes de seu valor ser utilizado:

  content_copyopen_in_new

  int a = 8;
  int b = --a;
  System.out.println(a);  // 7
  System.out.println(b);  // 7

• Pós-decremento (x--)

  content_copyopen_in_new

  int a = 8;
  int b = a--;
  System.out.println(a);  // 7
  System.out.println(b);  // 8

Prioridade das Operações Aritméticas

Cada operação tem uma prioridade específica, determinando a ordem em que são avaliadas. A ordem decrescente de prioridade é:

1. ++ (pós-incremento), -- (pós-decremento)
2. (pré-incremento) ++ , (pré-decremento) --
3. * (multiplicação), / (divisão), % (resto da divisão)
4. + (adição), - (subtração)

No exemplo abaixo, a operação ++b tem maior prioridade. O valor de b é incrementado antes da multiplicação, que ocorre antes da soma:

int a = 8;
int b = 7;
int c = a + 5 * ++b;
System.out.println(c);  // 48

Parênteses podem alterar a ordem da avaliação:

int a = 8;
int b = 7;
int c = (a + 5) * ++b;
System.out.println(c);  // 104

Mesmo que a adição tenha menor prioridade, ela será avaliada antes da multiplicação porque está dentro dos parênteses.

Associatividade das Operações

Quando operadores possuem a mesma prioridade, a ordem de avaliação é determinada pela associatividade:

• Operadores associativos à esquerda são avaliados da esquerda para a direita. Isso inclui +, -, *, / e %.
• Operadores associativos à direita são avaliados da direita para a esquerda, como = e alguns operadores bit a bit.

Por exemplo, na expressão:

int x = 10 / 5 * 2;

Como a divisão e a multiplicação têm a mesma prioridade e são associativas à esquerda, a avaliação ocorre da esquerda para a direita, equivalente a (10 / 5) * 2, resultando em 4.

Operações com Números de Ponto Flutuante

Os números de ponto flutuante podem apresentar imprecisões devido à forma como são armazenados em binário. Esse problema pode ser crítico em cálculos financeiros. Por exemplo:

double d = 2.0 - 1.1;
System.out.println(d);

O resultado não será 0.9, mas sim 0.8999999999999999. Isso ocorre porque a representação binária de 0.1 não é exata. Para evitar esse problema, recomenda-se o uso da classe BigDecimal:

import java.math.BigDecimal;

BigDecimal d1 = new BigDecimal("2.0");
BigDecimal d2 = new BigDecimal("1.1");
BigDecimal result = d1.subtract(d2);
System.out.println(result);  // 0.9

Resumo

• Operações podem ser binárias (soma, subtração, multiplicação, divisão, resto) ou unárias (incremento e decremento).
• A prioridade dos operadores define a ordem de execução: multiplicação e divisão vêm antes de soma e subtração.
• A maioria das operações é avaliada da esquerda para a direita.
• Números de ponto flutuante podem ter imprecisões; para cálculos precisos, a classe BigDecimal é a melhor opção.

📝 Exercícios

Tarefa 1: Avaliação de expressão com incremento

Qual será o valor da variável z após a execução do código abaixo? Explique.

int x = 8;
int y = 9;
int z = x++ + ++y;

Tarefa 2: Precisão com double

O que será exibido no console após a execução do código abaixo?

double x = 8.8;
double y = 1.5;
double z = x - y;
System.out.println(z);

Tarefa 3: Diagnóstico de erro

O código abaixo compila corretamente? Justifique.

int result = 10.0 / 2;

Tarefa 4: Expressão com decremento

Qual será a saída do código abaixo?

int a = 2;
int b = 3;
int c = 4;
int resultado = a + --b * c - b;
System.out.println(resultado);