Dominando Operadores Java: Tipos, Sintaxe e Exemplos Práticos

Operadores Java

Neste tutorial, você aprenderá sobre os diferentes tipos de operadores em Java, sua sintaxe e como usá-los com a ajuda de exemplos.

Operadores são símbolos que realizam operações em variáveis e valores. Por exemplo, + é um operador usado para adição, enquanto * é também um operador usado para multiplicação.

Operadores em Java podem ser classificados em 6 tipos:

1. Operadores Aritméticos
2. Operadores de Atribuição
3. Operadores Relacionais
4. Operadores Lógicos
5. Operadores Unários
6. Operadores Bitwise

---

1. Operadores Aritméticos Java

Operadores aritméticos são usados para realizar operações aritméticas em variáveis e dados. Por exemplo,

a + b;

Aqui, o operador + é usado para somar duas variáveis a e b. Da mesma forma, existem vários outros operadores aritméticos em Java.

Operador	Operação
+	Adição
-	Subtração
*	Multiplicação
/	Divisão
%	Operação Módulo (Resto da divisão)

Exemplo 1: Operadores Aritméticos

class Main {
    public static void main(String[] args) {
        // declarar variáveis
        int a = 12, b = 5;
        // operador de adição
        System.out.println("a + b = " + (a + b));
        // operador de subtração
        System.out.println("a - b = " + (a - b));
        // operador de multiplicação
        System.out.println("a * b = " + (a * b));
        // operador de divisão
        System.out.println("a / b = " + (a / b));
        // operador de módulo
        System.out.println("a % b = " + (a % b));
    }
}

Saída

a + b = 17
a - b = 7
a * b = 60
a / b = 2
a % b = 2

No exemplo acima, usamos operadores +, - e * para calcular adição, subtração e multiplicação.

Operador de Divisão /

Note a operação a / b em nosso programa. O operador / é o operador de divisão.

Se usarmos o operador de divisão com dois inteiros, o quociente resultante também será um inteiro. E, se um dos operandos for um número de ponto flutuante, o resultado também será em ponto flutuante.

Em Java, (9 / 2) é 4
(9.0 / 2) é 4.5
(9 / 2.0) é 4.5
(9.0 / 2.0) é 4.5

Operador Módulo %

O operador módulo % calcula o resto. Quando a = 7 é dividido por b = 4, o resto é 3.

Nota: O operador % é usado principalmente com inteiros.

---

2. Operadores de Atribuição Java

Operadores de atribuição são usados em Java para atribuir valores a variáveis. Por exemplo,

int age;
age = 5;

Aqui, = é o operador de atribuição. Ele atribui o valor à sua direita à variável à sua esquerda. Ou seja, 5 é atribuído à variável age.

Vamos ver mais operadores de atribuição disponíveis em Java.

Operador	Exemplo	Equivalente a
=	a = b;	a = b;
+=	a += b;	a = a + b;
-=	a -= b;	a = a - b;
*=	a *= b;	a = a * b;
/=	a /= b;	a = a / b;
%=	a %= b;	a = a % b;

Exemplo 2: Operadores de Atribuição

class Main {
    public static void main(String[] args) {
        // criar variáveis
        int a = 4;
        int var;
        // atribuir valor usando =
        var = a;
        System.out.println("var usando =: " + var);
        // atribuir valor usando +=
        var += a;
        System.out.println("var usando +=: " + var);
        // atribuir valor usando *=
        var *= a;
        System.out.println("var usando *=: " + var);
    }
}

Saída

var usando =: 4
var usando +=: 8
var usando *=: 32

---

3. Operadores Relacionais Java

Operadores relacionais são usados para verificar a relação entre dois operandos. Por exemplo,

// verifica se a é menor que b
a < b;

Aqui, o operador < é o operador relacional. Ele verifica se a é menor que b ou não.

Retorna true ou false.

Operador	Descrição	Exemplo
==	É Igual A	3 == 5 retorna false
!=	Não É Igual A	3 != 5 retorna true
>	Maior Que	3 > 5 retorna false
<	Menor Que	3 < 5 retorna true
>=	Maior Ou Igual A	3 >= 5 retorna false
<=	Menor Ou Igual A	3 <= 5 retorna true

Exemplo 3: Operadores Relacionais

class Main {
    public static void main(String[] args) {
        // criar variáveis
        int a = 7, b = 11;
        // valor de a e b
        System.out.println("a é " + a + " e b é " + b);
        // operador ==
        System.out.println(a == b); // false
        // operador !=
        System.out.println(a != b); // true
        // operador >
        System.out.println(a > b); // false
        // operador <
        System.out.println(a < b); // true
        // operador >=
        System.out.println(a >= b); // false
        // operador <=
        System.out.println(a <= b); // true
    }
}

Nota: Operadores relacionais são usados em tomada de decisão e loops.

---

4. Operadores Lógicos Java

Operadores lógicos são usados para verificar se uma expressão é true ou false. São usados em tomada de decisão.

Operador	Exemplo	Significado
&& (AND Lógico)	expressão1 && expressão2	true apenas se tanto expressão1 quanto expressão2 forem true
|| (OR Lógico)	expressão1 || expressão2	true se expressão1 ou expressão2 for true
! (NOT Lógico)	!expressão	true se expressão for false e vice-versa

Exemplo 4: Operadores Lógicos

class Main {
    public static void main(String[] args) {
        // operador &&
        System.out.println((5 > 3) && (8 > 5)); // true
        System.out.println((5 > 3) && (8 < 5)); // false
        // operador ||
        System.out.println((5 < 3) || (8 > 5)); // true
        System.out.println((5 > 3) || (8 < 5)); // true
        System.out.println((5 < 3) || (8 < 5)); // false
        // operador !
        System.out.println(!(5 == 3)); // true
        System.out.println(!(5 > 3)); // false
    }
}

Funcionamento do Programa

• (5 > 3) && (8 > 5) retorna true porque ambos (5 > 3) e (8 > 5) são true.
• (5 > 3) && (8 < 5) retorna false porque a expressão (8 < 5) é false.
• (5 < 3) || (8 > 5) retorna true porque a expressão (8 > 5) é true.
• (5 > 3) && (8 > 5) retorna true porque a expressão (5 > 3) é true.
• (5 > 3) && (8 > 5) retorna false porque ambos (5 < 3) e (8 < 5) são false.
• !(5 == 3) retorna true porque 5 == 3 é false.
• !(5 > 3) retorna false porque 5 > 3 é true.

---

5. Operadores Unários Java

Operadores unários são usados com apenas um operando. Por exemplo, ++ é um operador unário que aumenta o valor de uma variável em 1. Ou seja, ++5 retornará 6.

Diferentes tipos de operadores unários são:

Operador	Significado
+	Mais unário: não necessário usar já que números são positivos sem ele
-	Menos unário: inverte o sinal de uma expressão
++	Operador de incremento: incrementa valor em 1
--	Operador de decremento: decrementa valor em 1
!	Operador de complemento lógico: inverte o valor de um booleano

Operadores de Incremento e Decremento

Java também fornece operadores de incremento e decremento: ++ e -- respectivamente. ++ aumenta o valor do operando em 1, enquanto -- diminui em 1. Por exemplo,

int num = 5;
// aumentar num em 1
++num;

Aqui, o valor de num aumenta para 6 a partir de seu valor inicial 5.

---

Exemplo 5: Operadores de Incremento e Decremento

class Main {
    public static void main(String[] args) {
        // declarar variáveis
        int a = 12, b = 12;
        int result1, result2;
        // valor original
        System.out.println("Valor de a: " + a);
        // operador de incremento
        result1 = ++a;
        System.out.println("Após incremento: " + result1);
        System.out.println("Valor de b: " + b);
        // operador de decremento
        result2 = --b;
        System.out.println("Após decremento: " + result2);
    }
}

Saída

Valor de a: 12
Após incremento: 13
Valor de b: 12
Após decremento: 11

No programa acima, usamos os operadores ++ e -- como prefixos (++a, --b). Também podemos usar esses operadores como pós-fixos (a++, b++).

Há uma leve diferença quando esses operadores são usados como prefixo versus pós-fixo.

Para saber mais sobre esses operadores, visite operadores de incremento e decremento.

---

6. Operadores Bitwise Java

Operadores bitwise em Java são usados para realizar operações em bits individuais. Por exemplo,

Operação de complemento bitwise de 35
35 = 00100011 (Em Binário)
~ 00100011
________
11011100 = 220 (Em decimal)

Aqui, ~ é um operador bitwise. Ele inverte o valor de cada bit (0 para 1 e 1 para 0).

Os vários operadores bitwise presentes em Java são:

Operador	Descrição
~	Complemento Bitwise
<<	Deslocamento à Esquerda
>>	Deslocamento à Direita
>>>	Deslocamento à Direita Sem Sinal
&	AND Bitwise
^	OR Exclusivo Bitwise

Esses operadores não são geralmente usados em Java. Para saber mais, visite Operadores Bitwise e Bit Shift em Java.

---

Outros operadores

Além desses operadores, existem outros operadores adicionais em Java.

Operador instanceof Java

O operador instanceof verifica se um objeto é uma instância de uma classe particular. Por exemplo,

class Main {
    public static void main(String[] args) {
        String str = "Programiz";
        boolean result;
        // verifica se str é uma instância da classe String
        result = str instanceof String;
        System.out.println("str é um objeto de String? " + result);
    }
}

Saída

str é um objeto de String? true

Aqui, str é uma instância da classe String. Portanto, o operador instanceof retorna true. Para saber mais, visite Java instanceof.

---

Operador Ternário Java

O operador ternário (operador condicional) é abreviação para a instrução if-then-else. Por exemplo,

variavel = Expressao ? expressao1 : expressao2

Veja como funciona.

• Se a Expressao for true, expressao1 é atribuída à variavel.
• Se a Expressao for false, expressao2 é atribuída à variavel.

Vamos ver um exemplo de operador ternário.

class Java {
    public static void main(String[] args) {
        int februaryDays = 29;
        String result;
        // operador ternário
        result = (februaryDays == 28) ? "Não é ano bissexto" : "Ano bissexto";
        System.out.println(result);
    }
}

Saída

Ano bissexto

No exemplo acima, usamos o operador ternário para verificar se o ano é bissexto ou não. Para saber mais, visite operador ternário Java.

---

Agora que você conhece os operadores Java, é hora de saber a ordem em que os operadores são avaliados. Para saber mais, visite Precedência de Operadores Java.