Operadores em Java

Tipos de Operadores

Aritméticos:

• Realizam operações matemáticas básicas.

Bitwise: Operam sobre bits.
Relacionais: Comparam valores.
Lógicos: Realizam operações lógicas.

Operadores Aritméticos

Operadores Básicos:

• Adição
• Subtração
• Multiplicação / Divisão % Módulo (resto da divisão)

Operadores Unários:

• Mais unário
• Menos unário

Operadores de Incremento e Decremento:
++ Incremento (adição de 1)
-- Decremento (subtração de 1)

Comportamento dos Operadores Aritméticos

• Operam em tipos numéricos e em char.

Divisão de Inteiros: Trunca o resto.

Exemplo: 10 / 3 resulta em 3.
Operador Módulo: Gera o resto da divisão.
Exemplo: 10 % 3 resulta em 1.

• Pode ser aplicado a tipos inteiros e de ponto flutuante.

class ModDemo {
    public static void main(String args[]) {
        int iresult = 10 / 3;
        int irem = 10 % 3;
        double dresult = 10.0 / 3.0;
        double drem = 10.0 % 3.0;
        System.out.println("Result and remainder of 10 / 3: " + iresult + " " + irem);
        System.out.println("Result and remainder of 10.0 / 3.0: " + dresult + " " + drem);
    }
}

Saída:
Result and remainder of 10 / 3: 3 1
Result and remainder of 10.0 / 3.0: 3.3333333333333335 1.0

Incremento e Decremento
Incremento (++): Adiciona 1 ao operando.

Exemplo: x = x + 1; é equivalente a x++;
Decremento (--): Subtrai 1 do operando.

Exemplo: x = x - 1; é equivalente a x--;

Formas Prefixadas e Posfixadas:

Prefixada: Incrementa/Decrementa antes de usar o valor na expressão.
Exemplo: ++x
Posfixada: Usa o valor na expressão antes de incrementar/decrementar.
Exemplo: x++

int x = 10;
int y = ++x; // y será 11, x será 11

Resumo dos Pontos-Chave
Java possui operadores para operações matemáticas, lógicas, relacionais e bitwise.
Operadores aritméticos incluem +, -, *, /, %, ++, --.
Operador % pode ser aplicado a inteiros e tipos de ponto flutuante.
Incremento (++) e decremento (--) têm formas prefixadas e posfixadas que afetam a ordem da operação.
É importante entender o comportamento dos operadores para evitar erros de lógica em expressões complexas.