Explicação detalhada dos operadores e uso em Java

No conteúdo anterior, aprendi a definir e inicializar variáveis. O objetivo de definir variáveis é manipular dados. O idioma Java nos fornece símbolos de código usados especificamente para operar esses dados, coletivamente chamados de "operadores".

De acordo com o uso de operadores, podemos dividi -los nas seguintes categorias:

Operadores aritméticos

Operador de atribuição

Operadores de auto-aumento e auto-decisão

Operadores lógicos

Operadores relacionais

operador de bits

Não se preocupe, eles são apenas símbolos que nos ajudam a processar os dados de operação. O seguinte usa exemplos de código para ilustrar o uso desses operadores um por um.

1. Operadores aritméticos

Os operadores aritméticos são operações aritméticas para adicionar, subtrair, multiplicar, dividir e levar o restante de variáveis numéricas:

Adicione: +
reduzir:-
pegar:*
remover:/
Obter equilíbrio: %

 public class OperatorsDemo {public static void main (string [] args) {int num1 = 100; int num2 = 20; // add System.out.println ("num1 + num2:" + (num1 + num2)); // subtract System.out.println ("num1 - num2:" + (num1 - num2)); // multiply System.out.println ("num1 * num2:" + (num1 * num2)); // desconto system.out.println ("num1 / num2:" + (num1 / num2)); // obtenha o restante System.out.println ("num1 % num2:" + (num1 % num2)); }}

Resultado da saída:

 Num1 + num2: 120num1 - num2: 80num1 * num2: 2000num1 / num2: 5num1 % num2: 0

2. Operador de atribuição

Como a maioria das linguagens de programação, o Java usa o operador '=' para executar operações de atribuição. Esta operação atribui o resultado do cálculo à direita (chamado de RValue) à variável à esquerda. Os operadores de atribuição em Java incluem:

= (num2 = num1)
+= (num2 += num1 equivalente num2 = num2 +num1)
-= (num2 -= num1 equivalente num2 = num2 -num1)
*= (num2 *= num1 equivalente num2 = num2 *num1)
/= (num2 /= num1 equivalente num2 = num2 /num1)
%= (num2 %= num1 equivalente num2 = num2 %num1)

 public class OperatorsDemo {public static void main (string [] args) {int num1 = 10; int num2 = 20; num2 = num1; System.out.println ("= output:"+num2); num2 += num1; System.out.println ("+= output:"+num2); num2 -= num1; System.out.println ("-= output:"+num2); num2 *= num1; System.out.println ("*= output:"+num2); num2 /= num1; System.out.println ("/= output:"+num2); num2 %= num1; System.out.println ("%= saída:"+num2); }}

Resultados Saída:

 = Saída: 10+= saída: 20- = saída: 10*= saída: 100/= saída: 10%= saída: 0

3. Operadores de autoconfiança e auto-decisão

Os operadores de auto-incremento e autodenagem operam apenas em uma variável e o valor das mudanças variáveis.

NUM ++ (Num equivalente = num+ 1) aumenta por si só, principalmente para variáveis numéricas, adicionando 1 ao valor de sua própria variável.
NUM -(Num equivalente = num -1) Auto -dedicado, direcionando principalmente variáveis numéricas, subtraindo o valor da variável do corpo em 1.

 public class OperatorsDemo {public static void main (string [] args) {int num1 = 100; int num2 = 200; num1 ++; num2--; System.out.println ("num1 ++ é:"+num1); System.out.println ("num2-- é:"+num2); }}

Resultados Saída:

 Num1 ++ é: 101num2-- IS: 199

4. Operadores lógicos

Os operadores lógicos, como o nome sugerem, são usados para julgamentos lógicos. O resultado da operação é um valor do tipo booleano, isto é, verdadeiro ou falso. Operadores uniformes lógicos têm

B1 && B2: Se B1 e B2 forem verdadeiros, B1 && B2 retornará verdadeiro, caso contrário, Falso

B1 || B2: Se B1 e B2 forem falsos, falsos serão devolvidos, caso contrário, o verdadeiro será devolvido.

! B1: retornará o valor oposto a B1, se B1 for falso, retornará true; Se B1 for verdadeiro, retorne falso

 public class OperatorsDemo {public static void main (string [] args) {boolean b1 = true; booleano b2 = false; System.out.println ("b1 && b2:" + (b1 && b2)); System.out.println ("b1 || b2:" + (b1 || b2)); System.out.println ("! (B1 && B2):" +! (B1 && b2)); }}

Resultado da saída:

 B1 && B2: FALSB1 || B2: Verdadeiro! (B1 && B2): true

Curto -circuito lógico:

No Java, os operadores lógicos suportam operações de curto-circuito e, uma vez que o valor de toda a expressão pode ser claramente expresso, não precisamos calcular o restante da expressão. Por exemplo, precisamos julgar que um objeto não está vazio e que o valor de retorno de seu método não está vazio, para que possamos fazer um julgamento como este:

 if (object! = null && object.werfunction ()! = null) {// faça algo.}

Se o objeto estiver vazio, o objeto de expressão da primeira parte! = Null retornará false, então, independentemente do resultado do objeto de expressão. O compilador otimizará automaticamente esta parte da operação e não executará objeto.wowerfunction ()! = Null.

5. Operadores relacionais

Usado para comparar o tamanho de dois dados variáveis, retorne o valor de booleano, isto é, verdadeiro ou falso

Os operadores relacionais incluem:

'==' e '! =' são adequados para todos os tipos de valores e objetos (ou seja, variáveis do tipo primitivo e variáveis de tipo de referência).

'>', '<', '> =' e '<=' não se aplicam aos valores dos tipos booleanos, porque eles têm apenas verdadeiros ou falsos e maiores e menores do que não têm significado prático.

 public class OperatorsDemo {public static void main (string [] args) {int num1 = 10; int num2 = 50; if (num1 == num2) {System.out.println ("num1 e num2 são iguais"); } else {System.out.println ("num1 e num2 não são iguais"); } if (num1! = num2) {System.out.println ("num1 e num2 não são iguais"); } else {System.out.println ("num1 e num2 não são iguais"); } else {System.out.println ("num1 e num2 não são iguais"); } igual ");} if (num1> num2) {System.out.println (" num1 é maior que num2 ");} else {System.out.println (" num1 não é maior que num2 ");} se (num1> = num2) {System.out.println (" num1.} maior ou igual a (num1> menor que num2 ");} if (num1 <num2) {System.out.println (" num1 é menor que num2 ");} if (num1 <num2) {System.out.println (" num1) é menor que num2 ");} else {System.out.println (" num1 não é menos que num2 "); System.out.println ("num1 é menor ou igual a num2");

Resultado da saída:

 Num1 e num2 não são iguaisnum1 e num2 não são iguaisnum1 não é maior que o num2num1 é menor que o num2num1 é menor que o num2num1 é menor ou igual a num2

6. Operador de bits

O objeto de operação direcionado pelo operador de bits é "bits" binários, que podem ser aplicados aos tipos inteiros (int), longos, curtos, tipo de caractere (char) e tipo de byte (byte) e outros tipos. Durante a operação, o bit correspondente (0 ou 1) será realizado em operação algébrica booleana ou operações em movimento.

A descrição da lógica computacional é um pouco obscura e podemos usar exemplos para entender mais claramente como os operadores de bits executam cálculos. Suponha que se x for igual a 60; y é igual a 13; Suas representações binárias e os resultados das operações de bits são as seguintes:

 x = 0011 1100y = 0000 1101 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Observe a diferença entre >> e >>>:

Operador de turno direito >>, se o valor da operação for positivo, 0 for inserido na posição alta; Se o valor for negativo, 1 será inserido na alta posição;

Mova -se para a direita para preencher o operador zero >>>, insira 0 na posição alta, independentemente de positivo ou negativo.

> Se você não entender a operação de bits, pule -o primeiro. Quando é realmente usado, você pode estudá -lo novamente.

7. Prioridade do operador

A prioridade do operador determina o agrupamento de termos em uma expressão. Afeta como uma expressão é avaliada. Um determinado operador tem maior prioridade do que outros operadores.

Por exemplo: o operador de multiplicação tem maior prioridade que o operador de adição e a expressão 1 + 5 * 6. De acordo com a prioridade do operador, o compilador calculará primeiro 5 * 6, depois calculará 30 + 1 e, finalmente, obterá o resultado 31.

A prioridade de vários operadores é de grande a pequena:

 ., (), [] Monocular +(da direita para a esquerda combinada), monocular - (da direita para a esquerda combinada), ++, -, ~,!

Não se preocupe com uma lista de prioridades tão complexa. Na maioria dos casos, a expressão em si é fácil de ver prioridade. Por exemplo, a operação de atribuição deve ter a menor prioridade. Nos casos em que a prioridade não é clara, podemos alterar a prioridade da maneira que queremos, para que não haja necessidade demais da prioridade do operador.

8. Outros operadores

Operador de três vias:

O operador condicional em Java é um operador ternário, e sua forma é a seguinte:

 BooleanExpression? ValueWhentrue: Valuewhenfalse

Se o valor da expressão booleano for verdadeiro, o valor da expressão é o valor do valor que, caso contrário, o valor do valorwenfalse.

Por exemplo, se queremos calcular o valor absoluto de x, podemos implementá -lo através do seguinte código:

 if (x> = 0) {y = x;} else {y = -x;}

Através do operador ternário, você só precisa de uma instrução y = x> = 0? x: -x; Para concluí -lo, o que é mais conciso.

Tipo Operador de conversão:

Usamos a conversão do tipo em muitos casos. Nos momentos apropriados, o Java converterá automaticamente o tipo de dados em outro de acordo com o tipo de dados. Por exemplo, se atribuirmos um valor inteiro à variável float, o compilador converterá int em float e o atribui à variável.

No entanto, em muitos casos, o Java não pode determinar se precisamos executar a conversão do tipo. No momento, precisamos de operadores de conversão de tipo, que nos permitem executar explicitamente a conversão do tipo, como:

 int a = 10; long b = (longo) a; longo c = (longo) 100;

Podemos digitar converter variáveis e constantes.

Ao executar a conversão do tipo de números de ponto flutuante, precisamos prestar atenção ao problema do truncamento. Se queremos digitar converter 10.9: (int) 10.9, seu valor não é arredondado 11, mas 10