java_运算符

算术运算符

+，-，*，/，%，++（自增），–（自减）

除法运算符： / 表示两个数相除运算

取余运算符：% 用来求余数

示例

public class TestOpe01{
        public static void main(String[] args){
                //打印结果：
                System.out.println(12/3); 
                System.out.println(12%5);
                System.out.println(12/3.0);
                System.out.println(12%5.0);
        }
}

++ ++单独使用的时候，无论放在前还是后，都是加1操作

将++参与到运算中：

规则：看++在前还是在后，如果++在后：先运算，后加1 如果++在前，先加1，后运算

示例

赋值运算符

= 将等号右侧的值赋给等号左侧

示例

public class TestOpe06{
        public static void main(String[] args){
                //任意给出两个数，交换两个数并输出：
                //1.给出两个数：
                int num1 = 10;
                int num2 = 20;
                
                //2.输出交换前的两个数：
                System.out.println("交换前："+num1+"\t"+num2);
                
                //3.交换
                /*
                错误代码：
                num1 = num2;
                num2 = num1;	
                */		
                //解决办法：
                //引入一个中间变量:
                int t;
                t = num1;
                num1 = num2;
                num2 = t;
                /*
                int t;
                t = num2;
                num2 = num1;
                num1 = t;
                
                */
                
                //4.输出交换后的两个数：
                System.out.println("交换后："+num1+"\t"+num2);
        }
}

扩展赋值运算符

+=，-=，*=，/=

示例

public class TestOpe07{
        public static void main(String[] args){
                //实现功能：给出三个数，求和：
                //1.给出三个数：
                int num1 = 10;
                int num2 = 20;
                int num3 = 30;
                //2.求和
                //int sum = num1+num2+num3;
                //定义一个变量，用来接收和：
                int sum = 0;
                sum = sum + num1;//等效：  sum += num1;
                sum = sum + num2;// sum += num2;
                sum = sum + num3;//sum += num3;
                //3.将和输出：
                System.out.println("和："+sum);
        }
}

关系运算符

大于 >，<，>=，<=，==，!=

示例

public class TestOpe08{
        public static void main(String[] args){
                //>，<，>=，<=，==，!=
                //关系运算符最终结果：要么是true要么是false
                System.out.println(4>9);//false
                System.out.println(4<9);//true
                System.out.println(4>=9);//false
                System.out.println(4<=9);//true
                System.out.println(4==9);//false
                System.out.println(4!=9);//true
                System.out.println((5<9)!=(6==8));//true
        }
}

逻辑运算符

&，|， &&，||，!，^

逻辑运算符：进行逻辑运算的，运算符左右连接的都是 布尔类型的操作数，最终表达式的结果是布尔值：要么是true，要么false

public class TestOpe09{
        public static void main(String[] args){
                // 逻辑与 ：& 规律：只要有一个操作数是false，那么结果一定是false
                System.out.println(true&true);
                System.out.println(true&false);
                System.out.println(false&false);
                System.out.println(false&true);
                
                // 短路与：&& 规律：效率高一些，只要第一个表达式是false，那么第二个					表达式就不用计算了，结果一定是false
                System.out.println(true&&true);
                System.out.println(true&&false);
                System.out.println(false&&false);
                System.out.println(false&&true);
                
                // 逻辑或：| 规律：只要有一个操作数是true，那么结果一定是true
                System.out.println(true|true);
                System.out.println(true|false);
                System.out.println(false|false);
                System.out.println(false|true);
                
                // 短路或：|| 规律：效率高一些，只要第一个表达式是true，那么第二个表				   达式就不用计算了，结果一定是true
                System.out.println(true||true);
                System.out.println(true||false);
                System.out.println(false||false);
                System.out.println(false||true);
                
                //逻辑非：   !  规律：相反结果
                System.out.println(!true);//false
                System.out.println(!false);//true
                
                //逻辑异或： ^  规律：两个操作数相同，结果为false，不相同，结果为					true
                System.out.println(true^true);
                System.out.println(true^false);
                System.out.println(false^false);
                System.out.println(false^true);
        }
}

public class TestOpe10{
        public static void main(String[] args){
                int i=8;
                System.out.println((5>7)&&(i++==2)); //false
                System.out.println(i);  //8 
                
                
                int a=8;
                System.out.println((5>7)&(a++==2)); //false
                System.out.println(a); //9
                
                
                int m=8;
                System.out.println((5<7)&&(m++==2)); //false
                System.out.println(m); //9
                
                int b=2;
                System.out.println((5<7)&(b++==2)); //true
                System.out.println(b);  //3
                
                int c=2;
                System.out.println((5<7)&(++c==2)); //false
                System.out.println(c);  //3
        }
}

位运算符

&，|，^，~ ， >>，<<，>>> (了解！！！)

条件运算符

？ :

a ？b：c

其中a是一个布尔类型的表达式，返回结果要么是true要么false，通过a的结果决定最终表达式的结果:
如果a的结果是true，那么表达式最终结果为b
如果a的结果是false，那么表达式最终结果为c

public class TestOpe11{
        public static void main(String[] args){
                int num = (5>7)?6:9 ;
                System.out.println(num);
                
                String str = (4==4)?"你好":"你不好" ;
                System.out.println(str);
                
                System.out.println((4==4)?"你好":"你不好");
        }
}

总结
运算符的优先级

实际开发中我们不会写特别复杂的表达式，你要想先算谁就用()

示例

5<6 | 'A'>'a' && 12*6<=45+23&&!true
=5<6 | 'A'>'a' && 12*6<=45+23&&false
= 5<6 | 'A'>'a' &&72<=68&&false
= true|false&&false&&false
= true&&false&&false
=false&&false
=false

**实际开发中我们不会写特别复杂的表达式，你要想先算谁就用()**

**示例**

```properties
5<6 | 'A'>'a' && 12*6<=45+23&&!true
=5<6 | 'A'>'a' && 12*6<=45+23&&false
= 5<6 | 'A'>'a' &&72<=68&&false
= true|false&&false&&false
= true&&false&&false
=false&&false
=false