1.5, JAVA Primeros conocimientos de operadores JAVA

1 operador

1.1 Resumen

Los operadores se utilizan para 连接 表达式realizar 操作数operaciones en los operandos.
Por ejemplo, la expresión num1+num2, sus operandos son num1 y num2, y el operador es "+".
En el lenguaje Java, los operadores se pueden dividir en cinco tipos:
算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符。
según los diferentes operandos, los operadores se dividen en 单目运算符, 双目运算符y 三目运算符.
Los operadores unarios tienen un solo operando, los operadores binarios tienen dos operandos y los operadores ternarios tienen tres operandos.
Los operadores bit a bit implican operaciones en bits binarios y no se utilizan mucho en los programas Java.

1.2 Hoja de referencia del operador

Operaciones de tipos de datos básicos y String

Concepto:
Tipo de cadena: Cadena La
cadena no es un tipo de datos básico, sino un tipo de datos de referencia
Utilice un par de "" para representar una cadena, que puede contener 0, 1 o más caracteres.
El método de declaración es similar al de los tipos de datos primitivos. Por ejemplo: String str = "Educación de Chuangyan";

运算规则 1、任意八种基本数据类型的数据与 String 类型只能进行连接“+”运算，且结果 一定也是 String 类型

运算规则 1、任意八种基本数据类型的数据与 String 类型只能进行连接“+”运算，且结果
一定也是 String 类型
System.out.println("" + 1 + 2);//12
int num = 10;
boolean b1 = true;
String s1 = "abc";
String s2 = s1 + num + b1;
System.out.println(s2);//abc10true
//String s3 = num + b1 + s1;//编译不通过，因为 int 类型不能与 boolean 运算
String s4 = num + (b1 + s1);//编译通过
2、String 类型不能通过强制类型()转换，转为其他的类型
String str = "123";
int num = (int)str;//错误的
int num = Integer.parseInt(str);//正确的，后面才能讲到，借助包装类的方法才能转

Ejemplo 2: dos usos del signo "+"

El primer tipo: si ambos lados de + son números, + significa suma
El segundo tipo: si al menos uno de los lados de + es una cadena, + significa empalme

public class ArithmeticTest2 {
    
    
public static void main(String[] args) {
    
    
// 字符串类型的变量基本使用
// 数据类型 变量名称 = 数据值;
String str1 = "Hello";
System.out.println(str1); // Hello
System.out.println("Hello" + "World"); // HelloWorld
String str2 = "Java";
// String + int --> String
System.out.println(str2 + 520); // Java520
// String + int + int
// String + int
// String
System.out.println(str2 + 5 + 20); // Java520
} 
}

2. El tipo de cadena no se puede convertir a otros tipos a través de la conversión de tipo () obligatoria

String str = "123";
int num = (int)str;//错误的
int num = Integer.parseInt(str);//正确的，后面才能讲到，借助包装类的方法才能转

1.3 Ejercicio: Prueba de incremento y decremento

Crear paquete: cn.tedu.basic
Crear clase: TestOperator.java

package cn.tedu.basic;
/**本类用于测试取余运算符*/
public class TestOperator {
    
    
	//0.创建程序的入口函数main
	public static void main(String[] args) {
    
    
		//1.测试除法与取余数
		System.out.println(25 / 10);//2
		System.out.println(25 % 10);//5
		
         /**
         * 在使用%运算符的时候如果被除数小于除数。
         * 那么，打印的结果就是被除数
         * */
        System.out.println(2%3);
        System.out.println(5%6);

     /*
     * 在除数中如果，被除数小于除数。那么，打印的结果是0
     * */
        System.out.println(5/6);

		//2.练习1：获取一个两位数59的十位与个位
		int x = 59;
		System.out.println(x/10);//打印十位,5
		System.out.println(x%10);//打印个位,9
		
		//3.练习2：获取一个三位数159的百位、十位与个位
		int y = 159;
		System.out.println(y / 100);//打印百位
		System.out.println(y / 10 % 10);//打印十位
		System.out.println(y % 10);//打印个位
		
		//4.测试自增自减运算符
		/** 前缀式：符号在前：++a --a ,先改变变量本身的值，再使用，比如打印
		 *  后缀式：符号在后:   a++ a--，先使用，再改变变量本身的值
		 *  ++: 相当于给变量本身的值+1
		 *  --: 相当于给变量本身的值-1
		 * */
		System.out.println("我是一个无情的分界线");
		
		
		int a = 1;
		System.out.println(++a);//2
		System.out.println(a);//2
		
		int b = 1;
		System.out.println(b++);//1
		System.out.println(b);//2
		
		int c = 1;
		System.out.println(--c);//0,符号在前，先自减，再打印
		System.out.println(c);//0，上面已经自减过了
		
		int d = 1;
		System.out.println(d--);//1，符号在后，先打印，再自减
		System.out.println(d);//0,打印过后，自减成0
		
		//之前的代码会对后面的代码产生影响，c的值是0
		System.out.println(c);//0
		System.out.println(--c-c-c--);//1,-1-(-1)-(-1)=1
		System.out.println(c);//-2,经历了两次自减，所以0-2=-2
		
	}
}

+= -= *= /= %= uso de

//举例说明+= -= *= /= %= 
int m1 = 10;
m1 += 5; //类似于 m1 = m1 + 5 的操作，但不等同于。
System.out.println(m1);//15

//练习 1：开发中，如何实现一个变量+2 的操作呢？
// += 的操作不会改变变量本身的数据类型。其他拓展的运算符也如此。
//写法 1：推荐
short s1 = 10;
s1 += 2; //编译通过，因为在得到 int 类型的结果后，JVM 自动完成一步
强制类型转换，将 int 类型强转成 short
System.out.println(s1);//12
//写法 2：
short s2 = 10;
//s2 = s2 + 2;//编译报错，因为将 int 类型的结果赋值给 short 类型的
变量 s 时，可能损失精度
s2 = (short)(s2 + 2);
System.out.println(s2);

两种方式的区别：

s = s+2; //① 编译报错
s += 2; //② 正常执行
//①和②有什么区别？

s = s + 2和s += 2的作用都是增加2。
      不过使用起来还是有区别的，如果s是int类型，这两者效果完全相同，但如果s是byte或short类型，第一种编译则会报错，因为byte类型或short类型的s和int类型的2相加，其结果是需要int类型来接收，所以byte s = s + 2或者short s = s + 2是不符合规则的，而第二种则不会报错，因为+=不会改变本身变量的数据类型。

关系运算符

比较运算符的结果都是 boolean 型，也就是要么是 true，要么是 false。 
    • > < >= <= ：只适用于基本数据类型（除 boolean 类型之外）
      == != ：适用于基本数据类型和引用数据类型
    • 比较运算符“==”不能误写成“=”

逻辑运算符

– & 和 &&：表示"且"关系，当符号左右两边布尔值都是 true 时，结果才能为 true。否则，为 false。 
– | 和 || ：表示"或"关系，当符号两边布尔值有一边为 true 时，结果为true。当两边都为 false 时，结果为 false
– ! ：表示"非"关系，当变量布尔值为 true 时，结果为 false。当变量布尔值为 false 时，结果为 true。 – ^ ：当符号左右两边布尔值不同时，结果为 true。当两边布尔值相同时，结果为 false。

Diferenciar entre "&" y "&&":
– El mismo punto: si el lado izquierdo del símbolo es verdadero, ambos realizan la operación del lado derecho del símbolo
– Diferencia: &: si el lado izquierdo del símbolo es falso, continúan realizando la operación del lado derecho del símbolo
&&: si el lado izquierdo del símbolo es falso, no continúe Realice la operación del lado derecho del símbolo
– Sugerencia: En desarrollo, se recomienda usar &&

==Distingue entre "|" y "||": ==
- el mismo punto: si el lado izquierdo del símbolo es falso, ambos realizan la operación en el lado derecho del símbolo
- diferencia: | : si el lado izquierdo del símbolo es verdadero, continúe ejecutando el lado derecho del símbolo La operación de
|| : Si el lado izquierdo del símbolo es verdadero, la operación del lado derecho del símbolo no continuará realizándose
—sugerencia: en desarrollo, se recomienda utilizar ||

1.4 Ejercicio: Prueba de Operadores Lógicos

Crear paquete: cn.tedu.basic
Crear clase: TestOperator2.java

package cn.tedu.basic;
/**本类用于测试逻辑运算符*/
public class TestOperator2 {
    
    
	public static void main(String[] args) {
    
    
		/**与：全真才真*/
		System.out.println("测试单与：");
		System.out.println(true & true);
		System.out.println(true & false);
		System.out.println(false & true);
		System.out.println(false & false);
		System.out.println("测试双与：");
		System.out.println(true && true);
		System.out.println(true && false);
		System.out.println(false && true);
		System.out.println(false && false);
		/**或：全假才假*/
		System.out.println("测试单或：");
		System.out.println(true | true);
		System.out.println(true | false);
		System.out.println(false | true);
		System.out.println(false | false);
		System.out.println("测试双或：");
		System.out.println(true || true);
		System.out.println(true || false);
		System.out.println(false || true);
		System.out.println(false || false);
	}
}

operador bit a bit

Desplazar a la izquierda: <<
Regla de operación: dentro de un cierto rango, cada bit de datos desplazado hacia la izquierda es equivalente a los datos originales*2. (ambos números positivos y negativos son aplicables)

3<<4 es como 3 2 elevado a 4 => 3 16 => 48

-3<<4 es como -3 2 elevado a 4 => -3 16 => -48

(2) Desplazamiento a la derecha: >>

Regla de operación: dentro de un cierto rango, cada vez que los datos se mueven hacia la derecha, es equivalente a los datos originales/2. (Ambos
números positivos y negativos son aplicables)
[Nota] Si no puede ser divisible, redondee hacia abajo.

69>>4 es similar a 69/2 4 veces = 69/16 =4

-69>>4 es como -69/2 4 veces = -69/16 = -5

(3) Desplazamiento a la derecha sin signo: >>>
Reglas de operación: Después de desplazarse a la derecha, los bits vacíos a la izquierda se llenan directamente con 0. (ambos números positivos y negativos son aplicables)
69>>>4 es similar a 69/2 4 veces = 69/16 =4

-69>>>4 Resultado: 268435451

operador ternario

Formato de operador condicional:
(条件表达式)? 表达式 1:表达式 2
Descripción: La expresión condicional es el resultado del tipo booleano, seleccione la expresión 1 o la expresión 2 según el valor del booleano

1.5 Ejercicio: encuentra el valor máximo de dos números

Crear paquete: cn.tedu.basic
Crear clase: TestMaxNum.java

package cn.tedu.basic;

import java.util.Scanner;

/**需求:接收用户输入的两个整数,并比较输出这两个数的最大值*/
public class TestMaxNum {
    
    
	public static void main(String[] args) {
    
    
		//1.提示用户输入
		System.out.println("请输入您要比较的第一个整数:");
		//2.接收用户输入的整数,并把这个值交给变量a来保存
		int a = new Scanner(System.in).nextInt();
		System.out.println("请输入您要比较的第二个整数:");
		int b = new Scanner(System.in).nextInt();
		
		//3.比较接收两个数,使用三元运算符
		/**1 ? 2 : 3
		 * 1是表达式,若1的结果为true,结果取2位置,若1的结果为false,结果取3位置
		 * */
		//4.定义变量max来保存比较的最大值
		int max = a > b ? a : b;
		
		//5.打印最大值
		System.out.println("两个数的最大值是:"+max);	
		/**思考题:如何判断3个数的最大值? int max = a>b?(a>c?a:c):(b>c?b:c);*/
	}
}

1.6 Ejercicio: Encontrar años bisiestos en años promedio

Crear paquete: cn.tedu.basic
Crear clase: TestYear.java

//需求:接收用户输入的年份,判断是平年还是闰年
package cn.tedu.basic;

import java.util.Scanner;

/**
 * 需求:接收用户输入的年份,判断是平年还是闰年
 * 如果年份是闰年,需要满足下面两个条件之一:
 * 条件1:能被4整除,并且不能被100整除
 * 条件2:能被400整除
 * */
public class Test3_Year {
    
    
	public static void main(String[] args) {
    
    
		//1.提示并接收用户输入的年份
		System.out.println("请输入您要判断的年份:");
		int year = new Scanner(System.in).nextInt();
		
		//2.定义一个变量用来保存结果
		String result = "平年";//默认值是平年,假设每年都是平年
		
		//3.判断用户输入的年份是否满足闰年的条件
		/**解决方案1*/
		/**条件1:能被4整除,并且不能被100整除*/
//		if(year % 4 == 0) {//能被4整除
//			if(year %100 != 0) {//不能被100整除
//				result = "闰年";//符合闰年的条件1,修改结果为闰年
//			}
//		}
//		/**条件2:能被400整除*/
//		if(year % 400 == 0) {//能被400整除
//			result = "闰年";//符合闰年的条件2,修改结果为闰年
//		}
		/**解决方案2*/
		/**判断结构 if(判断条件){满足判断条件以后执行的代码} */
		//if(条件1  || 条件2){是闰年 }
		//if((小条件1  && 小条件2) || 条件2){ 是闰年 }
		//if((能被4整除  && 不能被100整除) || 能被400整除){ 是闰年 }
		if((year % 4 == 0 && year %100 != 0) || year % 400 == 0){
    
    
			result = "闰年";//符合闰年的条件,修改结果为闰年
		}
		System.out.println(year+"年是"+result);
	}
	
}

2 Suplementos de Expansión:

2.1 Resumen 1: Los operadores de autoincremento y autodecremento de los operadores aritméticos
a es el operando, ++ es el operador de autoincremento, - - es el operador de autodecremento, y los operadores de autoincremento y autodecremento pueden colocarse delante de la variable. También se puede colocar detrás de la variable, por ejemplo: a++, ++a, a- -, - -a, etc.
Incremento automático (++): suma 1 al valor de la variable
con un prefijo (como ++a) y un sufijo (como a++). El tipo de prefijo es para agregar 1 antes de usar; el tipo de sufijo es para usar y luego agregar 1.
Autodecremento (- -): Disminuye el valor de la variable en 1.
Tipo de prefijo (como - -a) y tipo de sufijo (como a- -). El tipo de prefijo es para restar 1 antes de usarlo; el tipo de sufijo es para usarlo primero y luego restar 1.

2.2 Resumen 2: Operadores lógicos
Los operadores lógicos conectan dos expresiones relacionales o variables booleanas para resolver el problema de juicio de combinación de múltiples expresiones relacionales
Tenga en cuenta que los resultados de la operación devueltos por los operadores lógicos son de tipo booleano
Por lo general, usamos 0 para representar falso, use 1 para representar verdadero
y: para representar la relación
& simple y: 1 y 2, el resultado quiere ser verdadero, y tanto 1 como 2 deben ser verdaderos
&& doble y (cortocircuito y): 1 && 2, cuando 1 es falso , 2 se cortocircuitará para mejorar la eficiencia del programa
O: Indica la relación de O|
O único: 1 | 2, el resultado quiere ser verdadero, y solo se requiere uno de 1 y 2 para ser verdadero
|| Doble OR (cortocircuito o): 1|| 2, cuando 1 es verdadero, 2 se cortocircuitará para mejorar la eficiencia del programa

2.3 Resumen 3: Control de prioridad
Cuando una expresión contiene múltiples operadores, es necesario considerar la prioridad de los operadores, los operadores con mayor prioridad participan primero en la operación y los operadores con menor prioridad participan en la operación después. En el desarrollo real, no necesita memorizar la prioridad de los operadores, y no use deliberadamente la prioridad de los operadores.Use paréntesis para ayudar en la gestión de prioridades donde la prioridad no está clara.

prioridad	Descripción del operador	Operadores Java
1	soportes	() 、 [] 、 {}
2	firmar	+、-
3	operador de unidad	++、–、~、！
4	multiplicacion, division, resto	*、/、%
5	suma resta	+、-
6	operador de turno	<<、>>、>>>
7	operador relacional	<、<=、>=、>、instancia de
8	Operador de equivalencia	==、!=
9	bit a bit Y	&
10	XOR bit a bit	^
11	bit a bit o	/
12	Condiciones y	&&
13	condición o	//
14	operador ternario	? :
15	operador de asignación	<、<=、>=、>、instancia de
dieciséis	operador de asignación bit a bit	&=、/=、<<=、>>=、>>>=

1. No confíe demasiado en la prioridad de las operaciones para controlar el orden de ejecución de las expresiones, ya que esto es
   demasiado legible, trate de usar () para controlar el orden de ejecución de las expresiones.
2. No hagas una expresión demasiado complicada. Si una expresión es demasiado complicada, divídela
   en varios pasos para completarla. Por ejemplo: (num1 + num2) * 2 > num3 &&
   num2 > num3 ? num3 : num1 + num2;