Oi! Hoje vamos considerar um tópico muito importante, ou seja, operadores numéricos em Java .
Na programação, os números estão por toda parte. Se você se aprofundar e se lembrar do ensino médio, deve se lembrar de que um computador representa todas as informações em um formato numérico: combinações de zeros e uns, também conhecidas como código binário.
Existem muitos operadores numéricos na programação, então usaremos exemplos para explorar os mais importantes deles :) Vamos começar com o mais simples: operadores aritméticos . Estes são os conhecidos operadores de adição (


+
), subtração ( -
), multiplicação ( *
) e divisão ( /
).
public class Main {
public static void main(String[] args) {
int x = 999;
int y = 33;
System.out.println(x+y);
System.out.println(x-y);
System.out.println(x*y);
System.out.println(x/y);
}
}
Saída do console: 1032 966 32967 30 Você já usou tudo isso. A este grupo, você pode adicionar o %
operador restante ou módulo ( ).
public class Main {
public static void main(String[] args) {
int x = 33;
int y = 33%2;
System.out.println(y);
}
}
Saída do console: 1 Neste exemplo, dividimos 33 por 2. Isso resulta em 16, com uma "cauda" extra (um) que não é divisível por 2. Essa "cauda" é o resultado da operação "resto da divisão". Java também implementa operadores de comparação/relacionais (assim como na matemática). Eles provavelmente são familiares para você da escola também:
- igual a (
==
) - maior que (
>
) - menor que (
<
) - maior ou igual a (
>=
) - menor ou igual a (
<=
) - diferente (
!=
)
==
, não =
. Em Java, um único =
é o operador de atribuição , que é usado quando uma variável recebe um número, string ou o valor de outra variável.

public class Main {
public static void main(String[] args) {
int x = 33;
int y = 999;
System.out.println(x=y);// We expect false to be displayed
}
}
Saída do console: 999 Ops! Obviamente, este não é o resultado que esperávamos. É um tipo de dados totalmente diferente: esperávamos ver um boolean , mas obtivemos um número. Tudo porque usamos um operador de atribuição entre parênteses em vez de uma comparação . x=y
O valor de y
(999) foi atribuído à variável x
, e então exibimos o valor de x
. Aqui está a maneira certa de fazer isso:
public class Main {
public static void main(String[] args) {
int x = 33;
int y = 999;
System.out.println(x==y);
}
}
Saída do console: false Agora comparamos os dois números corretamente! :) Aqui está outro recurso do operador de atribuição ( =
): ele pode ser "encadeado":
public class Main {
public static void main(String[] args) {
int x = 999;
int y = 33;
int z = 256;
x = y = z;
System.out.println(x);
}
}
Saída do console: 256 Lembre-se de que a atribuição é da direita para a esquerda . Esta expressão ( x = y = z
) será executada em etapas:
y = z
, aquilo é,y = 256
x = y
, aquilo é,x = 256
Operadores unários.
Eles são chamados de " unários " da palavra " uno ", que significa " um ". Eles receberam esse nome porque, ao contrário das operadoras anteriores, atuam em um único número, não em vários. Esses incluem:-
Unário menos. Ele inverte o sinal do número.
public class Main {
public static void main(String[] args) {
int x = 999;
// Change the sign for the first time
x = -x;
System.out.println(x);
// Change the sign for the second time
x= -x;
System.out.println(x);
}
}
Saída do console: -999 999 Usamos o operador menos unário duas vezes. Como resultado, nosso número foi primeiro negativo e depois voltou a ser positivo!
- Incremento (++) e decremento (--)
++
operador aumenta um número em um e o --
operador reduz um número na mesma quantidade.
public class Main {
public static void main(String[] args) {
int x = 999;
x++;
System.out.println(x);
x--;
System.out.println(x);
}
}
Saída do console: 1000 999 Esta notação pode ser familiar para você se já ouviu falar da linguagem C++. Seus criadores usaram esse nome interessante para transmitir a ideia de que "C++ é uma extensão da linguagem C". Existem dois tipos de operadores de incremento e decremento: postfix e prefix . x++
- postfix ++x
- prefix Qual é a diferença fundamental entre colocar os mais/menos antes ou depois do número? Veremos no exemplo a seguir:
public class Main {
public static void main(String[] args) {
int x = 999;
int y = x++;
System.out.println(y);
}
}
Saída do console: 999 Algo não está certo! Queríamos aumentar x
em 1 e atribuir o novo valor à variável y. Em outras palavras, y deveria ser 1000. Mas, em vez disso, obtemos outra coisa: 999. Parece que x não foi aumentado e que o operador de incremento não funcionou? Mas funcionou. Para se convencer, tente exibir x
no final :)
public class Main {
public static void main(String[] args) {
int x = 999;
int y = x++;
System.out.println(y);
System.out.println(x);
}
}
Saída do console: 999 1000 Na verdade, é exatamente por isso que essa operação é chamada de postfix: ela é executada após a expressão principal. Isso significa, no nosso caso: int y = x++;
y = x
é executado primeiro (e a variável y
será inicializada com o valor de x
), e só então será x++
executado E se este não for o comportamento que desejamos? Então precisamos usar a notação de prefixo :
public class Main {
public static void main(String[] args) {
int x = 999;
int y = ++x;
System.out.println(y);
}
}
Neste caso, ++x
é processado primeiro e só depois é y = x
; executado. Você deve gravar essa diferença na memória imediatamente para evitar erros em um programa real, onde usar o postfix em vez do prefixo pode virar tudo de cabeça para baixo :)
Operadores compostos
Além disso, em Java existem os chamados operadores compostos. Eles combinam dois operadores:- Atribuição
- Operadores aritméticos
+=
-=
*=
/=
%=
public class Main {
public static void main(String[] args) {
int x = 999;
int y = 33;
x += y;
System.out.println(x);
}
}
Saída do console: 1032 x += y
significa x = x + y
. Os dois símbolos são usados consecutivamente por uma questão de brevidade. As combinações -=
, *=
, /=
e %=
funcionam de maneira semelhante.
Operadores lógicos
Além dos operadores numéricos, Java também possui operações que envolvem valores booleanos ( true e false ). Essas operações são realizadas usando operadores lógicos!
- lógico NÃO . Ele inverte o valor de um booleano
public class Main {
public static void main(String[] args) {
boolean x = true;
System.out.println(!x);
}
}
Saída do console: falso
&&
- E lógico . Retorna verdadeiro somente se ambos os operandos forem verdadeiros.
public class Main {
public static void main(String[] args) {
System.out.println(100 > 10 && 100 > 200);
System.out.println(100 > 50 && 100 >= 100);
}
}
Saída do console: false true O resultado da primeira operação é false, porque um dos operandos é false, ou seja 100 > 200
, . Para retornar verdadeiro, o &&
operador exige que ambos os operandos sejam verdadeiros (como é o caso da segunda linha).
||
- OU lógico . Retorna verdadeiro quando pelo menos um dos operandos for verdadeiro.
public class Main {
public static void main(String[] args) {
System.out.println(100 > 10 || 100 > 200);
}
}
Saída do console: true A expressão 100 > 200
ainda é false, mas para o operador OR é totalmente suficiente que a primeira parte ( 100 > 10
) seja true.
GO TO FULL VERSION