D05运算符和分支结构

最新推荐文章于 2024-10-10 15:36:50 发布

善良的人永远最美

最新推荐文章于 2024-10-10 15:36:50 发布

阅读量212

点赞数

文章标签：蓝桥杯 java elementui

本文链接：https://blog.csdn.net/m0_65387966/article/details/122279656

版权

运算符和分支结构

1.运算符

1.1关系运算符

> <  >=  <=  ==  ！=
关系运算符的结果有且只有  true or false
用于在开发中的条件判断使用

    public static void main(String[] args){
    boolean ret = 10 > 5;
    System.out.println(ret);//结果为true
    
    //ret = 5 > 5;  结果为false
    
    ret = 5 >= 5; 
    System.out.println(ret);//结果为true
    
    ret = 10 < 5;
    System.out.println(ret);//结果为false
    
    ret = 10 <= 5;
    System.out.println(ret);//结果为false
    
    ret = 10 == 5;
    System.out.println(ret);//结果为false
    
    ret = 10 != 5; 
    System.out.println(ret);//结果为true
    }
}

1.2逻辑运算符

&&
    与，并且
    同真为真，有假【即】假
||
    或，或者
    有真【即】真，同假为假
！
    非，取反
    强牛，犟，假变真，真变假
逻辑运算符：
    一遍用于组合条件的判断，条件过滤，多情况分析。
短路原则：

    public static void main(String[] args){
        boolean ret = 5 > 3 && 10 >8;
        
        //结果为true
        System.out.println(ret);
        
        ret = 5 > 10 || 10 >8;
        
        //结果为true
        System.out.println(ret);
        
        ret = 5 > 10 || 10 >20;
        
        //结果为false
        System.out.println(ret);
        
        ret = !(10 > 5);
        
        //结果为false
        System.out.println(ret);

【补充知识点：逻辑运算符短路（断路原则）问题】

public class Demo4 {
    public static void main(String[] args) {
        /*
        int num = 10;
        boolean ret = 10 >5 && num++ > 10;
        
        System.out.pringtln("num : " + num); //11
        System.out.pringtln(“ret ：“ + ret); //false
        */
        
        int num = 10;
        boolean ret = 10 >15 && num++ >= 10;
        /*
        短路原则问题：
            逻辑与短路（断路）元素问题
            10 > 15 该表达式结果为false，已经决定了当前整个
            逻辑与表达式的结果为false，计算机为了提高效率，
            从逻辑与false条件开始，之后的表达式不再运行
        */
        System.out.println("num : " + num); //10
        System.out.println("ret ：" + ret); //false
        
        
        int num1 = 10;
        boolean ret1 = 10 > 5 || ++num1 >5;
        /*
        短路原则问题：
            逻辑或断路原则问题
            在逻辑或表达式中，出现了第一个为true条件，整个
            表达式结果已经为明确true，不需要再进行之后的判
            断，节约计算机资源，提高效率
        */
        System.out.println("num1: " +num1);//10
        System.out.println("ret1 : " + ret1);//ture
    }
}

1.3自增自减运算符

【注意事项】
    1.自增自减运算符有且只能操作变量！！！
    2.建议，自增自减运算符独立存在！单独成行，减少代码中的歧义！！！
    3.【个人建议】
        使用 += 1 和 -= 1 替代自增自减运算符
        Swift取消了 自增自减运算符
+ + :
     在变量之后，首先执行变量所在行语句，再执行自增1操作
     在变量之前，首先执行变量自增1操作，再执行所在行语句
- - :
     在变量之后，首先执行变量所在行语句，再执行自减1操作
     再变量之前，首先执行变量所在行语句没在执行自减1操作

public class Demo3 {
    public static void main(String[] args) {
        
        int num = 10;
        
        //先执行完该行语句后，num++会执行自增1操作
        System.out.println("num++ : " + num++); //10
        
        /*自增运算符单独存在展示
        System.out.println("num++ : " + num);   
        num++;    10  */
        
        System.out.println("num : " + num);   // 11   
        
        //到这里num值已经由10自增1为11，先执行自增操11+1==12后
        //再执行该行语句结果为12
        System.out.println("num++ : " + ++num); //12
        
        //上行语句num执行完后为12，该行结果为12
        System.out.println("num : " + num);   // 12
    }
}

2.从键盘上获取用户录入的数据（控制台输入）(CV大法)

*程序运行中，可在控制台（终端）手动录入数据，再让程序继续运行。

*导包语法：import 包名，类名；//将外部class文件功能引入到自身文件中。

*使用顺序：

1.导入 java.util.Scanner。导包，点技能点

2.声明 Scanner 类型的变量。 Scanner ：扫描器

3.使用Scanner 类中对应的函数（区分类型）：

.nextInt(); //获得整数

.nextDouble(); //获取小数

.next(); //获取字符串

.next().charAt(0); //获取单个字符

注：如果输入了不匹配的数据，则会产生java.util.InputMisamatchException

1.导包，点技能点
  import java.util.Scanner;
  class Demo1 {}
  
2.获取Scanner的变量，扫描器的一个变量
  Scanner sc = new Scanner(System.in);   System.in输入，标准录入模式（键盘）
  
3.使用Scanner其中的方法
  获取int类型数据  sc.nextInt();  
  获取double类型数据 sc.nextDouble();             //float
  获取String类型字符串数据 sc.next();sc.nextLine();
  获取一个char类型字符数据  sc.next().charAt(0);
                        sc.nextLine().charAt(0);

//导包，让当前代码拥有可以使用Scanner的能力
import java.util.Scanner;

public class Demo5 {
    public static void main(String[] args) {
        
        /*int num = 0;
        Scanner sc = new Scanner(System.in);
        
        System.out.println("请输入一个整数");
        num = sc.nextInt();
        
        System.out.println("num : " + num);
        */
        char ch = '\0';//空字符
        Scanner sc = new Scanner(System.in);
        
        System.out.println("请输入一个字符：");
        ch = sc.nextLine().charAt(0);
        
        System.out.println("ch: " + ch);
        
    }
}

3.选择结构和分支结构

概念：根据已知条件进行逻辑判断，满足条件后执行相应操作。

3.1 if 分支结构

 if (/*布尔类型的表达式 true or false*/) {
     //语句体
 }
 // 后续代码

/*
执行流程
    首先判断布尔类型的表达式 true 还是 false
    true 执行语句体
    false 执行后续代码
*/
展示:
class Demo6 {
    public static void main(String[] args) {
        //true执行语句体 | false执行后续语句
        boolean flag = false;
        
        if (flag) {
        System.out.println("天王盖地虎，小鸡炖蘑菇");
        }
        
        System.out.println("后续代码....");
    }
}

3.2 if - else分支结构

 if(/*布尔类型的表达式 true or false */){
     //true 语句体
     else{
        //false语句体 
     }
 }
 /*
 执行流程：
    首先判断if之后小括号里面的布尔类型数据到底是什么
    如果为ture,执行ture语句体
    如果为false，执行false语句体
    
    世界上最遥远的距离是，我在if里，你在else里
 */
展示：
class Demo7 {
    public static void main(String[] args) {
        boolean flag = false;
        
        if (flag) {
            System.out.println("我在if里等你");
        } else {
            System.out.println("你可等着把，这辈子遇不到~~~");  
        }
        
        System.out.println("后续代码...");
    }
}

3.3 if - else if 分支结构

/*
学生的成绩划分：
    >= 90 优秀
    >= 80 良好
    >= 70 中等
    >= 60 及格
    < 60 不及格
*/

 if (/*布尔条件1*/) {
     //处理方式1
 } else if (/*布尔条件2*/) {
     //处理方式2
 } else if (/*布尔条件3*/) {
     //处理方式3
 } else {
     //无匹配项处理方式
 }
/*
执行流程：
    使用已有条件匹配if之后的布尔条件
    匹配到任何一个布尔条件，指定对应的处理结果，结束 if - else if 结构，执行后续代码
    如果没有任何一个条件匹配，执行else里面语句，然后在执行后续代码
    
注意：
    else可以省略，按照自己的业务逻辑需要考虑是否省略else选择，else可以处理用户在输入过程中超出else if选择的一些特殊情况
*/
展示：
//导包
import java.util.Scanner;

class Demo8 {
    public static void main (String[] args) {
        int score = 0;
        //Scanner扫描器变量
        Scanner sc = new Scanner(System.in);
        
        System.out.println("请输入学生的成绩");
        score = sc.nextInt();
        
        //用户输入数据合法性判断问题
        if (score < 0 || score >100 ) {
            System.out.println("亲，您输入的数据不对哦~~~秋咪~~~");
            //程序退出
            System.exit(0);
        }
        
        //if - else if
        if (score >=90){
            System.out.println("秀儿");   
        } else if (score >=80) {
            System.out.println("良儿");
        } else if (score >= 70) {
            System.out.println("中儿");
        } else if (score >= 60) {
            System.out.println("过儿");
        } else {
            System.out.println("让你爹带着拖鞋来学校一趟");
        }
        
    }
}

【补充知识点：用于输入数据的合法性判断问题】

在实际开发中，存在生活中数据的合法性和程序运行的语法要求冲突问题。
在程序运行的过程中，我们需要用户输入的数据进行合法性判断，如果用户输入的数据不是合法范围以内的，需要给与用户提示，并且不可以进入正常的代码运行过程中。
学生的成绩0~100，超出0~100都是不合法的！！！
1.不能大于100   score > 100
2.不能小于0     score < 0
3.满足任何条件都是非法情况！！！
    score > 100 || score  < 0
4.if判断

//导包
import java.util.Scanner;

class Demo8 {
    public static void main (String[] args) {
        int score = 0;
        //Scanner扫描器变量
        Scanner sc = new Scanner(System.in);
        
        System.out.println("请输入学生的成绩");
        score = sc.nextInt();
        
        //用户输入数据合法性判断问题
        if (score < 0 || score >100 ) {
            System.out.println("亲，您输入的数据不对哦~~~秋咪~~~");
            //程序退出
            System.exit(0);
        }
        
        //if - else if
        if (score >=90){
            System.out.println("秀儿");   
        } else if (score >=80) {
            System.out.println("良儿");
        } else if (score >= 70) {
            System.out.println("中儿");
        } else if (score >= 60) {
            System.out.println("过儿");
        } else {
            System.out.println("让你爹带着拖鞋来学校一趟");
        }
        
    }
}

3.4 switch - case 结构

 switch (/*变量|表达式*/) {
         case 值1：
         //处理方式1；
            break;
         case 值2：
         //处理方式2；
             break;
        default:
         //最终处理方式
            break;                  
 }
/*
执行流程：
    去除switch小括号里面的数据匹配对应的case选择
    如果存在case匹配，执行对应的处理方式
    如果没有任何的一个case匹配，执行default处理方式
    
switch case 使用注意事项
    1.break 关键字作用是用于跳出对应的case选项
    2.break 省略之后，执行对应的case选择，会继续运行到下一个break或者大括号结尾终止switch - case运行
    3.在case选择中不允许出现相同的选择，语法错误！！！
    4.在switch case语句体中，能够执行的代码有且只能是case之后或者default之后的代码，其他代码都不可以执行；
    5.default可以省略，按照自己的业务逻辑需要考虑是否省略default选择，default可以处理用户在输入过程中超出case选择的一些特殊情况。
*/
展示：
import java.util.Scanner;
class Demo9 {
    public static void main(String[] args) {
        int choose = 0;
        Scanner sc = new Scanner(System.in);
        
        System.out.println("1.肥仔快乐水");
        System.out.println("2.浓郁咖啡摩卡");
        System.out.println("3.崂山白蛇草水");
        System.out.println("4.芬达");
        System.out.println("请输入您的选择");
        choose = sc.nextInt();
        
        switch (choose) {
            case 1:
                System.out.println("3RMB 肥仔快乐水");
                break;
            case 2:
                System.out.println("42RMB 浓郁咖啡摩卡”");
                break;
            case 3:
                System.out.println("30RMB 崂山白蛇草水");
                break;
            case 4:
                System.out.println("3RMB 芬达");
                break;
            default:
                System.out.println("臣妾做不到啊~~");
            break;
        }   
    }
}

3.5条件运算符/三目运算符

格式：
    条件判断 ?  ture处理方式 ：false处理方式；
条件运算符/三目运算符
    使用局限性大，类似于if - else结构。

展示：
class Demo10 {
    public static void main(String[] args) {
        //可以用于取巧，但是不建议多次使用，或者嵌套使用
        int num = 10 > 5 ? 888 : 666;
        
        //条件判断T为888，F为666
        System.out.println(num);
        
        /*类似于if - else 结构
        int num1 = 0;
        if (10 > 5) {
            num1 = 888;
        }else{
            num1 = 666;
        }
        System.out.println("num1");
        */
    }
}

3.6 分支结构嵌套

语法：

if (外层表达式) {
    if (内层表达式) {
        //内层代码块1
    } else {
        //内层代码块2
    }
} else {
    //外层代码块
}

执行流程：
    当外层条件满足是，再判断内层条件。
注意：
    *一个选择结构中，可嵌套另一个选择结构。
    *嵌套格式正确的情况下，支持任意组合

class Demo11 {
    public static void main(String[] args){
        int score = 100;
        if(score >= 90){
            if(score >= 95) {
                System.out.println("A+");   
            } else {
            System.out.println("A-");       
            }
        }else{
            System.out.println("A--");
        }
    }
}

4.局部变量

*概念：声明在函数内部的变量，必须先赋值再使用。
*作用范围：定义行开始到所在的代码块结束。
*注意：多个变量，在重合的作用范围内，不可出现重名（命名冲突）。

存在于代码块中的变量！！！
1.局部变量有且只能在所处的代码块中使用，超出当前代码块范围无效！！【作用域问题】
2.在作用域范围内，任何的地方可以直接使用对应的变量
3.在一个变量的作用域范围以内，不能重新定义同名变量，报错！
4.局部变量未赋值不能使用

课堂练习

1.完成条件：判断是不是闰年
    能被4整除，但是不能被100整除，或者可以被400整除
    a. year % 4 == 0;
    b. year % 4 != 0;
    c. year % 400 == 0;
    （year % 4 == 0 && year % 100 ！= 0） || year % 400 == 0
2.完成条件：判断一个字符是不是大写英文字符
    'A' <= ch <= 'Z'语法错误
    ch >= 'A' && ch <= 'Z'
3.完成条件：判断一个字符是不是英文字符
    a.英文字符中大写靠前，小写靠后
    b.大写和小写英文字符之间有其他字符
    (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')
    
4.使用if判断完成对应90后00后判断，用户输入年龄，判断情况

5.用户输入一个数值，判断是不偶数

6.用户输入自己的工资，判断是否需要缴税

class HomeWork4 {
    //使用if判断完成对应90后和00后判断，用户输入年龄，判断情况
    public static void main(String[] args){
        int age = 0;
        
        if (age >= 11 && age <= 20) {
            System.out.println("00后");
        } else if (age >= 21&& age <= 30){
            System.out.println("90后");
        } else {
            System.out.prlintln("老的算80后");
        }
    }
}

class HomeWork5 {
      //用户输入一个数值，判断是不是偶数
    public static void main(String[] args) {
        int num = 0;
        
        if(num % 2 == 0){
            System.out.println("偶数")
        }else{
            System.out.println("奇数");
        }
    }
}

class HomeWork6 {
    //用户输入自己的工资，判断是否需要缴税
    public static void main(String[] args) {
        double salary = 0.0;
        
        if (salary > 5000) {
            System.out.println("我为国家做贡献，我要养家，加油");
        } else {
            System.out.println("我不允许出现这种情况");
        }
    }
}

作业

1.代码三遍
2.笔记整理好
3.打字练习
4.分支结构练习题

//课题1~100相加

public class Demo17 {
    public static void main(String[] args) {
        int i = 0;
        int k = 0;
        
        for (int j = 1; j <= 100; j ++) {
            k += j;
            System.out.println(k);
        }
        
    }
}
//打印1~100之间既能被3整除，又能被5整除的数字

public class Demo13 {
    public static void main(String[] args) {
    
    int j = 0;
    
    for (int i = 1;i <= 100; i++) {
            if(i % 3 ==0 && i % 5 == 0) {
    //变量 j++ 为记录出现次数            
                j++;
                System.out.print(i + "\t");
            }
        }   
    System.out.println("共计出现次数：" + j);
    }
}

//用制表符 \t  打印 1~100
public class Demo12 {
    
    public static void main(String[] args) {
        
    
    for(int i = 99;i>0;i--) {
        
        System.out.print(i + "\t");
        }
    
    }
}

//while 循环打印1~100相加
public class Demo9 {
    public static void main(String[] args) {
        /*
        // 循环变量  i j k l m n
        int i = 10;
        while(i > 3) {
            
            //+ i 标识打印每次循环时的值数
            System.out.println("我想吃烤羊排" + i );
            
            // i -= 1；或者 i-- 每次循环后-1，条件为false是终止循环
            i-= 1 ;
        }
        */
        int i = 0;
        int num = 0;
        while (i <= 100) {
            num = num + i ;
        System.out.println("i结果为"+ i);
        System.out.println("num结果为"+ num);
            ++i;
        }
        System.out.println("1累加到10的和" + num);
    }
}


/**
*测试if-else if多分支结构
*随机生成年龄，根据不同年龄打印不同效果
*/
public class Demo8 {
    public static void main(String[] args) {
        int age = (int)(120*Math.random());
        
        System.out.println("年龄是：" + age);
        
        //15岁以下（不含15）：儿童；15~24：青年；25~44:中年；45~64：中老年；65~84：老年，85~99老寿星
        //100-109：百岁老人；110以上：申请国家记录；
        
        if (age < 14) {
            System.out.println("儿童：好好玩!");
        } else if (age < 25) {
            System.out.println("青年：努力学习,不然会被社会毒打");
        } else if (age < 45) {
            System.out.println("中年：成家立业");
        } else if (age < 65) {
            System.out.println("中老年：不服老！继续干~！");
        } else if (age < 85) {
            System.out.println("老年：好好休息！跳跳广场舞");
        } else if (age < 100) {
            System.out.println("老寿星，好好休息，看看广场舞~！");
        } else if (age < 110) {
            System.out.println("百岁老人，不容易，安心养老吧~~~！");
        } else {
            System.out.println("申请国家记录吧!!!太牛了！！！！");
        }
        
        
    }
}

//使用if else 做一个掷骰子游戏

public class Demo7 {
    public static void main(String[] args) {
        //调用(Math.random()*6)+1;随机生成0-5任意一个值，+1模拟骰子1~6数值；
        int first = (int)(Math.random()*6)+1;
        int second = (int)(Math.random()*6)+1;
        int third = (int)(Math.random()*6)+1;

        //打印第一，二，三次投掷结果
        System.out.println("第一次掷骰子：" + first);
        System.out.println("第二次次掷骰子：" + second);
        System.out.println("第三次掷骰子：" + third);
        
        /*  如果if结果为true，执行if语句块，程序结束，执行下行语句
        
            如果if为false，执行 else if布尔式结果为ture执行
            else if语句块，程序结束，执行下行语句；如果结果为false，执行
            else语句块，程序结束，执行下行语句
            
        */
        if (count > 15) {
            System.out.println("今天手气不错");
        } else if (count >= 10) {
            System.out.println("今天手气一般，再来两把！！");
        } else {
            System.out.println("手气不行！回家吧！！！");
        }
        System.out.println("今天得分:" + count);
    }
}


//测试if else双分支结构

public class Demo6 {
    public static void main(String[] args) {
        
        /*  r 为圆半径，aeea为圆面积，circle为圆周长
            调用Math.random()随机生成一个函数，* 4 结果赋值为半径值
            圆面积 = 3.14 * 半径*半径（半径的平方）’
            圆周长 = 2 * 3.14 * 半径
            
        */
        double r = 4 * Math.random();
        double area = 3.14 * r * r;
        double circle = 2 * 3.14 * r;
        
        //打印半径，面积，周长
        System.out.println("半径:" + r);
        System.out.println("面积:" +area );
        System.out.println("周长:" + circle);
        
        /*调用if else双分支结构，根据if (area >= circle)比较
        “面积数的数值和周长数值“；
        
        如果结果为true，则执行if语句
        （System.out.println("面积的数值大于等于周长")，
        
        如果结果为false，则执行else语句，
        System.out.println("面积的数值小于周长！");
        */
        if (area >= circle) {
            System.out.println("面积的数值大于等于周长");
        } else {
            System.out.println("面积的数值小于周长！");
        }
        
    }
}