08※、运算符的使用

运算符的使用

    --算术运算符   + - * /  %

            +的作用：实现加法运算，实现字符串的拼接

/**
  * @author Lantzrung
  * @date 2022年7月17日
  * @Description
  */

String res = 5+6+"abc";//Output: 11abc
String res1 = "abc"+5+6;//Output:abc56 cause:前面是String类型的字符串拼接，所以后面也是字符拼
//接,而不是加法运算了
String res2 = "abc"+5+6+7+8+9;//Output:abc56789;
int res3 = 8/0;//java.lang.ArithmeticException: / by zero  0不能作为被除数
int res4 = 8/0.2;//compile error:不兼容的类型,float类型无法转换成int类型
double res5 = 8%3.1;// 1.8--->1.7999999999998

    --扩展后的赋值运算符

    注意：扩展后的赋值运算符中包含强制类型转换操作

            item += 3;不完全等于item = item +3;

            而是等于item = (item的类型)(item +3);

/**
  * @author Lantzrung
  * @date 2022年7月17日
  * @Description
  */


int x = 3;
int y = 5;
x = x + y;//Output:8;
x += y;//Output:8; int x = (int) y;



这里插入一个经典笔试题:

short i = 0;//为什么 i += 5 可以? 而i =  i + 5出现错误;
i += 5;//cause:此运算赋值符包含强转类型,i = (short)(i+5);
i = i + 5;//compile error : 不兼容的类型: 从int类型转换short类型成可能会损失
System.out.println(i);

            

    --位运算符

/**
  * @author Lantzrung
  * @date 2022年7月17日
  * @Description
  */

//0000 0111  7
//0000 0101  7
//0000 0101  5
int res1 = 7&5;//按位与 全真(1)则为真(1)  有假(0)则为假(0)
//0000 0101  5
//0000 0001  1
//0000 0001  1
int res2 = 5&1;//Output:1 

//0000 0111  7
//0000 0101  5
//0000 0101  7
int res3 = 7&5;//按位或: 有真(1)则为真(1)  全假(0)则为假(0)

//0000 0101  5
//0000 0010  2
//0000 0111  7
int res4 = 5|2;//7

//0000 0101  5
※//1111 1010 -1-4-1=-6
int res5 = ~5; //Output:-6 取反,因为符号[将所有进行取反，包括符号位]

//0000 1010  10
※//1111 0101 -1-8-2=-11
int res6 = ~11; //Output:-11      

//0000 0111  7 
//0000 0101  5
//0000 0010  2
int res7 = 7^5;//2 按位异或 不同则为真(1) 相同则为假(0) 

//0000 0101  5
//0000 1110 14
//0000 1011 11
int res8 = 14^5;//11

//0000 0101  5
//0000 1010 10
int res9 = 5<<1;//10 左移一位 低位补0              

//1111 0101  -2-8=-10
//1110 1010  -16-4-1=-20
int res10 = -10<<1;//-20

//0000 0101  5
//0000 0010  2
int res10 = 5>>1;// 右移一位 高位补符号位

//1111 1010   -5
※//1111 1101   -1-2=-3//因为符号位是负数 故要补位-1 
int res11 = -5>>1;//-3 右移一位   

//1111 1111 1111 1111 1111 1111 1111 1011 (8*4=32bit)
//0111 1111 1111 1111 1111 1111 1111 1101  
int res12 = -5 >>> 1;//2

//1111 1111就是-1所以要-1

        --左移  双目运算符    案例 ： 8向左移动一位，低位补0

        --有符号右移>>  高位补符号位

        --无符号右移>>> 高位补0

        笔试题：如何最快的实现2*8？  2<<3 唔姆这里详细过程我以后另外一下解释qwq

    --运算符的优先级(由高到低)

/**
  * @author Lantzrung
  * @date 2022年7月17日
  * @Description
  */

分隔符      .  []  ()  {}  ,  ;
单目运算符  ++ --  ~  !
强制类型转换运算符 (type)
乘法/除法/求余  *  /  %
加法/减法      +  -
移位运算符   <<  >>  >>>
关系运算符   <  <=  >=  >  instanceof
等价运算符  ==   !=
按位与    &
按位或    ^
条件与    &&
条件或    ||
三目运算符  ?:
赋值  =  += -= *= /= |= ^= %= <<=  >>=  >>>= 

    --比较运算符（短路和非短路的概念）

        >   <    >=    

    --逻辑运算符

--短路与 如果前面的表达式为假，则后面不需要在判断，直接短路

--短路或  前面为真，则直接短路，不执行后面的逻辑判断

/**
  * @author Lantzrung
  * @date 2022年7月17日
  * @Description
  */

//1、逻辑运算符
//与:全真(对)则为真，有假(错)则为假 
//必须都是true(1)真才返回true 否则返回false
if((3>2)&(4>2)) {}//真真 对对   运行通过
if((3>2)&(1>2)) {}//真假 对错 
if((1>2)&(0>2)) {}//假假 错错 
if((1>2)&(3>2)) {}//假真 错对 

//或:有真则为真，全假则为全假
//只要有一个是true(1)真就返回true 否则返回false
if((3>2)|(4>2)) {
}//真真 对对 
if((3>2)|(1>2)) {}//真假 对错  运行通过
if((1>2)|(0>2)) {}//假假 错错  运行通过
if((1>2)|(3>2)) {}//假真 错对  运行通过
		       
//短路和非短路的区别 非短路所有条件都要进行判断  

//短路与: 必须都为true时执行并返回true 否则返回false
//两个逻辑判断必须true时才会执行通过 否则都不执行
if((3>2)&&(4>2)) {}//真真 对对  运行通过
if((3>2)&&(1>2)) {}//真假 对错 
if((1>2)&&(0>2)) {}//假假 错错 
if((1>2)&&(3>2)) {}//假真 错对 
		
//短路或:有一个true时就可以返回true并执行不继续执行下一个方法条件,否则返回false  
//当都是false或者有一个false时 不会执行当前逻辑判断
if((3>2)||(4>2)) {}//真真 对对  运行通过
if((3>2)||(1>2)) {}//真假 对错  运行通过 前者执行   后者不执行
if((1>2)||(0>2)) {}//假假 错错 
if((1>2)||(3>2)) {}//假真 错对  运行通过 前者不执行 后者执行

--三目运算符（三个操作元素，相当于判断语句）

      (逻辑表达式)?数值1:数值2  

      如果表达式为真 则赋值数值1，为假则赋值数值2

/**
  * @author Lantzrung
  * @date 2022年7月19日
  * @Description
  */

public class Demo {

	public static void main(String[] args) {

		int score = 86;
		String ispass = (score>=60)?"及格":"不及格";
		System.out.println(score+"为"+ispass);
		
		//90~100A 75~90B >=60 C <60D
		String level = (score>=90)?"A":(score>=75)?"B":(score>=60)?"C":"D";
		System.out.println(score+"为"+level);
	}

}

     --自增自减操作

        如果自增或自减符号和其他运算符一起操作时，会有顺序的先后：

        ++在变量的后面，所以先进行算术运算再进行自增操作

        ++在变量的前面，所以先进行进行自增操作再算术运算

/**
 * @author Lantzrung
 * @date 2022年7月19日
 * @Description
 */

public class Test02 {
	public static void main(String[] args) {
		int i = 3; // i++ --> i+1 --> i先赋值再自增+1 
		// int a = i+++4;//其实这里就是i++ + 4
		int a = i++ + 4;// 思考，这里输出的是8 还是 7呢?
		System.out.println("i:" + i);// 4
		System.out.println("a:" + a);// 7 答案是7，为什么不是8上面i都输出是4了，这是为什么 
        // 呢？
		// 因为i++是先赋值后自增加1的，也就是说i是先赋值3的值去和a是4的值去运算先，再把结果等 
        // 于7的值赋值给a
		// 然后a输出是7的值，最后i才进行自增加1
		
		// 这里记得变量i要换一个继续定义等于3 因为上次自增后结果不等于3了
		int i1 = 3;
		int a1 = ++i1 + 4;//这次是8 还是 7呢？qwq
		System.out.println("i1:"+i1);//4
		System.out.println("a1:"+a1);//8 答案是8 详细我也不解释了
		
		// 简要的概括就是:
		// ++在变量后面涉及到其他的运算时，则先执行其他的运算，然后再自增
		// ++在变量前面涉及到其他的运算时，则先自增，然后再执行其他的运算
		
		
	}
}

/**
 * @author Lantzrung
 * @date 2022年7月19日
 * @Description
 */

public class Demo01 {

	public static void main(String[] args) {

		int i = 5;
		int b = 6;
		if ((i++ == 5) && (++b == 6)) {
			// 分析:因为有小括号，所以优先级是先算小括号里面的，然后再执行短语与的，
			// 前者执行条件中先赋值，故此5==5成立，最后再自增1;
			// 后者执行条件中先自增+1，故此7==6不成立，false又因是短路与，故此执行体中期改 
            // i=7;不执行
			// 但最后b还是等于7 a是等于6
			i = 7;
		}
		System.out.println(i);// 6
		System.out.println(b);// 7

		int i1 = 5;
		int b1 = 6;
		if ((i1++ == 5) || (++b1 == 6)) {
			// 分析:前者执行条件中成立 最后i1自增等于6(但还不是最终结果);
			// 因为这个是短语或,因为前者已经是true了,所以后者不执行直接输出b1是等于6,
			// 最后执行方法体中的i1=7，直接把之前i1=6覆盖掉了
			i1 = 7;
		}
		System.out.println(i1);// 7
		System.out.println(b1);// 6

		int i2 = 5;
		int b2 = 6;
		if ((i2++ == 5) & (6 / (b2++ -6)) > 0) {
			i2 = 7;
		}

		System.out.println(i2);//编译错误因为被除数不能为0，b2:6-6是等于0的所以报 
        //错:Exception in thread "main" java.lang.ArithmeticException: / by zero
		//System.out.println(b2);

	}

}