[Camino a la revisión final] JAVA (2) D

Esta es la última parte de nuestro JAVA 2, actualizaremos la declaración de bucle de Java 3 mañana, manténgase atento

---

Directorio de artículos

1. ¿Qué es un operador?

2. Operadores aritméticos

Tres operadores de asignación

Cuatro operadores de comparación (relacionales)

Cinco operadores lógicos

operador de seis bits

Siete operadores condicionales

Precedencia del operador octal

prefacio

En este capítulo hablaremos de los operadores. Esto es algo que debemos dominar. ¡Echemos un vistazo!

---

提示：以下是本篇文章正文内容，下面案例可供参考

1. ¿Qué es un operador?

 Los operadores son símbolos especiales que se utilizan para representar operaciones de datos, asignaciones y comparaciones.

Hay muchos tipos de operadores, ¿cuánto sabes?

Clasificación de operadores:

• Operadores aritméticos: +, - ,* ,/ ,%, ++,-- 7
• Operadores de asignación: =,+=,-=,*=,%=,/=,>>=,>>>=,<<=,&=,|=,^=
• Operadores de comparación, operadores relacionales: >, >=, <, <=, ==, !=
• Operadores lógicos: &,|,^,!,&&,||
• Operadores bit a bit: &,|,^,~,<<,>>,>>>
• operador condicional: expresión condicional
• Operador lambda: ->

Dividido por el número de operandos:

• operador unario
• operador binario
• operador ternario

2. Operadores aritméticos

1. Conceptos básicos

operador	operación	ejemplo	estructura
+	Signo de más	+3	3
-	negativo	a=3;-a	-3
+	agregar	3+3	6
-	reducir	4-3	1
*	llevar	3*4	12
/	eliminar	3/3	1
%	toma el resto	6%4	2
++	Primero se calcula el autoincremento (antes) y luego el valor a=2, b=++2 Autodecremento (después) toma el valor primero y luego opera a=2, b=2++	a=2,b=++a a=2,b=a++	a=3,b=3 a=3,b=2
--	Incremento automático (antes) calcula el valor después de la operación Primero el valor de autodecremento (después) y luego la operación	a=2,b=--a a=2,b=a--	a=1,b=1 a=1,b=2
+	concatenación de cadenas	“él”+“abajo”	"Hola"

Ejemplo modular de suma, resta, multiplicación y división:

public class yunsuan{
    public static void main(String[] args){
        int a = 3;
        int b = 4;

        System.out.println(a+b);//7
        System.out.println(a-b);//-1
        System.out.println(a*b);//12
        System.out.println(a/b);//0
        System.out.println(a%b);//3
        
        System.out.println(5%2);//1
        System.out.println(5%-2);//1
        System.out.println(-5%2);//-1
        System.out.println(-5%-2);//-1
        //商*除数+余数=被除数
        //5%-2  ==>商=-2 余数=1  （-2）*（-2）+1=5             
               }
        }

Dos usos de +

1. Si ambos lados son números, + significa suma

2. Si al menos uno de los dos lados es una cuerda, significa empalme

public class yunsuan2 {   
       public static void main(String[] args) {     
            String str1 = "Hello";     
            System.out.println(str1); // Hello
            System.out.println("Hello" + "World"); // HelloWorld
            
            String str2 = "Java";      
            System.out.println(str2 + 520); // Java520     
            System.out.println(str2 + 5 + 20); // Java520   
        }
 }

operaciones de suma y resta

public class yunsuan3 {   
        public static void main(String[] args) {     
             int a = 3;        //定义一个变量int
             a++;      
     System.out.println(a);   //像这样无论是++a，还是a++结果都一样，都是4
    }
 }

operación compuesta de autoincremento y autosustracción

    public class ArithmeticTest4 {   
            public static void main(String[] args) {
                int x = 3;  
                int y = x++; 
                //x++的时候，y是4，x是3，当++x的时候，有x是4，y也是4
                System.out.println(x);   
                System.out.println(y);    
                System.out.println("==========");
                int z = 5;     
                //System.out.println(++z);// 输出结果是6，z 的值也是6                     
                System.out.println(z++);// 输出结果是5，z 的值是6   
                System.out.println(z);
  
     } 
}
 

operador de asignación triple

símbolo =

• Cuando los tipos de datos en ambos lados de "=" son diferentes, puede usar la conversión de tipo automática o usar el principio de conversión de tipo obligatoria
• Soporte para asignación continua

Símbolos extendidos: +=, -=, *=, /=, %=

operador	interpretación de símbolos
+=	El valor de la izquierda del símbolo se suma al valor de la derecha, y finalmente el resultado se asigna a la variable de la izquierda
-=	El valor de la izquierda del símbolo se resta del valor de la derecha y, finalmente, el resultado se asigna a la variable de la izquierda.
*=	El valor de la izquierda del símbolo se multiplica por el valor de la derecha, y finalmente el resultado se asigna a la variable de la izquierda
/=	El valor de la izquierda del símbolo se divide por el valor de la derecha, y finalmente el resultado se asigna a la variable de la izquierda
%=	El valor a la izquierda del símbolo y el valor a la derecha realizan una operación de resto y finalmente asignan el resultado a la variable de la izquierda.

public class fuzhiyunsuna{
    public static void main (String[] args){
        int i1 = 10;  //定义int
        long l1 = i1;  //int升为long类型，自动转化
        byte bb1 = (byte)i1;//强制转化类型，变为int
        int i2 =i1;
        int a1 = 10;
        int b1 = 10;//分别赋值

        int a2,b2;
        a2 = b2 = 10;//连续赋值

        int a3 = 10,b3 = 20;
        
        int m1 = 10;
        m1 += 5;//相当于m=m+5 使用m=15
        System.out.println(m1);
        
        short s2 = 10;//short s2=s2+2
       // s2 = (short)(s2+2);     int类型赋值给short，有损精度
        System.out.println(s2);
        

}
}

Cuatro operadores de comparación (relacionales)

operador	operación	ejemplo	resultado
==	igual a	4==3	FALSO
!=	no igual a	4!=3	verdadero
<	menos que	4<3	FALSO
>	más que el	4>3	verdadero
<=	Menos que o igual a	4<=3	FALSO
>=	mayor o igual a	4>=3	verdadero
en vez de	Comprobar si es un objeto de clase.	Instancia "Hello" de String	verdadero

• Los resultados de los operadores de comparación son booleanos, ya sea verdadero o falso
• >,>=,<,<=: aplicable a tipos de datos básicos y solo aplicable a tipos de datos básicos
• ==, !=: aplicar a tipos de datos básicos y tipos de datos de referencia

class CompareTest {   
    public static void main(String[] args) {     
        int i1 = 10;     
        int i2 = 20;
    System.out.println(i1 == i2);//false     
    System.out.println(i1 != i2);//true
    System.out.println(i1 >= i2);//false

        int m = 10;     
        int n = 20;     
    System.out.println(m == n);//false     
    System.out.println(m = n);//20

        boolean b1 = false;     
        boolean b2 = true;     
    System.out.println(b1 == b2);//false         
    System.out.println(b1 = b2);//true  
     } 
}

Distinguir la diferencia entre "=" y "="

Cinco operadores lógicos

a	b	a&b	a&b	a|b	a||b	!a	a ^ b
verdadero	verdadero	verdadero	verdadero	verdadero	verdadero	FALSO	FALSO
verdadero	FALSO	FALSO	FALSO	verdadero	verdadero	FALSO	verdadero
FALSO	verdadero	FALSO	FALSO	verdadero	verdadero	verdadero	verdadero
FALSO	FALSO	FALSO	FALSO	FALSO	FALSO	verdadero	FALSO

Los operadores lógicos operan sobre variables o constantes de tipo booleano, y el resultado de la operación es también un valor de tipo booleano.

  1. Descripción del operador:
 & y &&: representan la relación "y". Cuando los valores booleanos en los lados izquierdo y derecho del símbolo son verdaderos, el resultado puede ser verdadero. De lo contrario, falso

         | y || : Indica una relación "o". Cuando uno de los valores booleanos a ambos lados del símbolo es verdadero, el resultado es verdadero. Cuando ambos lados son falsos, el resultado es falso

         ! : Indica una relación "no", cuando el valor booleano de la variable es verdadero, el resultado es falso. El resultado es verdadero cuando el valor booleano de la variable es falso.

         ^ ：当符号左右两边布尔值不同时，结果为 true。当两边布尔值相同时，结果为 false。

 区分“&”和“&&”：
相同点：如果符号左边是 true，则二者都执行符号右边的操作

不同点：& ： 如果符号左边是 false,则继续执行符号右边的操作
             &&  ：如果符号左边是 false,则不再继续执行符号右边的操作
                建议：开发中，推荐使用  &&
区分“|”和“||”：
                 相同点：如果符号左边是 false，则二者都执行符号右边的操作
                 不同点：| ： 如果符号左边是 true，则继续执行符号右边的操作
                                ||  ：如果符号左边是 true，则不再继续执行符号右边的操作
                建议：开发中，推荐使用  ||

六 位运算符

运算符	运算	范例
<<	左移	3<<2 =12  - 3*2*2=12
>>	右移	3>>1 = 1  - 3/2=1
>>>	无符号右移	3>>>1 = 1 - 3/1=1
&	与运算	6&3=2
|	或运算	6|3=7
^	异或运算	6^3=5
~	取反运算	~6=-7

七 条件运算符

 （条件表达式）？

                表达式1

                表达式2                

条件表达式都是boolean类型的结果，根据boolean的值选择表达式1或表达式2

八 运算符优先级

优先级	运算符说明	Java运算符
1	括号	（），[],{}
2	正负号	+，-
3	单位运算符	++，--,~,!
4	乘法除法，求余	*，/,%
5	加减法	+，-
6	移位运算符	<<,>>,>>>
7	关系运算符	<,<=,>,>=,instanceof
8	等价运算法	==,!=
9	按位与	&
10	按位异或	^
11	按位或	|
12	条件与	&&
13	条件或	||
14	三位运算符	?;
15	赋值运算符	=,+=,-=,*=,/=,%=
16	位赋值运算符	&=,|=,<<=,>>=,>>>=

因为优先级太多，记忆起来也麻烦，使用没有必要记住，我们习惯性的用（）来控制表达式的执行顺序，不要写的过于复杂，这样只会让我们更难受

---

总结

提示：这里对文章进行总结：

例如：以上就是今天要讲的内容，本文仅仅运算符使用，这就是我们的第二部分，我分为4部分写的，大家可以关注或者订阅，这样方便大家阅读，相信大家也不容易，我们的Java 三，将会讲循环语句，Java 四会讲到数组，等等一系列，希望大家多多支持，谢谢大家，爱你们呦！