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 que um computador representa todas as informações em um formato numérico: combinações de zeros e uns, também conhecido 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. Esses 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
30Você já usou tudo isso. Para este grupo, você pode adicionar ao %operador resto 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:
1Neste exemplo, dividimos 33 por 2. Isso resulta em 16, com uma “cauda” extra (uma) que não é divisível por 2. Essa “cauda” é o resultado da operação de “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 (
>) - menos que (
<) - maior ou igual a (
>=) - menor ou igual a (
<=) - diferente (
!=)
Aqui você deve prestar atenção a um ponto importante que faz com que muitos iniciantes cometam erros. O operador “igual” é escrito ==, não =.
Em Java, um único =é o operador de atribuição, que é usado quando uma variável é atribuída a 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 is be displayed
}
}Saída do console:
999Ops! Obviamente, este não é o resultado que esperávamos. É um tipo de dados totalmente diferente: esperávamos ver um booleano, 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 xe, em seguida, exibimos o valor de x.
Esta é 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:
falseAgora 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:
256Lembre-se de que a atribuição é da direita para a esquerda.
Esta expressão ( ) será executada em etapas:x = y = z
y = z, isso é,y = 256x = y, isso é,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 dos operadores anteriores, atuam em um único número, não em vários.
Esses incluem:
- Menos unário. 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
999Usamos o operador menos unário duas vezes. Como resultado, nosso número primeiro foi negativo e depois tornou-se positivo novamente!
- Incremento (
++) e decremento (--)
A ++operadora aumenta um número em um e a --operadora 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
999Essa notação pode ser familiar para você se você já ouviu falar da linguagem C ++.
Seus criadores usaram este nome interessante para transmitir a ideia de que “C ++ é uma extensão da linguagem C”
Uma versão melhorada popular do Notepad é chamada Notepad ++
Aqui está um ponto importante. Existem dois tipos de operadores de incremento e decremento: postfix e prefix.
x++ – postfix
++x – prefixo
Qual é a diferença fundamental entre colocar os sinais de mais / menos antes ou depois do número?
Veremos no seguinte exemplo:
public class Main {
public static void main(String[] args) {
int x = 999;
int y = x++;
System.out.println(y);
}
}Saída do console:
999Alguma coisa não está certa! Queríamos aumentar xem 1 e atribuir o novo valor à variável y. Em outras palavras, y deveria ser 1000. Mas, em vez disso, obtemos algo mais: 999. Parece que x não foi aumentado e que o operador de incremento não funcionou?
Mas funcionou. Para se convencer, tente exibir xno 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
1000Na verdade, é exatamente por isso que essa operação é chamada de postfix: ela é realizada 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 somente então será executadox++
E se esse 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);
}
}Nesse caso, é processado primeiro e somente depois é executado.++xy = x;
Você deve comprometer essa diferença na memória imediatamente para evitar cometer erros em um programa real onde usar postfix em vez de 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:
- Tarefa
- Operadores aritméticos
Esses incluem:
+=-=*=/=%=
Vamos considerar um exemplo:
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:
1032x += ysignifica . Os dois símbolos são usados consecutivamente por uma questão de brevidade. O combinações , , e funcionam de maneira similar.x = x + y-=*=/=%=
Operadores lógicos
Além de operadores numéricos, Java também possui operações que envolvem valores booleanos (verdadeiro e falso).
Essas operações são realizadas usando operadores lógicos
-
!– NÃO lógico. 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:
false&&– AND lógico. Ele retorna verdadeiro apenas 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
trueO resultado da primeira operação é falso, porque um dos operandos é falso, a saber . Para retornar verdadeiro, o operador requer que ambos os operandos sejam verdadeiros (como é o caso na segunda linha).100 > 200&&
||– OR lógico. Ele retorna verdadeiro quando pelo menos um dos operandos é verdadeiro.
Quando usamos este operador, nosso exemplo anterior produz um resultado diferente:
public class Main {
public static void main(String[] args) {
System.out.println(100 > 10 || 100 > 200);
}
}Saída do console:
trueA expressão 100 > 200ainda é falsa, mas para o operador OR é inteiramente suficiente que a primeira parte ( 100 > 10) seja verdadeira.
O artigo foi publicado em <a href = ” https://codegym.cc/groups/posts/8-numeric-operators-in-java-logical-operators-in-java-bitwise-operators-in-java-operator- precedence – “> blog CodeGym </a>.