Operadores básicos em Java | Explicado

Java tem muitos operadores que ajudam a executar várias operações em variáveis/valores. Esses operadores são divididos em vários tipos e os operadores que executam operações iguais são colocados na mesma categoria.

Por exemplo, os operadores Java que executam adição, subtração, divisão, multiplicação, etc. são colocados na categoria aritmética de operadores. Da mesma forma, os operadores que fornecem a relação entre variáveis ​​são colocados dentro da categoria do operador relacional.

Este artigo lista o uso e a aplicabilidade dos operadores básicos em Java. Então vamos começar.

Quais são os operadores básicos em Java

Esta seção descreve a funcionalidade dos operadores básicos em Java.

Operadores de atribuição

Esses operadores ajudam a atribuir valor a uma variável em Java. Esta ação de atribuição pode ser executada usando um dos seguintes operadores:

"=": funciona em dois operandos e atribui o valor colocado no lado direito da variável escrita no lado esquerdo.

"+=": adiciona operando de ambos os lados e depois atribui o valor à variável escrita no lado esquerdo

"-=": subtrai o operando colocado à direita da esquerda e depois atribui o valor à variável colocada no lado esquerdo

"*=": multiplica ambos os operando e depois atribui a resposta à variável no lado esquerdo

"/=": relata o restante dividindo os operandos ou dividindo o operando esquerdo por um valor específico.

"%=": recebe o restante usando esse % primeiro e depois a resposta é atribuída à variável no lado esquerdo.

As seguintes sintaxes podem ser seguidas:

operand1 = operandd2; // usando =
operand1 += operand2 // usando += =
operand1- = operand2 // usando -=
operand1 *= operand2 // usando *= =
operand1 /= operand2 // usando /= =
operand1 %= operand2 // usando %=

Operadores aritméticos

Esta categoria lida com as operações aritméticas e os seguintes operadores residem nesta categoria.

"+": usado para adicionar duas variáveis/valores

“-“: fornece a diferença entre duas variáveis/valor

"*": multiplica duas variáveis/valores

"/": usado para dividir uma variável sobre outra e o quociente é mostrado na saída.

"%": relata o restante () de duas variáveis/valores

A sintaxe desses operadores é fornecida abaixo, o operand1 e operand2 se referem às variáveis/valores. Observa -se que dois operandos são necessários para realizar operações aritméticas.

operand1+operand2; //Adição
operand1-operand2; //subtração
operand1*operand2; //multiplicação
operand1/operand2; //divisão
operand1%operand2; //restante

Operadores unários

Este tipo executa várias operações em uma variável/valor. Os operadores incluídos nesta categoria estão descritos abaixo:

"+": atribui sinal positivo a um operando (geralmente o sinal positivo não é exibido, pois é opcional)

“-“: muda o sinal de um operando

“++”: incrementos o valor de um operando em 1. O operador de incremento pode ser aplicado como pós -fixo e prefixo

“-“: O valor de uma variável/valor é diminuído por 1. Como o incremento, ele também pode ser usado como prefixo ou postfix

““!”: O valor booleano (true/false) é invertido usando este operador

Você pode se referir à sintaxe desses operadores fornecidos abaixo:

+operando; // UNARY PLUS
-operando; // unário menos
++operando; // Incremento prefixo
operand ++; // incremento pós -fix
operando--; // decremento pós -fixo
--operando; // decremento prefixo
!operando; // complemento lógico

Operadores lógicos

Esses operadores ajudam a executar operações lógicas como e, ou e não. Estes são descritos abaixo:

E(&&): Isso opera em duas variáveis/valores, retorna true se ambas as variáveis ​​forem verdadeiras e falsas em outros casos.

Ou (||): Este operador cria lógica de modo que, se ambos os valores forem falsos, o resultado seria falso, caso contrário, verdadeiro.

NÃO (!): Isso também se refere à categoria unária e retorna resultados falsos/verdadeiros

Você pode se referir às seguintes sintaxes para usar operadores lógicos:

operand1 && operand2 // lógico e
operand1 || operand2 // lógico ou
!operando // lógico não

Operadores bitwise

A classe deste operador lida com os valores binários e, portanto, todas as operações são executadas pouco a pouco. e os seguintes operadores são praticados:

"&": Isso é conhecido como binário e que funciona da mesma forma que lógico, mas em valores binários.

"|": Isso também funciona com o mesmo padrão que lógico ou, mas executa a operação bit by pouco.

"^": Isso é conhecido como xor, ele retorna verdadeiro se ambos os valores forem diferentes e retornarem falsos se ambos os valores forem iguais.

"~": Este operador muda o bit de 0 para 1 e 1 para 0

““<<“: Este operador de mudança de esquerda muda o número de bits para a esquerda. O número de bits é decidido pelo usuário e pode ser qualquer número.

">>": O operador de mudança direto remove o número de bits do lado direito.

">>>": Isso é conhecido como mudança direita sem invertida e muda o número de bits por "0"

As seguintes sintaxes referem -se aos operadores bitwise:

operand1 | operand2; // bitwise ou
Operand1 & Operand2; // bitwise e
operand1 ^ operand2; // Bitwise xor
~ operando; // complementar bitwise
operando<operando >> número; // MUDANÇA DA CERTA
operando >>> número; // Mudança direita sem assinatura bitwise

Operadores relacionais

Esta categoria refere -se a relacionar mais de uma variável usando símbolos específicos. Esses operadores ajudam a tomar decisões na programação Java.

"==": Este operador é praticado verificando a igualdade de dois operandos

““!= ”: costumava verificar se a desigualdade dos operandos

““<“: Pratique a verificação menos do que a relação entre dois operandos

">": É usado para verificar se o operando esquerdo é maior ou não

"> =": Para verificar se o operando esquerdo é "maior ou igual" à direita ou não

““<=”: é praticado verificando se a variável esquerda é menor ou igual à direita

Os operadores relacionais podem ser praticados usando as sintaxes fornecidas abaixo:

operand1 == operand2; //igual a
operand1!= operand2; // não é igual a
operand1> operand2; //Maior que
operand1operand1> = operand2; //Melhor que ou igual a
operand1<=operand2; //less than or equal to

Como usar operadores básicos em java

Esta seção fornece o uso de operadores básicos em Java. Cada exemplo demonstra o código Java que usa operadores de uma categoria específica.

Exemplo 1: Usando os operadores de atribuição

O código Java a seguir pratica vários operadores de atribuição em variáveis.

pacote newpack;
Public class Charnementps
public static void main (string [] args)
// usando "=" para atribuir valores
int a = 3, b = 4, c = 5, d = 6, e = 7;
// usando "+=" em um
a+= 3;
Sistema.fora.println ("novo valor de A seria:" +a);
// usando "-=" em b
b- = 3;
Sistema.fora.println ("novo valor de B seria:" +b);
// usando "*=" em c
c*= 2;
Sistema.fora.println ("novo valor de C seria:" +c);
// usando "/=" em D
d/= 2;
Sistema.fora.println ("novo valor de d seria:" +d);
// usando "%=" em e
e%= 2;
Sistema.fora.println ("novo valor de e seria:" +e);

O código acima mencionado é descrito aqui:

• Em primeiro lugar, os valores são atribuídos a variáveis ​​usando =
• A declaração "a+= 3" adiciona 3 ao valor atual de um
• subtraindo 3 de B usando “-=”
• multiplica o valor de C por 2 usando “*=”
• divide o valor de D por 2 usando “/=”
• O valor de E é dividido por 2 e depois o restante é armazenado como um novo valor de e.

A saída do código é fornecida abaixo:

Exemplo 2: Usando operadores aritméticos

O código Java a seguir executa operações aritméticas em dois números A = 5 e B = 11.

pacote newpack;
classe pública arithop
public static void main (string [] args)
// Inicializando variáveis
int a = 5, b = 11;
// usando + em A e B
Sistema.fora.println ("a+b ="+(a+b));
// usando - em A e B
Sistema.fora.println ("a-b =" + (a-b));
// usando * em A e B
Sistema.fora.println ("a-b =" + (a*b));
// usando /em A e B
Sistema.fora.println ("a/b =" + (b/a));
// usando % em A e B
Sistema.fora.println ("a%b =" + (a%b));

No código acima mencionado, as variáveis ​​são inicializadas primeiro e, em seguida, cada linha representa a aplicação de um operador de atribuição diferente.

A saída é fornecida abaixo:

Exemplo 3: Usando operadores relacionais

O código Java a seguir pratica os operadores relacionais em duas variáveis ​​x = 3 e y = 5.

pacote newpack;
classe pública Relop
public static void main (string [] args)
// Inicializando variáveis
int x = 3, y = 5;
//usando < operator
Sistema.fora.println ("é x menor que y? " + (X operador
Sistema.fora.println ("é x maior que y? " + (x> y));
// Usando == Operador
Sistema.fora.println ("é x igual a y? " + (x == y));

O código acima escrito implementa três operadores relacionais em x e y. Além disso, o código é descrito como:

• inicializa duas variáveis ​​x e y
• relata o resultado de x
• Imprime resultados verdadeiros ou falsos para a condição x> y
• verifica e imprime a igualdade de x e y

A saída do código é fornecida abaixo:

Exemplo 4: Usando operadores lógicos

O código Java a seguir pratica os operadores lógicos na declaração condicional if-else.

pacote newpack;
classe pública Logop
public static void main (string [] args)
int a = 4, b = 5, c = 5;
if (a == b || (b == c && c!= a))

Sistema.fora.println ("A condição é verdadeira");

outro

Sistema.fora.println ("A condição é falsa");

O código acima é descrito como.

• Três variáveis ​​são inicializadas
• Na condição IF, usamos o operador e (&&) entre B == C e C!= a. Além disso, esta afirmação é unida a A == B usando ou (||) Operador.
• A condição acima mencionada é verdadeira, portanto, o bloqueio se a declaração if-else seria executada.

A saída do código é mostrada na imagem abaixo:

Exemplo 5: Usando operadores unários

Os operadores unários são praticados no seguinte código Java.

pacote newpack;
classe pública unop
public static void main (string [] args)
// Inicializando variáveis
int a = 4, b = 6;
// usando unário menos em um
Sistema.fora.println ("valor atualizado de A é:" + (-a));
// usando incremento de prefixo em B
Sistema.fora.println ("O valor atualizado de B é:"+(++ b));

A descrição do código é:

• Duas variáveis ​​A e B são inicializadas
• imprime a resposta depois de aplicar unário menos em um
• mostra o resultado após aplicar o operador de incremento de prefixo em B

A saída do código é fornecida aqui:

Exemplo 6: Usando operadores bitwise

O código Java a seguir implementa vários operadores bit netwise em variáveis/valores.

pacote newpack;
classe pública bitop
public static void main (string [] args)
int a = 3, b = 5;
// Usando o operador de mudança de esquerda bit netise em um
Sistema.fora.println ("A resposta é:" + (a3));

O código é descrito como:

• as variáveis ​​A e B são inicializadas
• usou o operador de deslocamento esquerdo em A e a resposta é impressa. O binário do número 3 seria deslocado por 2bits.
• Imprime a resposta depois de aplicar o operador de turno certo em B. Os 3bits do número B seriam removidos do lado direito do binário do número 3.

A saída do código é:

Conclusão

Os operadores básicos em Java são os operadores que são usados ​​com frequência em programas Java. O Java suporta uma longa lista de operadores que ajudam a executar várias operações em variáveis/valores. Os operadores que têm aplicabilidade iguais são colocados na mesma categoria. Por exemplo, os operadores que definem os relacionamentos podem ser encontrados na categoria relacional de operadores. Este artigo lista os operadores básicos em Java e fornece seu aplicativo usando o código Java. Você teria aprendido a visão geral e a aplicabilidade preliminar de todos os operadores básicos em Java.