En el contenido anterior, he aprendido a definir e inicializar variables. El propósito de definir variables es manipular datos. El lenguaje Java nos proporciona símbolos de código utilizados específicamente para operar estos datos, colectivamente llamados "operadores".
Según el uso de los operadores, podemos dividirlos en las siguientes categorías:
Operadores aritméticos
Operador de asignación
Operadores de autocuración y autodecientes
Operadores lógicos
Operadores relacionales
bit operador
No se preocupe, son solo símbolos que nos ayudan a procesar los datos de operación. El siguiente utiliza ejemplos de código para ilustrar el uso de estos operadores uno por uno.
1. Operadores aritméticos
Los operadores aritméticos son operaciones aritméticas para sumar, restar, multiplicar, dividir y tomar el resto de las variables numéricas:
Agregar: +
reducir:-
llevar:*
eliminar:/
Tomar equilibrio: %
Operadores de clase pública Demo {public static void main (string [] args) {int num1 = 100; int num2 = 20; // Agregar System.out.println ("num1 + num2:" + (num1 + num2)); // reste System.out.println ("num1 - num2:" + (num1 - num2)); // multiplicar system.out.println ("num1 * num2:" + (num1 * num2)); // descuento system.out.println ("num1 / num2:" + (num1 / num2)); // Obtenga el sistema restante.out.println ("num1 % num2:" + (num1 % num2)); }}Resultado de salida:
num1 + num2: 120num1 - num2: 80num1 * num2: 2000num1 / num2: 5num1 % num2: 0
2. Operador de asignación
Como la mayoría de los lenguajes de programación, Java usa el operador '=' para realizar operaciones de asignación. Esta operación asigna el resultado del cálculo a la derecha (llamada RValue) a la variable de la izquierda. Los operadores de asignación en Java incluyen:
= (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)
Operadores de clase pública Demo {public static void main (string [] args) {int num1 = 10; int num2 = 20; num2 = num1; System.out.println ("= salida:"+num2); num2 += num1; System.out.println ("+= output:"+num2); num2 -= num1; System.out.println ("-= salida:"+num2); num2 *= num1; System.out.println ("*= salida:"+num2); num2 /= num1; System.out.println ("/= output:"+num2); num2 %= num1; System.out.println ("%= salida:"+num2); }}Resultados de salida:
= Salida: 10+= salida: 20- = salida: 10*= salida: 100/= salida: 10%= salida: 0
3. Operadores de autoinforme y autodecientes
Los operadores de autoincremento y autodecientes solo operan en una variable, y el valor de la variable cambia.
num ++ (equivalente num = num+ 1) aumenta por sí mismo, principalmente para variables numéricas, agregando 1 al valor de su propia variable.
num -(equivalente num = num -1) autodeducir, principalmente variables numéricas, restando el valor de la variable del cuerpo por 1.
Operadores de clase pública Demo {public static void main (string [] args) {int num1 = 100; int num2 = 200; num1 ++; num2--; System.out.println ("num1 ++ es:"+num1); System.out.println ("num2-- es:"+num2); }}Resultados de salida:
num1 ++ es: 101num2-- es: 199
4. Operadores lógicos
Los operadores lógicos, como su nombre indica, se utilizan para juicios lógicos. El resultado de la operación es un valor de tipo booleano, es decir, verdadero o falso. Los operadores de uniformes lógicos tienen
| Operadores lógicos | Relaciones lógicas |
|---|---|
| && | y |
| `` | |
| ! | No |
b1 && b2: si tanto b1 como b2 son verdaderos, b1 && b2 devolverá verdadero, de lo contrario falso
B1 || B2: Si tanto B1 como B2 son falsos, se devolverán falsos, de lo contrario, verdadero se devolverá.
! B1: devolverá el valor opuesto a B1, si B1 es falso, devuelve verdadero; Si B1 es verdadero, devuelve falso
Operadores de clase pública Demo {public static void main (string [] args) {boolean b1 = true; booleano b2 = falso; System.out.println ("B1 && B2:" + (b1 && b2)); System.out.println ("B1 || b2:" + (b1 || b2)); System.out.println ("! (B1 && B2):" +! (B1 && B2)); }}Resultado de salida:
b1 && b2: falseb1 || B2: ¡True! (B1 && B2): verdadero
Cortocircuito lógico:
En Java, los operadores lógicos admiten operaciones de cortocircuito, y una vez que el valor de toda la expresión puede expresarse claramente, no necesitamos calcular el resto de la expresión. Por ejemplo, debemos juzgar que un objeto no está vacío y que el valor de retorno de su método no está vacío, por lo que podemos hacer un juicio como este:
if (object! = null && object.somefunction ()! = null) {// haz algo.}Si el objeto está vacío, el objeto de expresión de la primera parte! = NULL devolverá falso, entonces, independientemente del resultado de la expresión objeto. El compilador optimizará automáticamente esta parte de la operación y no ejecutará Object.SomeFunction ()! = NULL.
5. Operadores relacionales
Se utiliza para comparar el tamaño de dos datos variables, devolver el valor del booleano, es decir, verdadero o falso
Los operadores relacionales incluyen:
| Operadores relacionales | relación |
|---|---|
| > | Más que |
| < | Menos que |
| == | igual |
| ! = | No igual a |
| > = | Mayor o igual a |
| <= | Menos o igual a |
'==' y '! =' son adecuados para todos los tipos de valores y objetos (es decir, variables de tipo primitivo y variables de tipo de referencia).
'>', '<', '> =' y '<=' no se aplican a los valores de los tipos booleanos, porque solo tienen verdadero o falso, y mayor y menor de lo que no tiene importancia práctica.
Operadores de clase pública Demo {public static void main (string [] args) {int num1 = 10; int num2 = 50; if (num1 == num2) {system.out.println ("num1 y num2 son iguales"); } else {System.out.println ("num1 y num2 no son iguales"); } if (num1! = num2) {system.out.println ("num1 y num2 no son iguales"); } else {System.out.println ("num1 y num2 no son iguales"); } else {System.out.println ("num1 y num2 no son iguales"); } igual ");} if (num1> num2) {system.out.println (" num1 es mayor que num2 ");} else {system.out.println (" num1 no mayor que num2 ");} if (num1> = num2) {system.out.println (" num1 es mayor que o igual a num2 ");} de lo otro {system1) {systemn (num1.Printl (num1 es mayor que o es igual a que num2");} de lo otro {System1). menos que num2 ");} if (num1 <num2) {system.out.println (" num1 es menor que num2 ");} if (num1 <num2) {system.out.println (" num1 es menor que num2 ");} else {system.println (" num1 no es menor que num2 ");} if (num1 <<= num2) {num2) { System.out.println ("num1 es menor o igual a num2");Resultado de salida:
num1 y num2 no son igualnum1 y num2 no son igualnum1 no es mayor que num2num1 es menor que num2num1 es menor que num2num1 es menor o igual a num2
6. Operador de bits
El objeto de operación dirigido por el operador de bits es "bits" binarios, que se pueden aplicar a tipos enteros (int), largo, corto, tipo de caracteres (char) y tipo de byte (byte) y otros tipos. Durante la operación, el bit de bit correspondiente (0 o 1) se realizará en operaciones algebraicas booleanas o operaciones móviles.
| bit operador | Lógica computacional |
|---|---|
| Y | Y operación: para un cierto bit, siempre que ambos operandos sean 1, el resultado del bit es 1, de lo contrario es 0. |
| `` | `` |
| ^ | Operación XOR: para un cierto bit, si los dos operandos no son los mismos, el resultado del bit es 1, de lo contrario es 0. |
| ~ | No operación: el operador del complemento bit a bit fluye cada bit del operando |
| << | Operador binario de desplazamiento izquierdo: el operando izquierdo está desplazado por la izquierda por el operando derecho. |
| >> | Operador binario de desplazamiento derecho: el operando izquierdo se desplaza por el operando derecho. |
| >>> | Operador de complemento cero de desplazamiento derecho binario: el valor del operando izquierdo se desplaza a la derecha de acuerdo con el número de bits especificados por el operando derecho, y el bit vacío resultante se llena con cero |
La descripción de la lógica computacional es algo oscura, y podemos usar ejemplos para comprender más claramente cómo los operadores de bits realizan cálculos. Suponga que si x es igual a 60; y es igual a 13; Sus representaciones binarias y los resultados de las operaciones de bit son los siguientes:
x = 0011 1100y = 0000 1101 --------------------------------------------------------------- -------------------------------------------------------------------------------------------
Tenga en cuenta la diferencia entre >> y >>>:
Operador de desplazamiento derecho >>, si el valor de la operación es positivo, 0 se inserta en la posición alta; Si el valor es negativo, 1 se inserta en la posición alta;
Muévase a la derecha para llenar el operador cero >>>, inserte 0 en la posición alta independientemente de lo positivo o negativo.
> Si no comprende la operación de bits, omita primero. Cuando realmente se usa, puede estudiarlo nuevamente.
7. Prioridad del operador
La prioridad del operador determina la agrupación de términos en una expresión. Afecta cómo se evalúa una expresión. Un determinado operador tiene mayor prioridad que otros operadores.
Por ejemplo: el operador de multiplicación tiene una prioridad más alta que el operador de adición, y la expresión 1 + 5 * 6. Según la prioridad del operador, el compilador primero calculará 5 * 6, luego calculará 30 + 1 y finalmente obtendrá el resultado 31.
La prioridad de varios operadores es de grande a pequeño:
., (), [] Monocular +(combinado de derecha a izquierda), monocular - (derecha a izquierda combinada), ++, -, ~ ,!*, /,% +(izquierda a derecha combinada), - (izquierda a derecha combinada) >>, <<, >> <, <=,> == ,! = & | && ||
No se preocupe por una lista de prioridades tan compleja. En la mayoría de los casos, la expresión en sí es de prioridad fácil de ver. Por ejemplo, la operación de asignación debe tener la prioridad más baja. En los casos en que la prioridad no es clara, podemos cambiar la prioridad de la manera que queremos, por lo que no es necesario recordar demasiado la prioridad del operador.
8. Otros operadores
Operador de tres vías:
El operador condicional en Java es un operador ternario, y su forma es la siguiente:
booleanExpression? Valuewhentrue: valuewhenfalse
Si el valor de expresión booleano es verdadero, el valor de la expresión es el valor de valuewhentrue, de lo contrario el valor de valor cuando se realiza.
Por ejemplo, si queremos calcular el valor absoluto de X, podemos implementarlo a través del siguiente código:
if (x> = 0) {y = x;} else {y = -x;}A través del operador ternario, solo necesita una declaración y = x> = 0? x: -x; Para completarlo, lo cual es más conciso.
Tipo de operador de conversión:
Usamos la conversión de tipo en muchos casos. En los momentos apropiados, Java convertirá automáticamente el tipo de datos a otro de acuerdo con el tipo de datos. Por ejemplo, si asignamos un valor entero a la variable flotante, el compilador convertirá int en flotante y lo asignará a la variable.
Sin embargo, en muchos casos, Java no puede determinar si necesitamos realizar la conversión de tipo. En este momento, necesitamos operadores de conversión de tipo, que nos permitan realizar explícitamente la conversión de tipo, como:
int a = 10; largo B = (largo) A; largo C = (largo) 100;
Podemos escribir convertir tanto variables como constantes.
Al realizar la conversión de tipo de números de punto flotante, debemos prestar atención al problema del truncamiento. Si queremos escribir convertir 10.9: (int) 10.9, su valor no se redondea 11, sino 10