三 . 运算符和流程控制——Java基础篇-CSDN博客

本文链接：https://blog.csdn.net/wkt1105436760/article/details/136285423

三 . 运算符和流程控制

1. 运算符

1 . 赋值运算符

1.2.1 基本语法

符号：=
- 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
- 支持连续赋值。

扩展赋值运算符： +=、 -=、*=、 /=、%=

赋值运算符	符号解释
`+=`	将符号`左边的值`和`右边的值`进行`相加`操作，最后将结果`赋值给左边的变量`
`-=`	将符号`左边的值`和`右边的值`进行`相减`操作，最后将结果`赋值给左边的变量`
`*=`	将符号`左边的值`和`右边的值`进行`相乘`操作，最后将结果`赋值给左边的变量`
`/=`	将符号`左边的值`和`右边的值`进行`相除`操作，最后将结果`赋值给左边的变量`
`%=`	将符号`左边的值`和`右边的值`进行`取余`操作，最后将结果`赋值给左边的变量`

注意：赋值运算符不会更改原有的数据类型

public class OperatorTest1 {
    public static void main(String[] args) {
        char c='a';
        c-=32;//省去了强转数据类型的步骤
        System.out.println("c = " + c);
//        char c='a';
//
//        int result=c-32;
//        System.out.println("result = " + result);
//        //将数字转为字符
//        char temp=(char)result;
//        System.out.println("temp = " + temp);
        /*
        a:97
        A:65

        */
        System.out.println("------------------------");
        int m = 10;
        System.out.println("m = " + m);

        m+=30;//m = m + 30;

        System.out.println("m = " + m);
        m*=10;//m=m*10

        System.out.println("m = " + m);
        int n=30;
        n%=7;   //n=n=n%7;

        System.out.println("n = " + n);
    }
}

2 . 比较运算符

在这里插入图片描述

比较运算符的结果都是boolean型，也就是要么是true，要么是false。

> < >= <= ：只适用于基本数据类型（除boolean类型之外）

== != ：适用于基本数据类型和引用数据类型

class CompareTest {
	public static void main(String[] args) {
		int i1 = 10;
		int i2 = 20;
		

		System.out.println(i1 == i2);//false
		System.out.println(i1 != i2);//true
		System.out.println(i1 >= i2);//false


		int m = 10;
		int n = 20;
		System.out.println(m == n);//false
		System.out.println(m = n);//20
	
		boolean b1 = false;
		boolean b2 = true;
		System.out.println(b1 == b2);//false
		System.out.println(b1 = b2);//true
	}

}

3 . 逻辑运算符

在这里插入图片描述

逻辑运算符，操作的都是boolean类型的变量或常量，而且运算得结果也是boolean类型的值。

运算符说明：
- & 和 &&：“且”，true=true--------true 两边布尔值都是true时，结果才能为true。否则，为false。
- | 和 || ：“或”，true=flase或者false=true-------true false=fasle------false 当符号两边布尔值有一边为true时，结果为true。当两边都为false时，结果为false
- ! ：“非”，当变量布尔值为true时，结果为false。当变量布尔值为false时，结果为true。
- ^ ：当符号左右两边布尔值不同时，结果为true。当两边布尔值相同时，结果为false。
  - 理解：异或，追求的是“异”！
区分“&”和“&&”：
- 相同点：如果符号左边是true，则二者都执行符号右边的操作
- 不同点：& ：如果符号左边是false,则继续执行符号右边的操作
&& ：如果符号左边是false,则不再继续执行符号右边的操作
- 建议：开发中，推荐使用 &&
区分“|”和“||”：
- 相同点：如果符号左边是false，则二者都执行符号右边的操作
- 不同点：| ：如果符号左边是true，则继续执行符号右边的操作
  
  || ：如果符号左边是true，则不再继续执行符号右边的操作

逻辑运算符：
    &:与：所有的表达式都是true，结果才是true，能false就false

    |:或：所有的表达式都是flase，结果才是false,能true就true

    ^:异或：相同为false，不同为true

    !:非：取反
    ----
    &&:短路与：前面的表达式为true，则不再计算后面的表达式

    ||:短路或：前面的表达式为false，则不再计算后面的表达式

    注意:
    1、&|^是逻辑运算符时 两边表达式时boolean布尔类型 则逻辑
    2、&|^是逻辑运算符时 两边表达式时int数字 则位

 */
class OperatorTest_2{
    public static void main(String[] args) {
        boolean t1 = true, t2 = true;
        boolean f1 = false, f2 = false;
        System.out.println("-----             --||---            -----");
        System.out.println(f1 || f2 || f1 || f2 || t1);   //true
        System.out.println(f1 || f2 || f1 || f2); //false

        int a=10;
        int b=20;
        //boolean result=b>a | ++a>b;  //result = true,a=11
        boolean result=b>a || ++a>b;  //result = true,a=10
        System.out.println("result = " + result+",a="+a);

        System.out.println("---------------------&&------------------");

        System.out.println(t1 && t2 && t1 && f1);  //false
        System.out.println(t1 && t2 && t1 && t2);  //true

        int m=66;
        int n=99;
       // result=m>n & ++m<n;  //result = false,m=67
        result=m>n && ++m<n;  //result = false,m=66
        System.out.println("result = " + result+",m="+m);

    }
}
public class OperatorTest4 {
    public static void main(String[] args) {
        boolean t1 = true, t2 = true;
        boolean f1 = false, f2 = false;

        System.out.println("-------！--------");
        System.out.println(!t1);//false
        System.out.println(!f1);//true

        System.out.println("-------^--------");
        System.out.println(f1^t1);//true
        System.out.println(f1^f1);//false
        System.out.println(t2^t2);//false
        System.out.println(t2^f2);//ture

        System.out.println("-------|--------");
        System.out.println(f1 | f2 | f1 | f2 | t1);   //true
        System.out.println(f1 | f2 | f1 | f2); //false

        System.out.println("-------&--------");
        //结果都是true是结果才是true，只要有一个是false，结果就是false
        System.out.println(t1 & t2 & t1 & f1);  //false
        System.out.println(t1 & t2 & t1 & t2);  //true

    }
}

4 . 位运算

在这里插入图片描述

位运算符的运算过程都是基于二进制的补码运算

（1）左移：<<

运算规则：在一定范围内，数据每向左移动一位，相当于原数据*2。（正数、负数都适用）

【注意】当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位

3<<4  类似于  3*2的4次幂 => 3*16 => 48

在这里插入图片描述

-3<<4  类似于  -3*2的4次幂 => -3*16 => -48

在这里插入图片描述

（2）右移：>>

运算规则：在一定范围内，数据每向右移动一位，相当于原数据/2。（正数、负数都适用）

【注意】如果不能整除，向下取整。

69>>4  类似于  69/2的4次 = 69/16 =4

在这里插入图片描述

-69>>4  类似于  -69/2的4次 = -69/16 = -5

在这里插入图片描述

（3）无符号右移：>>>

运算规则：往右移动后，左边空出来的位直接补0。（正数、负数都适用）

69>>>4  类似于  69/2的4次 = 69/16 =4

在这里插入图片描述

-69>>>4   结果：268435451

在这里插入图片描述

（4）按位与：&

运算规则：对应位都是1才为1，否则为0。

1 & 1 结果为1
1 & 0 结果为0
0 & 1 结果为0
0 & 0 结果为0

9 & 7 = 1

在这里插入图片描述

-9 & 7 = 7

在这里插入图片描述

（5）按位或：|

运算规则：对应位只要有1即为1，否则为0。

1 | 1 结果为1
1 | 0 结果为1
0 | 1 结果为1
0 & 0 结果为0

9 | 7  //结果： 15

在这里插入图片描述

-9 | 7 //结果： -9

在这里插入图片描述

（6）按位异或：^

运算规则：对应位一个为1一个为0，才为1，否则为0。

1 ^ 1 结果为0
1 ^ 0 结果为1
0 ^ 1 结果为1
0 ^ 0 结果为0

9 ^ 7  //结果为14

在这里插入图片描述

-9 ^ 7 //结果为-16

在这里插入图片描述

（7）按位取反：~

运算规则：对应位为1，则结果为0；对应位为0，则结果为1。

~0就是1
~1就是0

~9  //结果：-10

在这里插入图片描述

~-9  //结果：8

在这里插入图片描述

/*
位运算符（按照二进制进行运算）：
    &:与
    |：或
    ^：异或
    ~：取反
    <<：左移
    >>：右移
    >>>：无符号右移
        无论是正数还是负数，移动后最高位都补0
        一个更小的负数移动后会变为一个更大的正数

十进制转二进制：0B开头+十进制，
System.out.println(0B0000000000000000000000000000000000001000);
 */
public class OperatorTest3 {
    public static void main(String[] args) {

        System.out.println("----------无符号右移>>>-----------");
        /*
        0000 0000 0000 0000 0000 0000 0000 0000 0000 1000|
         0000 0000 0000 0000 0000 0000 0000 0000 0000 100|0   //4
          0000 0000 0000 0000 0000 0000 0000 0000 0000 10|00    //2
        */
        System.out.println(0B0000000000000000000000000000000000001000);
        System.out.println(8>>>1);
        System.out.println(8>>>2);
        System.out.println(-8>>>1);
        System.out.println("----------右移>>-----------");
        /*
        10000
         1000   //8
          100   //4
    
        */
        System.out.println(16>>1);
        System.out.println(16>>2);
        System.out.println("----------<<-----------");
        /*
        100
       1000  //8
      10000  //16
      注意：左移一位乘以2，就是向左移一位，后面补0
        */
        System.out.println(4 << 1);
        System.out.println(4<<2);
        System.out.println("----------&|~^------------");
        System.out.println(5 & 3);//1
            /*
            1 0 1
            0 1 1
         &  //上下都为1，才是1
         ---------------
            0 0 1
    
        System.out.println(5 | 3);//1
                    /*
            1 0 1
            0 1 1
         |  //上下有1，才是1
         ---------------
            1 1 1
            */
        System.out.println(5 ^ 3);//1
        /*
            1 0 1
            0 1 1
         ^  //不同为1，相同为0
         ---------------
            1 1 0
            */
        System.out.println(~5);//-6
        /*
           0000 0101
     ~ 取反 1111 1010
       补码 1111 1010
       反码 1111 1001          反码+1才是补码
       原码 1000 0110          源码最高位不变，其余1变0，0变1
         */
    
    }

}

5 . 条件运算符

条件运算符格式：

(条件表达式)? 表达式1:表达式2

说明：条件表达式是boolean类型的结果，根据boolean的值选择表达式1或表达式2

在这里插入图片描述

如果运算后的结果赋给新的变量，要求表达式1和表达式2为同种或兼容的类型

/*
 条件运算符/三目运算符/三元运算符：
            X?Y:Z;
 X:true-->Y
 X:false-->Z
 */
public class OperatorTest5 {
    public static void main(String[] args) {
        //定义年龄
        int age=19;
        String result=age>18?"成年了":"未成年";
        System.out.println("result = " + result);

        //定义一个整数
        int num=19;
        String result2 = 19 % 2 == 0 ? "时偶数" : "不是整数";
        System.out.println("result2 = " + result2);

        int m=10;
        int n=20;
        int result3 = m > n ? m : n;
        System.out.println("result3 = " + result3);

        /*
        定义三个数字，求最大值，要求一行三目

         */
        int a = 20, b = 300, c = 60;
        int MaxNum3 = a > b ? (a > c ? a : c) : (b > c ? b : c);
        System.out.println("MaxNum3 = " + MaxNum3);

//        //1、获取前两个数中的最大值
//        int tempMaxNum = a > b ? a : b;
//        //2、最大值与第三个数进行比较
//        int MaxNum2 = tempMaxNum > c ? tempMaxNum : c;
//        System.out.println("MaxNum2 = " + MaxNum2);
    }
}

2. Scanner：键盘输入功能的实现

键盘输入：Scanner
 一、基本操作：
    1、创建键盘输入的对象
        in:对象名 是可以改变的
        Scanner in=new Scanner(System.in);
    2、提供提示语句（可选）
    3、对象调用的方法接收数据
        in.nextInt();
    4、展示数据
    5、关闭资源
        in.nextInt();

二、键盘输入获取其他基本数据类型的值
    nextByte()
    nextShart()
    nextInt()
    nextLong()
    nextFloat()
    nextDouble()
    nextBoolean()
 注意：
    1、如果输入的类型不满足要求，输入异常，会显示inputMismatchExceltion
    2、键盘输入不存在nextChar（）。。
        通过字符串中的charAt(index)获取char值

三、键盘输入获取字符串数据
    next()：只能接收空格之前的数据
    nextLine()：可以接受一整行数据，若是要输入多行数据，得使用in.nextLine()进行过渡

class OperatorTest7_4{
    public static void main(String[] args) {
        //1、创建对象
        Scanner in=new Scanner(System.in);
        //2、提示语句
        System.out.println("请您输入一句话：");
        //3、对象调用方法来接受数据
        String message=in.nextLine();
        //4、展示数据
        System.out.println("message = " + message);
        //5、关闭资源
        in.close();
    }
}
class OperatorTest7_3{
    public static void main(String[] args) {
        //1、创建对象
        Scanner in=new Scanner(System.in);
        //2、提示语句
        System.out.println("请您输入一句话：");
        //3、对象调用方法来接受数据
        String message=in.next();
        //4、展示数据
        System.out.println("message = " + message);
        //5、关闭资源
        in.close();
    }
}
class OperatorTest7_2{
    public static void main(String[] args) {
        //通过字符串中的charAt(index)获取char值
        String s="ABCDE";
        char ele =s.charAt(2);
        System.out.println("ele = " + ele);

        //1、创建输入对象
        Scanner in=new Scanner(System.in);
        //2、提示语句
        System.out.println("请您输入一个名字：");
        //3、接受数据
        String name = in.next();
        //4、获取名字得第一个字符
        char c = name.charAt(0);

       // char c2 = in.next().charAt(0);
        //5、展示数据
        System.out.println("c = " + c);
        //6、关闭资源
        in.close();
    }
}
class OperatorTest7_1{
    public static void main(String[] args) {
        //1、创建键盘输入对象
        Scanner input=new Scanner(System.in);
        //2、接受并展示一个long值
        System.out.println("请您输入一个long值");
        long l = input.nextLong();
        System.out.println("l = " + l);
        //3、接受并展示一个dluble值
        System.out.println("请您输入一个double值");
        double d = input.nextDouble();
        System.out.println("d = " + d);
        //4、接受并展示一个boolean值
        System.out.println("请您输入一个boolean值");
        boolean b =  input.nextBoolean();
        System.out.println("b = " + b);
        //5、接受并展示一个char值

        //6、关闭资源
        input.close();

    }

}
public class OperatorTest7 {
    public static void main(String[] args) {
//        1、创建键盘输入的对象
        Scanner in=new Scanner(System.in);
//        2、提供提示语句
        System.out.println("请您输入年龄：");
//        3、对象调用的方法接收数据
        int age=in.nextInt();
//        4、展示数据
        System.out.println("age = " + age);
//        5、关闭资源
        in.close();
    }
}

Math.random()会获取随机数[0,1)

[m,n]之间的随机数就用这个公式
(int)(Math.random()*(n-m+1)+m);

public class ScannerExer2 {
    public static void main(String[] args) {
        double random = Math.random();
        System.out.println("random = " + random);
        for(int i=1;i<=50;i++){
            int num=(int)(Math.random()*(44-22+1)+22);

            System.out.println(i+"-->" + num);

        }
    }
}

3 .程序执行结构 ( 单\双—if )

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。

程序得执行结构：
    顺序结构
    分支结构
    循环结构

分支结构：
    1. if分支
        1.1 if单分支
            if(布尔类型的表达式){
                分支内容
                }
        1.2 if双分支
        1.3 if多分支

 注意：//使用if时若是没有括号，是对靠近它的一条语句有作用
 后++：先运算再+1.
 前++：先+1再运算。
 使用if时若是没有括号，是对靠近它的第一条语句有作用

在这里插入图片描述

class IfExer{
    public static void main(String[] args) {
        int x=1;
        int y =1;
        if(x++==2 & ++y==2){
            //x++就是x先运算与2比较，结果不等于，所以是false；++y就是先+1再运算，x原本=1，再+1=2，与2进行比较，所以是true
            //false & ture结果是（&能false就false）false
            x=7;
        }
        System.out.println("x = " + x+",y = " + y);
    }
}


class IfText_3{
    public static void main(String[] args) {
        boolean b=false;
        if(b=true){
            System.out.println("AAAAA");
        }
        System.out.println("GameOver");
        boolean flag=true;
        if(flag){
            System.out.println("888888");
        }
        System.out.println("GameOver");
    }
}
class IfText_2{
    public static void main(String[] args) {
        int num=2;
        if(num>10)
            //使用if时若是没有括号，是对靠近它的第一条语句有作用
            System.out.println("AAAAA");
            System.out.println("BBBBB");
            System.out.println("CXCCC");
            System.out.println("DDDDD");
            System.out.println("GameOver");
    }

}
public class IfText1 {
    public static void main(String[] args) {
        int age=20;
        if(age>=18){
            System.out.println("成年了");
        }
        System.out.println("GameOver");
    }
}

-----闰年判断练习

class IfText2_4{
    public static void main(String[] args) {
        //简单的if双分支可以使用三目运算符代替,与IfText2对应
        int age=45;
        String s=age>=30?"上年纪了":"还年轻";
        System.out.println(age+s);

        int num=19;
        String s1=num%2!=0?"是奇数":"不是奇数";
        System.out.println(num+s1);

        int year=2001;
        String s2 = year % 400 == 0 || year % 100 != 0 ? "是闰年" : "不是闰年";
        System.out.println(year+s2);

    }
}
class IfText2_3{
    public static void main(String[] args) {
        /*
        判断闰年：
        1、能被400整除
        2、能被4整除，不能被100整除
         */
        int year=2000;
        if(year%400==0 || year%4==0 && year%100!=0){
            System.out.println("是闰年");
        }else{
            System.out.println("不是闰年");
        }
        System.out.println("GameOver");
    }
}
class IfText2_2{
    public static void main(String[] args) {
        int num=19;
        String message="";
        if(num%2!=0){
            message="是奇数";
          //  System.out.println(num+"是奇数");
        }else{
            message="不是奇数";
          //  System.out.println(num+"不是奇数");
        }
        System.out.println(num+message);
    }

}
public class IfText2 {
    public static void main(String[] args) {
        //1、创建键盘输入对象
        Scanner in = new Scanner(System.in);
        //2、提示
        System.out.println("请您输入年龄：");
        //3、接受
        int age = in.nextInt();
        //4、对数据进行校验
        if(age>=30){
            System.out.println("上年纪了！");
        }else{
            System.out.println("你还年轻！");
        }
        //5、关闭资源
        in.close();
    }
}

4 . if多分支

if 多分支
if(布尔表达式1){
内容1
}else if(布尔表达式2){
内容2
}else{
内容3
}

    /*
    如果x>=3, 则y=2*x
    如果x在[-1,3), 则y=3*x+1
    如果x<-1, 则y=2*x
     */
public class ifText3 {
    public static void main(String[] args) {

        int x=2;
        if(x>=3){
            System.out.println("y="+2*x);
        }else if(x>=-1 && x<3){
            System.out.println("y="+(3*x+1));
        }else if(x<-1){
            System.out.println("y="+4*x);
        }
    }
}

/*
1.键盘输入一个分数判断分数的等级
    90~100    A
    80~89     B
    70~79     C
    60~69     D
    <60       E
    希望使用一条输出语句展示结果

    99   A
    56   E

2.
    大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件：高：180cm以上；富：财富1千万以上；帅：是。
    如果这三个条件同时满足，则：“我一定要嫁给他!!!”
    如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”
    如果三个条件都不满足，则：“不嫁！”

 */
class IfIfIfExer3{
    public static void main(String[] args) {
        //1.创建键盘输入对象
        Scanner in = new Scanner(System.in);
        //2.接收成绩
        System.out.println("请您输入成绩");
        int score = in.nextInt();
        //todo 定义变量记录分数等级
        String level = "";

        if (score >= 90 ) {
            level = "A";
        } else if (score >= 80 ) {
            level = "B";
        } else if (score >= 70) {
            level = "C";
        } else if (score >= 60 ) {
            level = "D";
        } else {
            level = "E";
        }
        //4.输出结果
        System.out.println(score + " 等级是 " + level);

        //5.关闭资源
        in.close();
    }
}
class IfIfIfExer2 {

    public static void main(String[] args) {
        //1.创建键盘输入对象
        Scanner in = new Scanner(System.in);
        //2.接收成绩
        System.out.println("请您输入成绩");
        int score = in.nextInt();
        //todo 定义变量记录分数等级
        String level = "";
        //todo 对成绩进行安全校验 满足[0,100]
        if(score>=0 && score<=100){
            if(score>=90 && score<=100){
                level="A";
            }else if(score>=80 && score<90){
                level = "B";
            }else if(score>=70 && score<=79){
                level = "C";
            }else if(score>=60 && score<=69){
                level = "D";
            }else{
                level = "E";
            }
            //4.输出结果
            System.out.println(score+" 等级是 "+ level);
        }else{
            System.out.println("您的成绩输入有误");
        }

        //5.关闭资源
        in.close();

    }
}

public class IfIfIfExer {

    public static void main(String[] args) {
    
        //1.创建键盘输入对象
        Scanner in = new Scanner(System.in);
        //2.获取身高信息
        System.out.println("请输入您的身高");
        double height = in.nextDouble();
        //3.获取财富信息
        System.out.println("去输入财富");
        int money = in.nextInt();
        //4.是否帅的信息
        System.out.println("是不是很帅");
        boolean handSome = in.nextBoolean();
        //5.对各种条件进行校验
    
        if(height>1.8 && money>10000000&& handSome==true){
            System.out.println("我一定要嫁给他!!!");
        }else if(height>180 || money>10000000|| handSome){
            System.out.println("嫁吧，比上不足，比下有余");
        }else{
            System.out.println("不嫁");
        }
        //7.关闭资源
     in.close();
    }
}