D05运算符和分支结构

D05运算符和分支结构 运算符和分支结构 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 >15 && num++ >= 10;
        
        System.out.println("num : " + num); //10
        System.out.println("ret ：" + ret); //false
        
        
        int num1 = 10;
        boolean ret1 = 10 > 5 || ++num1 >5;
        
        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);   // 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) {
        
        
        char ch = '';//空字符
        Scanner sc = new Scanner(System.in);
        
        System.out.println("请输入一个字符：");
        ch = sc.nextLine().charAt(0);
        
        System.out.println("ch: " + ch);
        
    }
}

3.选择结构和分支结构

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

3.1 if 分支结构

 if () {
     //语句体
 }
 // 后续代码
​

展示:
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 语句体
     else{
        //false语句体 
     }
 }
 
展示：
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 分支结构

​
 if () {
     //处理方式1
 } else if () {
     //处理方式2
 } else if () {
     //处理方式3
 } else {
     //无匹配项处理方式
 }

展示：
//导包
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;                  
 }

展示：
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);
        
        
    }
}

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) {
        
        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);
    }
}
​
​

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 (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) {
        
        
        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 (area >= circle) {
            System.out.println("面积的数值大于等于周长");
        } else {
            System.out.println("面积的数值小于周长！");
        }
        
    }
}
​
​