运算符流程控制

一、运算符

运算符类型	运算符
算术运算符	+，-，*，/，++，--，%
关系运算符	<，<=，>，>=，==，!=
布尔(逻辑)运算符	&&， ||，&，|，!，^
位运算符	&，|， ~，^，>>，>>>，<<
赋值类运算符	=， +=， -=， *=， /=， %=
字符串连接运算符	+
条件运算符(三目运算符）	? :
其他运算符	instanceof，new

1. 算数运算符

public class demo1 {
    public static void main(String[] args){
        //除法
        int a=10;
        int b=3;
        double c=10;
        System.out.println(a/b); //整数相除只保留整数部分
        System.out.println(c/b); //带有double则正常计算
        //自增++，自减--（原理相同）
        int d=10;
        int e=d++;
        System.out.println(e);//++在后，先执行操作，再自增
        System.out.println(d);
        System.out.println(++d);//++在前，先自增，再执行操作
        System.out.println(d);
        int p = 2;
        p = 2 + p++ + ++p + p++ + ++p;
        //p =2 + 2 + 4 + 4 + 6=18
        System.out.println(p);
        int x = 10;
        x = 10 + x++ + ++x + (10 * x++) + ++x; //自增优先级高于小括号
        //x= 10 + 10 + 12 + (10*12) + 14 =166
        System.out.println(x);
        int t=5;
        t=t+++10;
        //t = 5+10=15
        System.out.println(t);//15
        t=++t+10;
        //t = 16+10=26
        System.out.println(t);//26
    }
}

2.关系运算符

public class demo2 {
    public static void main(String[] args){
        //关系运算符
        int a=1;
        int b=2;
        double c=1;
        System.out.println(a>b);   //false
        System.out.println(a>=b);  //false
        System.out.println(a<b);   //true
        System.out.println(a<=b);  //true
        System.out.println(a==b);  //false
        System.out.println(a!=b);  //true
        System.out.println(a==c);  //true
    }
}

 3.逻辑运算符

public class demo3 {
    public static void main(String[] args){
        int a=1;
        int b=2;
        int c=3;
        System.out.println(a<b&b<c);//与：&&和&运算结果相同，但是&&碰到第一个结果为false的表达式，就不再执行后续表达式 //true
        System.out.println(a<b|b>c);//或：||和|原理同上，|| 碰到第一个结果为true的表达式，后面的不再执行 //true
        System.out.println(!(a<b));//非 //false
        System.out.println((a<b)^(b<c));//亦或，表达式结果相同为true，不同为false  //false
        System.out.println(2&3);//数字会转化成二进制比较每一位，若都为1，则取1，否则都是0
        //2：0000 0010     //用0补全8位
        //3：0000 0011
        //   0000 0010     //故最后结果为2
    }
}

4. 赋值运算符

public static void main(String[] args) {
        //赋值运算符
        int a=5;
        int b=10;
        System.out.println(a+=b);//a=15
        System.out.println(a-=b);//a=5
        System.out.println(a*=b);//a=50
        System.out.println(a/=b);//a=5
        System.out.println(a%=b);//a=5
        byte num3=2;
        num3++;//num3=3
        num3+=3333;
        System.out.println(num3);//由于byte取值范围小，需要强制转换，将3333转化为二进制后，取后8位进行运算
                                 //3333转换为二进制：1101 0000 0101，后8位：0000 0101,转换为10进制是5
                                 //再用5+3=8
    }

5.字符串连接运算符

public static void main(String[] args) {
        int a=10;
        int b=5;
        System.out.println("a"+b);//有字符串时，“+”为字符串拼接
        System.out.println(a+b);//只有数字时，“+”为数值相加
        System.out.println("相加"+a+b);
        System.out.println("相加"+(a+b));//即有字符串拼接，又有数值运算的，把数值运算用小括号括起来
    }

运算结果：

 6.运算符优先级

优先级	运算符分类	结合顺序	运算符
由高到低	分隔符	左结合	. [] ( ) ; ,
	一元运算符	右结合	! ++ – - ~
	算术运算符 移位运算符	左结合	* / % + - << >> >>>
	关系运算符	左结合	< > <= >= instanceof == !=
	逻辑运算符	左结合	! && || ~ & | ^
	三目运算符	右结合	布尔表达式?表达式1:表达式2
	赋值运算符	右结合	= *= /= %= += -= <<= >>= >>>= &= *= |=

二、流程控制语句

程序控制结构包括：顺序结构、分支结构、循环结构。

1.顺序结构

顺序结构程序就是按语句出现的先后顺序执行的程序结构。

2.分支结构（选择结构）

 public static void main(String[] args){
        //1.三目运算符  格式： 条件？条件为true的结果：条件为false的结果
        int a=1;
        int b=2;
        System.out.println(a>b?"a大于b":"a小于b");
        //2.单分支（if），若if下要执行的代码块只有一句，可以不加大括号，建议都加
        //3.双分支（if-else）
        //4.多分支（第一种：if-elseif-else 第二种：switch-case多分支）
        int age=38;
        if(age>=0&&age<18){
            System.out.println("未成年人");
        }else if(age>=18&&age<40){
            System.out.println("青年"); //只要有任何一个条件满足，就会跳出这个多重if选择结构
        }else if(age>=40&&age<60){       //分支结构可以互相嵌套
            System.out.println("中年");
        }else if(age>60){
            System.out.println("老年");
        }else{
            System.out.println("输入有误");
        }
        String color="red";
        switch(color){ 
            case "red":
                System.out.println("红");
                break;
            case "blue":
                System.out.println("蓝");
                break;
            default:
                System.out.println("输入错误");
                break;
        }
    }
//表达式的类型（此代码中color的位置）：int、short、byte，char、String、 枚举
//case的顺序以及default的顺序是可以打乱的，但是不推荐

1. if和switch的对比

switch:有局限性，只能去做等值判断

if：可以判断等值，也可以判断连续的一段空间（区间判断）

2.switch穿透（省略break的问题）

//switch穿透（省略break的问题）
        //1.在switch结构中只进行一次判断
        //2.遇到break才会结束
        //3.若无break，则会略过判断语句，直接往下执行，直到遇到break，或switch整个语句执行完才会结束
        //4.case的顺序以及default的顺序是可以打乱的
        int num=10;
        switch (num){
            case 1:
                System.out.println("星期一");
                break;
            default:
                System.out.println("周末");
                //break;
            case 2:
                System.out.println("星期二");
                //break;
            case 3:
                System.out.println("星期三");
                //break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                //break;
        }

输出结果：

switch穿透适用场景举例：

//适用场景：一三五学Java，二四六学html，周末休息
        Scanner input =new Scanner(System.in);
        System.out.println("请输入今天星期几");
        int day=input.nextInt();
        switch (day){
            case 1:
            case 3:
            case 5:
                System.out.println("学Java");
                break;
            case 2:
            case 4:
            case 6:
                System.out.println("学html");
                break;
            default:
                System.out.println("休息");
                break;
        }

3.判断条件里的比较

==     比较的是内存中的地址，通常用来比较数值型

equals()  比较的是内容，通常用来比较字符串

 if(!name.equals("admin")){
            System.out.println("用户名不正确");
}