Aula 29 - Introdução à Operadores

Introdução à Operadores

Há três tipos de operadores: unários, binários e ternários. Nesta aula, vamos explorar cada um deles e suas aplicações em Java.

Operadores Unários

Operadores unários são aqueles que atuam sobre um único operando (valor ou variável). Exemplos comuns incluem o incremento (++) e o decremento (--) que já vimos em aulas anteriores.

public class OperadoresUnarios {
    public static void main(String[] args) {
      // Incremento e decremento      
      // diferenças] entre ++variavel e variavel++
      // variavel++ incrementa depois na próxima chamada
      // ++variavel incrementa na hora que é chamada
      int num = 5;
      System.out.println("num: " + num);
      System.out.println("num++ (ainda não alterou o valor): " + num++);
      System.out.println("num++ (chamo a variável num novamente, agora atualizada): " + num);
      
      num = 5;
      System.out.println("num: " + num);
      System.out.println("++num: " + ++num);
      
      // diferenças] entre --variavel e variavel--
      // variavel-- decrementa depois na próxima chamada
      // --variavel decrementa na hora que é chamada
      int num2 = 5;
      System.out.println("num2: " + num2);
      System.out.println("num2-- (ainda não alterou o valor): " + num2--);
      System.out.println("num2-- (chamo a variável num2 novamente, agora atualizada): " + num2);
      
      num2 = 5;
      System.out.println("num2: " + num2);
      System.out.println("--num2: " + --num2);
  }
}

Operadores Binários

Operadores binários atuam sobre dois operandos. Essa categoria inclui os operadores aritméticos, relacionais e lógicos que já vimos, bem como outros.

public class OperadoresBinarios {
    public static void main(String[] args) {
        // Operadores aritméticos
        int a = 10;
        int b = 3;
        
        System.out.println("Operadores Aritméticos:");
        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)
        System.out.println("a % b = " + (a % b));  // 1 (resto da divisão)
        
        // Operadores relacionais
        System.out.println("\nOperadores Relacionais:");
        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 <= b: " + (a <= b)); // false
        System.out.println("a == b: " + (a == b)); // false
        System.out.println("a != b: " + (a != b)); // true
        
        // Operadores lógicos
        boolean x = true;
        boolean y = false;
        
        System.out.println("\nOperadores Lógicos:");
        System.out.println("x && y: " + (x && y)); // false (AND lógico)
        System.out.println("x || y: " + (x || y)); // true (OR lógico)
    }
}

Operador Ternário

O operador ternário é o único operador em Java que atua sobre três operandos. Ele funciona como uma versão compacta do if-else para atribuição de valores.

public class OperadorTernario {
    public static void main(String[] args) {
        // Operador ternário: condição ? valor_se_verdadeiro : valor_se_falso
        int idade = 17;
        String status = (idade >= 18) ? "Maior de idade" : "Menor de idade";
        
        System.out.println("Idade: " + idade);
        System.out.println("Status: " + status);
        
        // Comparando com if-else tradicional
        String statusTradicional;
        if (idade >= 18) {
            statusTradicional = "Maior de idade";
        } else {
            statusTradicional = "Menor de idade";
        }
        
        System.out.println("Status (if-else tradicional): " + statusTradicional);
        
        // Exemplo com operações
        int a = 10;
        int b = 5;
        int maiorValor = (a > b) ? a : b;
        
        System.out.println("\na = " + a);
        System.out.println("b = " + b);
        System.out.println("Maior valor: " + maiorValor);
        
        // Você pode encadear operadores ternários, mas isso pode dificultar a leitura
        int c = 15;
        int valorMedio = (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c);
        System.out.println("c = " + c);
        System.out.println("Valor médio: " + valorMedio);
        
        // Usando ternário para determinar par ou ímpar
        int numero = 7;
        String parOuImpar = (numero % 2 == 0) ? "Par" : "Ímpar";
        System.out.println("\nNúmero " + numero + " é: " + parOuImpar);
    }
}

Operadores de Atribuição

Os operadores de atribuição são usados para atribuir valores a variáveis. Além do operador de atribuição simples (=), existem operadores compostos que combinam uma operação e uma atribuição.

public class OperadoresAtribuicao {
    public static void main(String[] args) {
        // Atribuição simples
        int a = 10;
        System.out.println("Valor inicial de a: " + a);
        
        // Atribuição composta (+=)
        a += 5;  // Equivalente a: a = a + 5;
        System.out.println("Após a += 5: " + a);
        
        // Atribuição composta (-=)
        a -= 3;  // Equivalente a: a = a - 3;
        System.out.println("Após a -= 3: " + a);
        
        // Atribuição composta (*=)
        a *= 2;  // Equivalente a: a = a * 2;
        System.out.println("Após a *= 2: " + a);
        
        // Atribuição composta (/=)
        a /= 4;  // Equivalente a: a = a / 4;
        System.out.println("Após a /= 4: " + a);
        
        // Atribuição composta (%=)
        a %= 3;  // Equivalente a: a = a % 3; 
    }
}

Precedência de Operadores

A precedência dos operadores determina a ordem em que as operações são executadas em uma expressão. Quando múltiplos operadores aparecem em uma expressão, aqueles com maior precedência são avaliados primeiro.

Categoria	Operadores	Precedência
Unários	++, --, +, -, !, ~	Alta
Multiplicativo	*, /, %	↓
Aditivo	+, -	↓
Deslocamento	<<, >>, >>>	↓
Relacional	<, >, <=, >=, instanceof	↓
Igualdade	==, !=	↓
AND bit a bit	&	↓
XOR bit a bit	^	↓
OR bit a bit	|	↓
AND lógico	&&	↓
OR lógico	||	↓
Ternário	? :	↓
Atribuição	=, +=, -=, *=, /=, %=, etc.	Baixa

public class PrecedenciaOperadores {
    public static void main(String[] args) {
        // Exemplo de precedência de operadores
        int resultado1 = 5 + 3 * 2;
        System.out.println("5 + 3 * 2 = " + resultado1);  // 11 (multiplicação tem precedência sobre adição)
        
        // Usando parênteses para alterar a precedência
        int resultado2 = (5 + 3) * 2;
        System.out.println("(5 + 3) * 2 = " + resultado2);  // 16 (parênteses têm precedência sobre qualquer operador)
        
    }
}

int numero = 7;
String resultado = ___________________;