EnglishEnglish العربيةالعربية PortuguêsPortuguês Japanese日本語

Operadores

Operadores são usados para realizar operações em variáveis e valores. Esta lição cobre os vários operadores em Java.

Operadores Aritméticos

Operador Descrição Exemplo Resultado
+ Adição 5 + 3 8
- Subtração 5 - 3 2
* Multiplicação 5 * 3 15
/ Divisão 5 / 3 1 (divisão inteira)
% Módulo (resto) 5 % 3 2
++ Incremento i++ i aumenta em 1
-- Decremento i-- i diminui em 1

Exemplo: Operações Aritméticas

JAVA 
public class ArithmeticDemo {
    public static void main(String[] args) {
        int a = 10, b = 3;
        
        System.out.println("a + b = " + (a + b));  // 13
        System.out.println("a - b = " + (a - b));  // 7
        System.out.println("a * b = " + (a * b));  // 30
        System.out.println("a / b = " + (a / b));  // 3 (divisão inteira, decimais truncados)
        System.out.println("a % b = " + (a % b));  // 1
        
        // Divisão de ponto flutuante
        double c = 10.0, d = 3.0;
        System.out.println("c / d = " + (c / d));  // 3.3333...
    }
}
▶ Experimente
⚠️ Divisão inteira: Quando dois inteiros são divididos, o resultado também é um inteiro, e a parte decimal é truncada. Para obter um resultado decimal, pelo menos um operando deve ser um número de ponto flutuante.

Incremento e Decremento

JAVA 
int i = 5;

// Pós-incremento: usa primeiro, depois aumenta
int a = i++;  // a = 5, i = 6

// Pré-incremento: aumenta primeiro, depois usa
int b = ++i;  // b = 7, i = 7

Operadores de Atribuição

Operador Descrição Exemplo Equivalente a
= Atribuição a = 5 —
+= Adicionar e atribuir a += 3 a = a + 3
-= Subtrair e atribuir a -= 3 a = a - 3
*= Multiplicar e atribuir a *= 3 a = a * 3
/= Dividir e atribuir a /= 3 a = a / 3
%= Módulo e atribuir a %= 3 a = a % 3

Exemplo: Operações de Atribuição

JAVA 
public class AssignmentDemo {
    public static void main(String[] args) {
        int a = 10;
        System.out.println("Valor inicial: " + a);  // 10
        
        a += 5;
        System.out.println("a += 5: " + a);  // 15
        
        a -= 3;
        System.out.println("a -= 3: " + a);  // 12
        
        a *= 2;
        System.out.println("a *= 2: " + a);  // 24
        
        a /= 4;
        System.out.println("a /= 4: " + a);  // 6
        
        a %= 4;
        System.out.println("a %= 4: " + a);  // 2
    }
}
▶ Experimente

Operadores de Comparação

Operadores de comparação retornam um valor booleano (true ou false).

Operador Descrição Exemplo Resultado
== Igual a 5 == 5 true
!= Diferente de 5 != 3 true
> Maior que 5 > 3 true
< Menor que 5 < 3 false
>= Maior ou igual a 5 >= 5 true
<= Menor ou igual a 5 <= 3 false

Exemplo: Operações de Comparação

JAVA 
public class ComparisonDemo {
    public static void main(String[] args) {
        int a = 10, b = 20;
        
        System.out.println("a == b: " + (a == b));  // false
        System.out.println("a != b: " + (a != b));  // true
        System.out.println("a > b: " + (a > b));    // false
        System.out.println("a < b: " + (a < b));    // true
        System.out.println("a >= 10: " + (a >= 10)); // true
        System.out.println("a <= 5: " + (a <= 5));   // false
    }
}
▶ Experimente

Operadores Lógicos

Operador Descrição Exemplo Resultado
&& E lógico true && false false
|| OU lógico true || false true
! NÃO lógico !true false

Tabela Verdade dos Operadores Lógicos

A B A && B A || B !A
true true true true false
true false false true false
false true false true true
false false false false true

Exemplo: Operações Lógicas

JAVA 
public class LogicDemo {
    public static void main(String[] args) {
        int age = 25;
        boolean hasID = true;
        
        // Idade >= 18 e tem ID
        boolean canEnter = (age >= 18) && hasID;
        System.out.println("Pode entrar: " + canEnter);  // true
        
        // Idade < 12 ou > 60
        boolean isSpecial = (age < 12) || (age > 60);
        System.out.println("Categoria especial: " + isSpecial);  // false
        
        // NÃO lógico
        boolean isAdult = age >= 18;
        System.out.println("É adulto: " + isAdult);    // true
        System.out.println("Não é adulto: " + !isAdult);  // false
    }
}
▶ Experimente
💡 Avaliação de curto-circuito: && para se o lado esquerdo for false; || para se o lado esquerdo for true. O lado direito não é avaliado nesses casos.

Operador Ternário

O operador ternário é uma abreviação para if-else.

JAVA 
// Sintaxe: condição ? valor1 : valor2
int max = (a > b) ? a : b;

Exemplo: Operador Ternário

JAVA 
public class TernaryDemo {
    public static void main(String[] args) {
        int a = 10, b = 20;
        
        // Encontrar máximo
        int max = (a > b) ? a : b;
        System.out.println("Máximo: " + max);  // 20
        
        // Verificar ímpar ou par
        int num = 7;
        String result = (num % 2 == 0) ? "par" : "ímpar";
        System.out.println(num + " é " + result);  // 7 é ímpar
        
        // Valor absoluto
        int x = -5;
        int abs = (x >= 0) ? x : -x;
        System.out.println("Valor absoluto: " + abs);  // 5
    }
}
▶ Experimente

Precedência de Operadores

Operadores com maior precedência são avaliados primeiro. Use parênteses para alterar a precedência.

Precedência Operador Descrição
1 () Parênteses
2 ! ++ -- Operadores unários
3 * / % Multiplicação, divisão, módulo
4 + - Adição, subtração
5 < <= > >= Comparação
6 == != Igualdade
7 && E lógico
8 || OU lógico
9 ?: Operador ternário
10 = += -= etc. Atribuição

Exemplo: Precedência

JAVA 
public class PrecedenceDemo {
    public static void main(String[] args) {
        // Multiplicação tem maior precedência que adição
        int result1 = 2 + 3 * 4;
        System.out.println("2 + 3 * 4 = " + result1);  // 14, não 20
        
        // Use parênteses para alterar a precedência
        int result2 = (2 + 3) * 4;
        System.out.println("(2 + 3) * 4 = " + result2);  // 20
    }
}
▶ Experimente
💡 Dica: Use parênteses em expressões complexas para melhorar a legibilidade e evitar erros de precedência.

Promoção de Tipo

Quando valores de diferentes tipos são misturados em uma operação, o tipo menor é automaticamente promovido para o tipo maior.

JAVA 
public class TypePromotion {
    public static void main(String[] args) {
        // int + long → long
        int a = 10;
        long b = 20;
        long c = a + b;
        
        // int + double → double
        int d = 10;
        double e = 3.14;
        double f = d + e;
        
        // byte + byte → int
        byte g = 10;
        byte h = 20;
        // byte i = g + h;  // Erro! O resultado é do tipo int
        int i = g + h;      // Correto
    }
}

❓ Perguntas Frequentes

P: Qual é a diferença entre == e equals? R: == compara valores para primitivos e endereços para referências. equals compara conteúdo de objetos. Use equals para comparação de strings.

P: Qual é a diferença entre i++ e ++i? R: i++ usa o valor primeiro e depois incrementa; ++i incrementa primeiro e depois usa. Quando usado sozinho, o efeito é o mesmo. A diferença só importa em expressões.

P: Por que 0.1 + 0.2 != 0.3? R: Números de ponto flutuante têm problemas de precisão. 0.1 e 0.2 não podem ser representados exatamente em binário. Use comparação de intervalo para valores de ponto flutuante.

📖 Resumo

📝 Exercícios

  1. Prática aritmética: Insira um número de segundos e converta para o formato "X horas X minutos X segundos"
  2. Prática de comparação: Determine se um ano é bissexto (divisível por 4 mas não por 100, ou divisível por 400)
  3. Prática ternária: Insira três números e encontre o máximo usando o operador ternário

Próxima Lição

Na próxima lição, aprenderemos sobre Instruções Condicionais — tomando decisões em seus programas.

100%