1.Scanner类

💡 Scanner类属于引用数据类型 与定义基本数据类型变量不同，引用数据类型的变量定义及赋值有一个相对固定的步骤或格式。

  1. 数据类型  变量名  =  new 数据类型();
  2. //每种引用数据类型都有其功能

Scanner类可以完成用户键盘录入，获取到录入的数据。

  1. //Scanner使用步骤：
  2. //1.导包
  3.     import java.util.Scanner;
  4. //2.创建对象实例
  5.     Scanner sc = new Scanner(System.in);
  1. //用来接收控制台录入的数字
  2.     int  i = sc.nextInt(); 
  3. //用来接收控制台录入的字符串
  4.     String s = sc.next();
  1.     public static void main(String[] args) {
  2.         //Scanner 键盘录入
  3.         Scanner input = new Scanner(System.in);
  4.         System.out.println("请输入想要加密的数字：");
  5.         //通过input获取到键盘录入的数值并且赋值给num
  6.         int num = input.nextInt();
  7.         //加密运算赋值给jg
  8.         int jg = (num*10)/2+(int)3.1415926;
  9.         //输出结果
  10.         System.out.println("加密的结果" + jg);
  11.         //取消警号 关闭键盘录入的内存
  12.         input.close();
  13.     }

2.Random随机数类

💡 用来产生随机数的类Random，它也属于引用数据类型。 这个Random类，它可以产生多种数据类型的随机数，在这里主要介绍生成整数与小数的方式。

  1. //Scanner使用步骤：
  2. //1.导包
  3.     java.util.Random 
  4. //2.创建对象实例
  5.     Random 变量名 = new Random();
  1.     public static void main(String[] args) {
  2.         // 创建Random类的实例
  3.         Random r = new Random();
  4.         // 得到0-100范围内的随机整数，将产生的随机整数赋值给i变量
  5.         int i = r.nextInt(100);
  6.         // 得到0-10范围内的随机整数，将产生的随机整数赋值给i1变量
  7.         int i1 = r.nextInt(10);
  8.         //得到0.0-1.0范围内的随机小数，将产生的随机小数赋值给d变量
  9.         double d = r.nextDouble();
  10.         System.out.println(i);
  11.         System.out.println(i1);
  12.         System.out.println(d);
  13.     }

3.流程控制语句

1.选择结构if

💡 if语句是指如果满足某种条件，就进行某种处理。

  1. if (条件语句){
  3. 执行语句;
  5. ……
  7. }

注意

  • 判断结果为boolean 要么为true 要么为false
    1.       //当条件满足的情况下 奖励MP4
    2.       if(score >= 90){
    3.           System.out.println("奖励一个MP4!");
    4.       }

    1.1if…else语句

    💡if…else语句是指如果满足某种条件，就进行某种处理，否则就进行另一种处理。

  1. if (判断条件){
  2.     执行语句1
  3.     ……
  4. }else{
  5.     执行语句2
  6.     ……
  7. }
  1.         Scanner scanner = new Scanner(System.in);
  2.         int alcohol  = scanner.nextInt();
  4.         if (alcohol >= 20){
  5.             System.out.println("被警察叔叔带走了...");
  6.         } else {
  7.             System.out.println("继续开车...");
  8.         }

1.2if…else if….else语句

  1.         //        银行卡
  2.         int money = 4;
  4.         //        判断
  5.         if (money >= 500) {
  6.             System.out.println("买高铁");
  7.         }else if(money >= 200){
  8.             System.out.println("买飞机");
  9.         }else if (money >= 100) {
  10.             System.out.println("买坦克");
  11.         }else if (money >= 50) {
  12.             System.out.println("买核弹");
  13.         }else if (money >= 20) {
  14.             System.out.println("买房子");
  15.         }else if (money >= 5){
  16.             System.out.println("买AK");
  17.         }else {
  18.             System.out.println("回家做梦");
  19.         }

1.3嵌套IF

  1. //        键盘录入 分别是 时间和男子女子
  3.         Scanner input = new Scanner(System.in);
  4.         //获取成绩
  5.         System.out.println("请输入比赛成绩：");
  6.         double score = input.nextDouble();
  7.         //获取性别
  8.         System.out.println("请输入性别：");
  9.         String gender = input.next();
  11.         //        判断成绩是否小于10秒
  12.         if (score <= 10) {
  13.             //判断性别
  14.             if (gender.equals("男")) {
  15.                 System.out.println("去男子组");
  16.             }else if(gender.equals("女")){
  17.                 System.out.println("去女子组");
  18.             }else {
  19.                 System.out.println("请重新输入。。。。。");
  20.             }
  21.         }else {
  22.             System.out.println("成绩不合格");
  23.         }

2.switch语句

💡switch 选择结构可以更好的解决等值判断问题

  1.             switch (表达式) {
  2.             case 常量1:
  3.                 break;
  4.             case 常量3:
  5.                 break;
  6.             default:
  7.                 break;
  1.         int num = 2;
  3.         switch (num) {
  4.             case 1:
  5.                 System.out.println("麻省理工学院");
  6.                 break;
  7.             case 2:
  8.                 System.out.println("笔记本");
  9.                 break;
  10.             case 3:
  11.                 System.out.println("奖励移动硬盘");
  12.                 break;
  13.             default:
  14.                 System.out.println("请从新输入前几名");
  15.                 break;

1.穿透

💡在使用switch语句的过程中，如果多个case条件后面的执行语句是一样的，则该执行语句只需书写一次即可，这是一种简写的方式。

  1.          int num = 2;
  3.         switch (num) {
  4.             case 1:
  5.             case 3:
  6.             case 5:
  7.                 System.out.println("奇数！");
  8.                 break;
  9.             case 2:
  10.             case 4:
  11.             case 6:
  12.                 System.out.println("偶数！");
  13.                 break;
  14.             default:
  15.                 System.out.println("请从新输入");
  16.                 break;

08.流程控制语句 - 图1
switch 和 if 的比较

  • 如果判断的具体数值不多， 而且符合 byte、 short 、 int、 char, enum[枚举], String 这 6 种类型。 虽然两个语句都可 以使用， 建议使用 swtich 语句。
  • 其他情况： 对区间判断， 对结果为 boolean 类型判断， 使用 if， if 的使用范围更广 。

注意：

  • “表达式” 的取值类型：char 、byte、short、int、string 类型等数据，并且它必须用括号括住。
    1. - JDK5版本以后可以是枚举
    2. - JDK7版本以后可以是字符串
  • “case:” 后面跟的是是要和表达式进行比较的值
  • “break” 表示一个case的中断，不能省略，但最后一个break可以省略
  • “default” 当所有值和表达式都不匹配的时候就执行 default 控制的语句体，默认情况总是出现在switch 语句块的最后。
  • 若表达式是String类型，case后面的值要用双引号” “；
  • 若表达式是char类型，case后面的值用单引号’ ‘。

3.循环结构

1.While

根据条件判断来决定是否执行大括号内的执行语句。 只要循环条件成立就会不断执行循环操作，大括号内的执行语句就会执行，直到条件不成立，while循环结束。

  1. while(循环条件){
  2.     循环操作
  3.     ………
  4. }

在大括号中的执行语句被称作循环体，循环体是否执行取决于循环条件。

  1.         //起始从1开始
  2.         int i = 1;
  3.         while(i <= 100){
  4.             System.out.println("第" + i + "次打王飞");
  5.             //循环一次加1
  6.             i++;
  7.             //直到加100次为止 并且大于100不在进入循环
  8.         }

2.do….while

关键字do，大括号中是循环体， do…while循环语句将循环条件放在了循环体的后面。 循环体会无条件执行一次，然后再根据循环条件来决定是否继续执行。

  1.         do {
  3.             循环体
  4.             ………
  5.         } while(循环条件);
  1.         String answer;
  2.         Scanner input = new Scanner(System.in);
  3.         do {
  4.             System.out.println("上机编写程序！");
  5.             System.out.println("合格了么？(y/n)");
  6.             answer = input.next();
  7.         } while (!"y".equals(answer));
  8.         System.out.println("及格了");

区别

  • 循环结构的表达式不同
  • 执行时判断方式不同
  • 执行次数不同
  • 执行末尾循环体的顺序不同
  • while 先判断在执行
  • do..while 先执行在判断

1.死循环

  1.         while(true){
  2.             循环操作
  3.             ………
  4.         }
  6.         do {
  8.             循环体
  9.             ………
  10.         } while(true);

缺乏条件的判断，当条件为true的时候会一直执行循环体

3.For

反复执行一段代码，指导满足一定的条件为止

  1. for（初始化表达式; 循环条件; 操作表达式）{
  3.     执行语句
  4.     ………
  5. }
  7. 1.初始部分:设置循环的初始状态
  8. 2.循环体:重复执行的代码
  9. 3.迭代:下一次循环开始前要执行的部分
  10. 4.循环条件:判断是否继续循环的条件

注意：
for关键字后面()中包括了三部分内容：初始化表达式、循环条件和操作表达式，它们之间用“;”分隔，{}中的执行语句为循环体。

执行流程

1.表示初始化表达式、2.表示循环条件、3.表示操作表达式、4.表示循环体，通过序号来具体分析for循环的执行流程。

  1.     for（初始化表达式; 循环条件; 操作表达式）{
  3.         执行语句
  4.         ………
  5.     }

顺序
1.执行初始化部分（int i = 0）
2.进入循环条件判断（i<100;）
3.根据循环条件判断结果（true，false）执行循环体
4.执行迭代部分 改变循环变量值（i++）
5.依次重复执行
6.退出循环

错误代码

  1.     for（;; ）{
  2.         执行语句
  3.     }
  5.     for（;i<10; ）{
  6.         执行语句
  7.     }
  9.      for（;;i++ ）{
  10.         执行语句
  11.     }
  13.      for（;i<10;i++ ）{
  14.         执行语句
  15.     }

4.跳转语句（break、continue）

break语句

用于终止某个循环，程序跳转到循环体外的下一条语句。

  1. int score ; //每门课的成绩
  2.         int sum = 0 ; //成绩之和
  3.         double avg = 0.0; //平均分 
  4.         boolean isR = true;
  5.         Scanner input = new Scanner(System.in);
  6.         System.out.println("请输入学生姓名：");
  7.         String name = input.next();
  8.         for (int i = 0; i < 5; i++) {
  9.             System.out.println("请输入5门课程中第" + (i+1) + "门课的成绩");
  10.             //循环录入每次课的成绩
  11.             score = input.nextInt();
  12.             if (score < 0 ) {
  13.                 isR = false;
  14.                 break;
  15.             }
  16.             //进行求和
  17.             sum = sum + score;
  18.         }
  19.         if (isR) {
  20.             avg = sum /5 ;
  21.             System.out.println(name+ " 的平均分是 ： " + avg);
  22.         }else {
  23.             System.out.println("输入错误，请从新输入。。。。。。");
  24.         }

continue

用于跳出本次循环，进入下一次循环

  1. int score ; //每门课的成绩
  2.         int sum = 0 ; //大于80的人数
  3.         int num ; //总人数
  4.         Scanner input = new Scanner(System.in);
  5.         System.out.println("请输入班级总人数：");
  6.         num = input.nextInt();
  7.         for (int i = 0; i < num; i++) {
  8.             System.out.println("请输入第" + (i+1) + "名的成绩：");
  9.             //循环录入每次课的成绩
  10.             score = input.nextInt();
  11.             if (score < 80) {
  12.                 continue;
  13.             }
  14. //            if (score >= 80) {
  15. //                sum++;
  16. //            }
  17.             sum++;
  18.         }
  19.         System.out.println("80分以上的学生人数是："+sum);
  20.         double rate = (double)sum / num *100;
  21.         System.out.println(rate+"%");
  22.     }

4.双重循环

💡循环嵌套是指在一个循环语句中再定义一个循环语句的语法结构

  1.         System.out.println("打印直角三角形");
  2.         //打印行数
  3.         for(int i = 1 ; i <= 5 ; i++){
  4.             //打印行内个数        
  5.             for (int j = 0; j < 2*i-1; j++) {
  6.                 System.out.print("*");
  7.             }
  8.             System.out.println("");
  9.         }
  1.         int rows = 9;                        //乘法表的行数
  2.         for(int i = 1; i<=rows; i++){        //一共9行
  3.             for(int j = 1; j <= i; j++){    //第i行有i个式子
  4.                 System.out.print(j+"*"+i+"="+j*i+"    ");
  5.             }
  6.             System.out.print("\n");            //打印完一行后换行
  7.         }