每日复习

  1. switch后面使用的表达式可以是哪些数据类型的。

    • byte 、 short 、char 、int 、枚举类型变量、String类型。

  2. 谈谈你对三元运算符、if-else和switch-case结构使用场景的理解

    • 凡是用三元和switch-case的都可以写成if-else
    • 能用三元或switch-case尽量用三元和switch，因为执行效率高 ```java int c; if(a != b){ c = a; }else{ c = b; }

int c = (a != b)? a : b;

int c = a;

  2. 3. 
  3. 如何从控制台获取String和int型的变量，并输出？使用代码实现
  6. ```java
  7. 1.import java.util.Scanner;
  9. 2.Scanner scan = new Scanner(System.in);
  11. 3.String info = scan.next(); 
  12. int id = scan.nextInt();
  1. 使用for循环遍历100以内的奇数，并计算所有的奇数的和并输出。
    1. int sum = 0;
    2. for(int i = 1;i <= 100;i++){
    3.  if(i % 2 != 0){
    4.      Sysout(i);
    5.      sum += i;
    6.  }
    7. }
    8. syout(sum);

例题

  • 题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
    比如：12和20的最大公约数是4，最小公倍数是60。

    1.   说明：break关键字的使用
  1. import java.util.Scanner;
  2. class ForTest {
  3.     public static void main(String[] args) {
  5.         Scanner scan = new Scanner(System.in);
  7.         System.out.println("请输入第一个正整数");
  8.         int m = Scanner.nextInt();
  10.         System.out.println("请输入第一个正整数");
  11.         int m = Scanner.nextInt();
  13.         //获取最大公约数 
  14.         int min = (m > n)? m : n;
  15.         //遍历
  16.         for(int i = min;i>=1;i--){
  17.             if(m % i == 0 && n){
  18.                 System.out.println("最大公约数为：" + i);
  19.                 break;//一旦在循环中执行break，就跳出循环
  20.             }
  21.         }
  23.         //获取最大公倍数 
  24.         int max = (m > n)? m : n;
  25.         //遍历
  26.         for(int i = max;i <= m * n;i--){
  27.             if(i % m == 0 && i % n == 0){
  28.                 System.out.println("最大公倍数为：" + i);
  29.                 break;//一旦在循环中执行break，就跳出循环
  30.             }
  31.         }
  32.     }
  33. }

while循环

  • 循环语句的四个组成部分

    1. 初始化部分(init_statement)
    2. 循环条件部分(test_exp) ——>是boolean类型
    3. 循环体部分(body_statement)
    4. 迭代部分(alter_statement)

  • 语法格式

  • ①初始化部分
    while(②循环条件部分)｛
    ③循环体部分;
    ④迭代部分;
    }

  • 执行过程：①②③④②③④②③④②

说明：

  • 注意不要忘记声明迭代部分。否则，循环将不能结束，变成死循环。
  • 我们写程序，要避免出现死循环
  • for循环和while循环可以相互转换
  • 区别：for循环和while循环的初始条件部分，作用域不一样

算法：有限性

Do-While循环

  • 循环语句的四个组成部分

    1. 初始化部分(init_statement)
    2. 循环条件部分(test_exp) ——>是boolean类型
    3. 循环体部分(body_statement)
    4. 迭代部分(alter_statement)

  • 语法格式
    ①初始化部分;
    do{
    ③循环体部分
    ④迭代部分
    }while(②循环条件部分);
    执行过程：
    ①-③-④-②-③-④-②③④
    说明：

    1. do-while循环至少执行一次循环体
    2. 开发中，使用for-while更多一些。较少使用do-while
  1. class DowhileTest {
  2.     public static void main(String[] args) {
  4.         //遍历100以内的偶数,并计算所有偶数的和，及偶数的个数
  5.         int num = 1;
  6.         int sum = 0;//
  7.         int count = 0;//
  8.         do{
  9.             if(num % 2 == 0){
  10.                 System.out.println("偶数" + num);
  11.                 sum += sum;
  12.                 count++;
  13.             }
  14.             num++;
  15.         }while(num <= 100);
  17.         System.out.println("总和为" + sum);
  18.         System.out.println("个数为" + count);
  20.         //********体会do-while至少执行一次循环体*********
  21.         //执行多次，没区别
  22.         int number1 = 10;
  23.         while(number1 > 10){
  24.             System.out.println("hello,while");
  25.             number1--;
  26.         }
  28.         int number2 = 10;
  29.         do{
  30.             System.out.println("hello,do-while");
  31.             number2--;
  32.         }while(number2 > 10);
  33.     }
  34. }

例题

  1. 题目：
    从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序

  2. 说明：
    1.不在循环条件部分限制次数的结构：for(;;)或while(true)
    2.结束循环有几种方式？
    方式一：循环条件部分返回false
    方式二：在循环体中执行break

  1. import java.util.Scanner;
  3. class ForWhileTest {
  4.     public static void main(String[] args) {
  6.         Scanner scan = new Scanner(System.in);
  8.         int positiveNumber = 0;//记录正数的个数
  9.         int negativeNumber = 0;//记录负数的个数
  11.         while(true){//for(;;)
  12.             int number = scan.nextInt();
  13.             if(number > 0){
  14.                 positiveNumber++;
  15.             }else if(number == 0){
  16.                 //一旦执行break,跳出循环
  17.                 break;
  18.             }else if(number < 0){
  19.                 negativeNumber++;
  20.             }
  21.         }
  23.         System.out.println("输入正数个数为：" + positiveNumber);
  24.         System.out.println("输入负数个数为：" + negativeNumber);
  25.     }
  26. }

嵌套循环的使用

嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环

  1. 外层查询：循环结构B
    内层查询：循环结构A

3.说明
①内层循环结构遍历一遍，只相当于外层循环体执行一次
②假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的执行体一共执行了m*n次

4.技巧
外层循环控制行数
内层循环控制列数

  1. class ForForTest {
  2.     public static void main(String[] args) {
  3.         System.out.println("Hello World!");
  5.         //******
  6.         //System.out.println("******");
  7.         for(int i = 1;i <= 6;i++){
  8.             System.out.print('*');
  9.         }
  10.         System.out.println("\n");
  12.         /*
  13.         ******
  14.         ******
  15.         ******
  16.         ******
  17.         */
  18.         for(int j = 1;j <= 4;j++){
  19.             for(int i = 1;i <= 6;i++){
  20.                 System.out.print('*');
  21.             }
  22.             System.out.println();
  23.         }
  24.         System.out.println();
  25.         /*
  26.         *
  27.         **
  28.         ***
  29.         ****
  30.         *****
  31.         */
  32.         for(int i = 1;i <= 5;i++){
  33.             for(int j = 1; j <= i;j++){
  34.                 System.out.print("*");
  35.             }
  36.             System.out.print("\n");
  37.         }
  38.         /*
  39.         *****
  40.         ****
  41.         ***
  42.         **
  43.         *
  44.         */
  45.         for(int i = 1;i <= 5;i++){
  46.             for(int j = 1; j <= 5 - i + 1;j++){
  47.                 System.out.print("*");
  48.             }
  49.             System.out.print("\n");
  50.         }
  51.     }
  52. }

嵌套循环：例题1

  1. /*
  2. 九九乘法表
  3. */
  4. class NineNineTable {
  5.     public static void main(String[] args) {
  6.         System.out.println("Hello World!");
  7.         for(int i = 1;i <= 9;i++){
  8.             for(int j = 1;j <= i;j++){
  9.                 System.out.print(j*i + " ");
  10.             }
  11.             System.out.println();
  12.         }
  13.     }
  14. }

嵌套循环：例题2

  • 方式一
  1. /*
  2. 100以内的所有质数
  3. */
  4. class PrimeNumberTest {
  5.     public static void main(String[] args) {
  7.         boolean flag = true;
  9.         for(int i = 2;i <= 100;i++){
  10.             for(int j = 2;j <= Math.sqrt(i);j++){
  12.                 if(i % j == 0){//被除尽了
  13.                     flag = false;
  14.                     break;
  15.                 }
  16.             }
  18.             //判断是否为质数
  19.             if(flag){
  20.                 System.out.println(i);
  21.             }
  22.             flag = true;
  23.         }
  24.     }
  25. }
  • 方式二
  1. /*
  2. 100以内的所有质数
  3. */
  4. class PrimeNumberTest {
  5.     public static void main(String[] args) {
  7.         label:for(int i = 2;i <= 100;i++){//遍历100以内的自然数
  8.             for(int j = 2;j <= Math.sqrt(i);j++){
  10.                 if(i % j == 0){//被除尽了
  11.                     continue label;
  12.                 }
  13.             }
  14.             //能执行到此处的，都是质数
  15.             count++;
  16.         }
  17.     }
  18. }

break、continue

使用范围 循环中使用的作用（不同点） 相同点
break switch-case、循环中使用 结束当前循环 关键字后面不能有执行语句
continue 循环中使用 结束当此循环 关键字后面不能有执行语句

break 语句

  • break语句用于终止某个语句块的执行
  1. { ……
  2. break;
  3. ……
  4. }
  • break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
  1. label1: { ……
  2. label2: { ……
  3. label3: { ……
  4. break label2;
  5. ……
  6. } } }

continue 语句

  • continue只能使用在循环结构中

  • continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环

  • continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环

  1. class  BreakContinueTest {
  2.     public static void main(String[] args) 
  3.     {
  4.         for(int i = 1;i <= 10;i++){
  5.             if(i % 4 == 0){
  6.                 //break;//123
  7.                 continue;//1235679 10
  8.                 //System.out.println("迪丽热巴");//编译报错
  9.             }
  10.             System.out.print(i);
  11.         }
  13.         System.out.println("\n");
  14.         //*******************
  15.         for(int i = 1;i <= 4;i++){
  17.             for(int j = 1; j <= 10;j++){
  18.                 if(j % 4 == 0){
  19.                     //break;//默认跳出包裹此关键字最近的一层循环。
  20.                     continue;
  21.                 }
  22.                 System.out.print(j);
  23.             }
  24.             System.out.println();
  25.         }
  27.         System.out.println("\n");
  28.         //*******************
  29.         label:for(int i = 1;i <= 4;i++){
  31.             for(int j = 1; j <= 10;j++){
  32.                 if(j % 4 == 0){
  33.                     //break label;//结束指定标识的一层循环结构
  34.                     continue label;//结束指定标识的一层循环结构的当此
  35.                 }
  36.                 System.out.print(j);
  37.             }
  38.             System.out.println();
  39.         }
  40.     }
  41. }

特殊流程控制语句

  • return：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。

  • 与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内

特殊流程控制语句

  • break只能用于switch语句和循环语句中。

  • continue 只能用于循环语句中。

  • 二者功能类似，但continue是终止本次循环，break是终止本层循环。

  • break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。

  • 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。

  • 很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它。但使程序容易出错。Java中的break和continue是不同于goto的

每日一考

  1. 说明break和continue的相同点和不同点
    break:switch和循环结构（结束当前循环），其后不可以声明执行语句
    continue:循环结构（结束当此循环），其后不可以声明执行语句

  2. 从控制台输出如下结构

    • 外层循环控制行数
    • 内层循环控制列数
  1. *****
  2. ****
  3. ***
  4. **
  5. *