java基础学习day03（运算符）

运算符之一：算数运算符
+(正) -(负) + - * / 前++ 后++ 前-- 后-- %

class AriTest{
     public static void main(String[] args){
         //  除号 /
         int num1 = 12;
         int num2 = 5;
         int result1 = num1 / num2;
         System.out.println(result1);
         int result2 = num1 / num2 * num2; // 10
         System.out.println(result2);
         
         // 取模（取余）运算  %
         //结果的符号和被模数符号相同
         //取余运算经常在开发中判断是否被除尽的情况
         int m1 = 12;
         int m2 = 5;
         int result3 = m1 % m2;
         System.out.println("m1 % m2 = " + result3); // 2
         int m3 = 10;
         int m4 = 6;
         System.out.println("m3 % m4 = " + m3 % m4); // 4
         
         int m5 = -10;
         int m6 = 6;
         System.out.println("m5 % m6 = " + m5 % m6); // -4
         
         int m7 = 10;
         int m8 = -6;
         System.out.println("m7 % m8 = " + m7 % m8); // 4
         
         int m9 = -10;
         int m10 = -6;
         System.out.println("m9 % m10 = " + m9 % m10); // -4
         
         //（前）++ （后）++
         // (前) --  (后) --
         int a1 = 10;
         int b1 = ++a1;
         System.out.println("a1 = " + a1 + ",b1 = " + b1 );
         int a2 = 10;
         int b2 = a2++;
         System.out.println("a2 = " + a2 + ",b2 = " + b2);
         //注意点
         short s1 = 10;
         //编译不通过
         //s1 = s1 + 1;
         //s1 = (short)(s1 + 1);
         s1++;//自增1，不会改变原本变量的数据类型
         System.out.println(s1);
          
     }
 }

赋值运算符
= += -= *= /= %=
如果在开发过程中，希望变量实现+2的操作，有几种方法？（前提：int num = 10；）
方式一：num = num + 2;
方式二：num += 2;(推荐,不会改变变量本身的数据类型)

class SetValueTest{
    public static void main(String[] args)
    {
        int j1 = 10;
        int i1 = 10;
        //连续赋值
        int i2,j2;        
        i2 = j2 = 10;
        int i3 = 10,j3 = 20;
        
        
        int num1 = 10;
        num1 += 2; //num1 = num1 + 2;
        System.out.println(num1);
        
        short s1 = 10;
        //s1 = s1 + 2;编译失败
        s1 += 2; //不会改变变量本身的数据类型
        System.out.println(s1);
        
比较运算符
        比较运算符的结果都是boolean型，要么是true，要么是false
        比较运算符“==”不能误写成“=”
        ==  != > < >= <= instanceof

        int i = 20;
        int j = 10;
        System.out.println(i == j); //结果是false
        System.out.println(i = j); //结果是10
        
        boolean b1 = true;
        boolean b2 = false;
        System.out.println(b2 == b1);//false
        System.out.println(b2 = b1); //true
        

逻辑运算符
&逻辑与 |逻辑或 !逻辑非
&&短路与 ||短路或 ^逻辑异或
开发中推荐使用短路与 短路或

//区分&与&&
    boolean c1 = true;
    int num3 = 10;
    if(c1 & (num3++ > 0)){
        System.out.println("我在北京");
    }
    else{
        System.out.println("我在南京");
    }
    System.out.println("num3=" + num3);
    
    boolean c2 = true;
    int num4 = 10;
    if(c2 && (num4++ > 0)){
        System.out.println("我在北京");
    }
    else{
        System.out.println("我在南京");
    }
    System.out.println("num4=" + num4);
    
    
    boolean c3 = true;
    c3 = false;
    int num5 = 10;
    if(c3 & (num5++ > 0)){
        System.out.println("我在北京");
    }
    else{
        System.out.println("我在南京");
    }
    System.out.println("num5=" + num5);
    
    
    boolean c4 = true;
    c4 = false;
    int num6 = 10;
    if(c4 && (num6++ > 0)){
        System.out.println("我在北京");
    }
    else{
        System.out.println("我在南京");
    }
    System.out.println("num6=" + num6);

    结论
    相同点：运算结果相同，当符号左边是true时，二者都会执行符号右面的运算
   不同点：当符号左边是false时，&继续执行符号右边的运算，&&不再执行符号右边的运算。

区分|与||

结论：运算结果相同，当符号左边是false时，二者都会执行符号右面的运算
      不同：当符号左面是true时，|继续执行符号右边的运算，||不再执行符号右边的运算。

位运算符

结论：1.位运算符操作的都是整形的数据
2. << 在一定范围内，每向左移一位，相当于*2；
>> 在一定范围内，美向右移一位，相当于/2；

面试题：如何高效的计算2*8？  2 << 3 或 8 << 1

class BitTest{
	public static void main(String[] args){
		int i = 21;
		int j = -21;
		System.out.println("i << 2:"+(i<<2));
		System.out.println("i << 27:"+(i<<27)); 
		System.out.println("j << 2:"+(j<<2));
		
		int m = 12;
		int n = 5;
		System.out.println("j & 2:"+(m & n));
		System.out.println("j | 2:"+(m | n));
		System.out.println("j ^ 2:"+(m ^ n));
		
		//练习  交换俩个变量的值
		int num1 = 10;
		int num2 = 20;
		System.out.println("num1:" + num1 + ",num2:" + num2);
		
		//方式一：定义临时变量的方式
		int c = num1;
		 num1 = num2;
		 num2 = c;
		 System.out.println("num1:" + num1 + ",num2:" + num2);
		 
		 //方式二：好处：不用定义临时变量
		 //坏处：1.相加操作可能超出存储范围。
          //     2. 有局限性，只能适用于数值类型
		 num1 = num1 + num2;
		 num2 = num1 - num2;
		 num1 = num1 - num2;
		 System.out.println("num1:" + num1 + ",num2:" + num2);
		 
		//方式三：使用位运算符
		num1 = num1 ^ num2;
		num2 = num1 ^ num2;
		num1 = num1 ^ num2;
		System.out.println("num1:" + num1 + ",num2:" + num2);
	}
}

三元运算符
(条件表达式)？表达式1 ：表达式2;
条件表达式的结果为boolean类型
条件表达式结果为true，运算后的结果为表达式1
条件表达式结果为false，运算和的结果为表达式2

表达式1和表达式2要求是一致的

凡是可以使用三元运算符的地方 都可以改写成 if-else

class SanYuanTest{
	public static void main(String[] args){
		//获取俩个整数的较大值
		int m = 12;
		int n = 5;
		
		int max = (m > n) ? m : n;
		System.out.println(max);
		
		//(m > n)? 2 : "n大";  编译错误
		
		String maxStr = (m > n)? "m大" : "n大"; 
		System.out.println(maxStr);
		//*****************************
		//获取三个数的最大值
		int n1 = 10;
		int n2 = 30;
		int n3 = -10;
		
		//放到一起，可以 但是可读性差，不推荐
		int threeMax = (((n1 > n2) ? n1 : n2) > n3) ? ((n1 > n2) ? n1 : n2) : n3;  
		System.out.println(threeMax);
		
	    //推荐
		int max1 = (n1 > n2) ? n1 : n2;
		int max2 = (max1 > n3) ? max1 : n3;
		System.out.println(max2);
		
	}
}