javajavase
尚硅谷宋红康第2章_Java基本语法(下)：程序流程控制.pdf

顺序结构

从上往下，依次执行

选择结构

按照不同的选择，执行不同的代码

if语句

格式

  1. if(布尔表达式) {
  2.     语句体;
  3. }

  • 判断比较表达式的值，看是true还是false

    • 如果是true，就执行语句体
    • 如果是false，就不执行语句体
      1. if(布尔表达式) {
      2. 语句体1;
      3. } else {
      4. 语句体2;
      5. }

  • 判断比较表达式的值，看是true还是false

    • 如果是true，就执行语句体1
    • 如果是false，就执行语句体2
      1. if(布尔表达式1) {
      2. 语句体1;
      3. } else if(布尔表达式2) {
      4. 语句体2;
      5. }
      6. …
      7. else {
      8. 语句体n+1;
      9. }

  • 判断比较表达式1的值，看是true还是false

    • 如果是true，就执行语句体1
    • 如果是false，就继续判断比较表达式2的值，看是true还是false
      • 如果是true，就执行语句体2
      • 如果是false，就继续判断比较表达式3的值，看是true还是false
        • …
          • 如果都不满足，就执行语句体n+1

注意事项

  • 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）或布尔变量
  • 语句块只有一条执行语句时，一对{}可以省略，但建议保留
  • 一般来说，有左大括号，就没有分号，有分号，就没有左大括号
  • if语句其实都是一个语句，只要有一个执行，其他的就不再执行
  • 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓

当多个条件是“包含”关系时，“上小下大 / 子上父下”

  • if-else语句结构，根据需要可以嵌套使用

    1. if(条件) {
    2.   if(条件) {}
    3. }else {
    4.   if(条件) {}
    5. }
    6. 执行顺序：先判断外层if的条件，如果成立，才去判断内部if的条件

    三元运算符和if语句第二种格式的关系
    所有的三元运算符能够实现的，if语句的第二种格式都能实现，反之不成立
    如if语句第二种格式控制的语句体是输出语句，就不可以
    因为三元运算符是一个运算符，必须要有一个结果返回，不能是一个输出语句

    switch语句

    格式

    1. switch(表达式) {
    2. case 值1:
    3.   语句体1;
    4.   break;
    5. case 值2:
    6.   语句体2;
    7.   break;
    8. …
    9. default:
    10.   语句体n+1;
    11.   break;
    12. }

  • switch：说明这是switch语句。

  • 表达式：可以是byte、short、int、char、枚举(JDK5)、字符串(JDK7)
  • case：后面的值就是要和表达式进行比较的值
  • break：表示程序到这里中断，跳出switch语句
  • default：如果所有的情况都不匹配,就执行这里,相当于if语句中的else

流程

  • 首先计算表达式的值
  • 和每一个case进行匹配，如果有就执行对应的语句体，看到break就结束
  • 如果没有匹配，就执行default的语句体n+1

注意事项

  • case后面只能是常量，不能是变量，而且多个case后面的值不能出现相同的
  • default可以省略，但是不建议，因为它的作用是对不正确的情况给出处理

特殊情况case就可以把值固定。如选项A,B,C,D
default不一定要在最后，可以在任意位置。但是建议在最后

  • break可以省略，但是结果可能不是我们想要的，会出现case穿透现象

  • switch语句的结束条件

    • 遇到break就结束了
    • 执行到末尾就结束了

      if语句和switch语句比较

      if

  • 针对boolean类型的判断

  • 针对一个范围的判断
  • 针对几个常量的判断

switch

  • 针对几个常量的判断

循环结构

做一些重复的代码

for语句

格式：

  1. for(初始化语句; 判断条件语句; 控制条件语句) {
  2.     循环体语句;
  3. }
  1. 执行初始化语句
  2. 执行判断条件语句
    • 如果这里是true，就继续3
    • 如果这里是false，循环就结束
  3. 执行循环体语句
  4. 执行控制条件语句
  5. 回到2
    1. for(元素类型 元素临时变量名: 数组名) {
    2.  循环体语句;
    3. }
    注意事项
  • 判断条件语句无论简单还是复杂，结果是boolean类型

  • 初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔

    while语句

    1. 初始化语句;
    2. while(判断条件语句) {
    3.   循环体语句;
    4.   控制条件语句;
    5. }

    do…while语句

    1. 初始化语句;
    2. do {
    3.   循环体语句;
    4.   控制条件语句;
    5. } while(判断条件语句);

    区别

    for和while的区别

  • for循环可以和while循环等价转换

  • 使用上的区别
    • for语句的控制条件变量，在循环结束后不能再使用了。(变量只存在所处的大括号内)
    • 而while的可以继续使用
  • 理解上的区别
    • for适合于一个范围的判断
    • while适合次数不明确的

三种循环的区别

  • do…while循环至少执行一次循环体
  • for和while必须先判断条件是否是true，然后后才能决定是否执行循环体
  • 优先考虑for，其次考虑while，最后考虑do…while

    循环使用的注意事项(死循环)

    一定要注意修改控制条件,否则容易出现死循环
    最简单的死循环格式
    1. for(;;) {}
    2. while(true) {}

    嵌套循环

    一个循环中又嵌套了另一个完整的循环结构
    三种循环中，都可以嵌套另外一种任意的循环结构
    先执行外层循环，然后执行内层循环 ```java // 100000以内所有质数个数 int count = 0; boolean isflag == true;

long start = System.currentTimeMillis(); for(int i = 2; i <= 100000; i++) { for(int j = 2; j <= Math.sqrt(i); j++) { if(i % j == 0) { isFlag = false; break; }
} if(isFlag == true) { count++; } isFlag = true; } long end = System.currentTimeMillis();

System.out.println(count); System.out.println(end - start);

  2. ---
  4. <a name="kVtY4"></a>
  5. ## 跳转
  6. <a name="inY2Y"></a>
  7. ### break：中断
  8. 用于终止某个语句块的执行，用在循环和switch语句中
  10. - 跳出单层循环
  11. - 跳出多层循环，需要标签语句的配合
  12. ```java
  13. wc:
  14. for(int x=0; x<3; x++) {
  15.     nc:
  16.     for(int y=0; y<4; y++) {
  17.         if(y == 2) {
  18.         //break nc;
  19.         break wc;
  20.     }
  21.     System.out.print("*");
  22. }

continue：继续

用在循环中，离开此应用场景无意义

  • 跳出单层循环的一次，可以继续下一次

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

    1. outer: 
    2. for (int i = 101; i < 150; i++) {
    3.   for (int j = 2; j < i / 2; j++) {
    4.       if (i % j == 0){
    5.           continue outer;
    6.       }
    7.   }
    8.   System.out.print(i + "  ");
    9. }
    1. // 100000以内所有质数个数
    2. long start = System.currentTimeMillis();
    3. int count = 0;
    4. lable:
    5. for (int i = 2; i <= 100000; i++) {
    6.   for (int j = 2; j <= Math.sqrt(i); j++) {
    7.       if (i % j == 0) {
    8.           continue lable;
    9.       }
    10.   }
    11.   count++;
    12. }
    13. long end = System.currentTimeMillis();
    14. System.out.println(count);
    15. System.out.println(end - start);

    return：返回

    用于结束方法，或者返回调用方法
    一旦遇到return程序就不会在继续往后执行

    范例

    1. /**
    2. * 需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是，
    3. *      每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，
    4. *      请问，经过多少天，小芳才可以存到100元钱。
    5. */
    6. class Test {
    7.   public static void main(String[] args) {
    8.       double dayMoney = 2.5;  // 每天要存储的钱是2.5元
    9.       double daySum = 0;      // 存钱的初始化值是0
    10.       int dayCount = 0;       // 存钱天数
    11.       int result = 100;       // 最终存储不小于100就不存储了
    13.       // 因为不知道是多少天，所以我用死循环，
    14.       while (true) {
    15.           // 累加钱
    16.           daySum += dayMoney;
    17.           // 天数变化
    18.           dayCount++;
    19.           // 一旦超过100元我就退出循环。
    20.           if (daySum >= result) {
    21.               System.out.println("共花了" + dayCount + "天存储了100元");
    22.               break;
    23.           }
    24.           if (dayCount % 5 == 0) {
    25.               // 花去6元钱
    26.               daySum -= 6;
    27.               System.out.println("第" + dayCount + "天花了6元钱");
    28.           }
    29.       }
    30.   }
    31. }