Operadores Java
Operadores Java
Neste tutorial, você aprenderá sobre 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.
Os operadores em Java podem ser classificados em 5 tipos:
- Operadores aritméticos
- Operadores de atribuição
- Operadores Relacionais
- Operadores lógicos
- Operadores Unários
- Operadores bit a bit
1. Operadores aritméticos Java
Os 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 adicionar 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 do módulo (resto após divisão) |
Exemplo 1:operadores aritméticos
class Main {
public static void main(String[] args) {
// declare variables
int a = 12, b = 5;
// addition operator
System.out.println("a + b = " + (a + b));
// subtraction operator
System.out.println("a - b = " + (a - b));
// multiplication operator
System.out.println("a * b = " + (a * b));
// division operator
System.out.println("a / b = " + (a / b));
// modulo operator
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
+ , - e * operadores para calcular operações de adição, subtração e multiplicação. / Operador de Divisão
Observe 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, obteremos o resultado também em ponto flutuante.
In Java,
(9 / 2) is 4
(9.0 / 2) is 4.5
(9 / 2.0) is 4.5
(9.0 / 2.0) is 4.5 Operador de % Módulo
O operador de módulo
% calcula o restante. Quando a = 7 é dividido por b = 4 , o restante é 3 . Observação :O
% operador é usado principalmente com números inteiros. 2. Operadores de atribuição Java
Os 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 idade . Vamos ver mais alguns 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) {
// create variables
int a = 4;
int var;
// assign value using =
var = a;
System.out.println("var using =: " + var);
// assign value using =+
var += a;
System.out.println("var using +=: " + var);
// assign value using =*
var *= a;
System.out.println("var using *=: " + var);
}
} Saída
var using =: 4 var using +=: 8 var using *=: 32
3. Operadores Relacionais Java
Operadores relacionais são usados para verificar a relação entre dois operandos. Por exemplo,
// check if a is less than b
a < b; Aqui,
< operador é o operador relacional. Ele verifica se a é menor que b ou não. Ele retorna
true ou false . | Operador | Descrição | Exemplo |
|---|---|---|
== | É igual a | 3 == 5 retorna falso |
!= | Diferente de | 3 != 5 retorna verdadeiro |
> | Maior que | 3 > 5 retorna falso |
< | Menor que | 3 < 5 retorna verdadeiro |
>= | Maior ou igual a | 3 >= 5 retorna falso |
<= | Menor ou igual a | 3 <= 5 retorna verdadeiro |
Exemplo 3:Operadores Relacionais
class Main {
public static void main(String[] args) {
// create variables
int a = 7, b = 11;
// value of a and b
System.out.println("a is " + a + " and b is " + b);
// == operator
System.out.println(a == b); // false
// != operator
System.out.println(a != b); // true
// > operator
System.out.println(a > b); // false
// < operator
System.out.println(a < b); // true
// >= operator
System.out.println(a >= b); // false
// <= operator
System.out.println(a <= b); // true
}
} Observação :Operadores relacionais são usados na 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 . Eles são usados na tomada de decisões. | Operador | Exemplo | Significado |
|---|---|---|
&& (E lógico) | expressão1 && expressão2 | true somente se ambos expression1 e expressão2 são true |
|| (OU lógico) | expressão1 || expressão2 | true se expression1 ou expressão2 é true |
! (NÃO Lógico) | ! expressão | true se expressão é false e vice-versa |
Exemplo 4:operadores lógicos
class Main {
public static void main(String[] args) {
// && operator
System.out.println((5 > 3) && (8 > 5)); // true
System.out.println((5 > 3) && (8 < 5)); // false
// || operator
System.out.println((5 < 3) || (8 > 5)); // true
System.out.println((5 > 3) || (8 < 5)); // true
System.out.println((5 < 3) || (8 < 5)); // false
// ! operator
System.out.println(!(5 == 3)); // true
System.out.println(!(5 > 3)); // false
}
} Funcionamento do Programa
(5 > 3) && (8 > 5)retornatrueporque ambos(5 > 3)e(8 > 5)sãotrue.(5 > 3) && (8 < 5)retornafalseporque a expressão(8 < 5)éfalse.(5 < 3) || (8 > 5)retornatrueporque a expressão(8 > 5)étrue.(5 > 3) && (8 > 5)retornatrueporque a expressão(5 > 3)étrue.(5 > 3) && (8 > 5)retornafalseporque ambos(5 < 3)e(8 < 5)sãofalse.!(5 == 3)retorna true porque5 == 3éfalse.!(5 > 3)retorna falso porque5 > 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, pois os números são positivos sem usá-lo |
- | Unário menos :inverte o sinal de uma expressão |
++ | Operador de incremento :incrementa o valor em 1 |
-- | Operador de decremento :diminui o 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 -- diminua em 1 . Por exemplo,
int num = 5;
// increase num by 1
++num; Aqui, o valor de num aumenta para 6 de seu valor inicial de 5 .
Exemplo 5:operadores de incremento e decremento
class Main {
public static void main(String[] args) {
// declare variables
int a = 12, b = 12;
int result1, result2;
// original value
System.out.println("Value of a: " + a);
// increment operator
result1 = ++a;
System.out.println("After increment: " + result1);
System.out.println("Value of b: " + b);
// decrement operator
result2 = --b;
System.out.println("After decrement: " + result2);
}
} Saída
Value of a: 12 After increment: 13 Value of b: 12 After decrement: 11
No programa acima, usamos o operador ++ e -- como prefixos (++a, --b) . Também podemos usar esses operadores como postfix (a++, b++) .
Há uma pequena diferença quando esses operadores são usados como prefixo versus quando são usados como pós-fixo.
Para saber mais sobre esses operadores, visite operadores de incremento e decremento.
6. Operadores Java Bitwise
Operadores bit a bit em Java são usados para realizar operações em bits individuais. Por exemplo,
Bitwise complement Operation of 35
35 = 00100011 (In Binary)
~ 00100011
________
11011100 = 220 (In decimal) Aqui,
~ é um operador bit a bit. Inverte o valor de cada bit (0 para 1 e 1 para 0 ). Os vários operadores bit a bit presentes em Java são:
| Operador | Descrição |
|---|---|
~ | Complemento bit a bit |
<< | Deslocamento à esquerda |
>> | Deslocamento à direita |
>>> | Deslocamento à direita não assinado |
& | Bit a bit E |
^ | OU exclusivo bit a bit |
Esses operadores geralmente não são usados em Java. Para saber mais, visite Operadores Java Bitwise e Bit Shift.
Outros operadores
Além desses operadores, existem outros operadores adicionais em Java.
Instância Java do Operador
O
instanceof O operador verifica se um objeto é uma instância de uma determinada classe. Por exemplo,
class Main {
public static void main(String[] args) {
String str = "Programiz";
boolean result;
// checks if str is an instance of
// the String class
result = str instanceof String;
System.out.println("Is str an object of String? " + result);
}
} Saída
Is str an object of String? true
Aqui, str é uma instância do
String classe. Portanto, o instanceof operador retorna true . Para saber mais, visite Java instanceof. Operador Ternário Java
O operador ternário (operador condicional) é uma abreviação para o
if-then-else declaração. Por exemplo, variable = Expression ? expression1 : expression2
Aqui está como funciona.
- Se o
Expressionétrue,expression1é atribuído à variável . - Se o
Expressionéfalse,expression2é atribuído à variável .
Vejamos um exemplo de operador ternário.
class Java {
public static void main(String[] args) {
int februaryDays = 29;
String result;
// ternary operator
result = (februaryDays == 28) ? "Not a leap year" : "Leap year";
System.out.println(result);
}
} Saída
Leap year
No exemplo acima, usamos o operador ternário para verificar se o ano é bissexto ou não. Para saber mais, visite o operador ternário Java.
Agora que você conhece os operadores Java, é hora de saber sobre a ordem em que os operadores são avaliados. Para saber mais, visite Precedência do Operador Java.
Java