学习笔记--Java 控制语句

Java 控制语句

---

• Java 控制语句
  • 选择结构
    • if 语句
    • switch 语句
  • 循环结构
    • for循环
    • while循环
    • do...while循环
• 循环控制
  • break 语句
  • continue 语句

---

选择结构

if 语句

if 语句被称为分支语句/条件控制语句，有两种表现方式
基于两种表现方式方法是允许进行嵌套

• 注意下面几点：

1. if 语句至多有 1 个 else 语句，else 语句在所有的 else if 语句之后。
2. if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。
3. 一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。
4. 嵌套时，注意缩进写法规范

 
public class IfTest {
 
    public static void main(String[] args){
 
        /*
        第一种：
            if(布尔表达式){
                Java语句;
                ...
            }
        只要布尔表达式为 true 执行  */
 
        if(true){
            System.out.println("if 内执行");
        }   // 执行
 
        if(false){
            System.out.println("if 内执行");
        }   // 不执行 if 内的语句
 
 
        /*
        第二种：
            if(布尔表达式){
                Java语句;
                ...
            }else{
                Java语句;
                ...
            }
        只要布尔表达式为 true 执行，为 false 执行 else 内的 Java语句*/
 
        if(true){
            System.out.println("if 内执行");
        }else{
            System.out.println("else 内执行");
        }   // 执行  if 内的语句，未执行 else 内语句
 
        if(false){
            System.out.println("if 内执行");
        }else{
            System.out.println("else 内执行");
        }   // 未执行  if 内的语句，执行 else 内语句
 
 
        //------------------------------------------------------------------------------
 
 
 
    }
}
 

switch 语句

switch 形式开关选择，if 偏向范围概念

一个比较完整的 switch 语句：

switch(expression) {
    case value :
        java 语句;
        ...
        [break;]可选
 
    case value :
        java 语句;
        ...
        [break;]可选
 
    ...
 
    default:
        java 语句;
        ...
}

• expression 是 int 数据和 String 数据，也可以是：byte、short、char。从 Java SE 7 开始，switch 支持字符串 String 类型
• case 标签中 value 必须为字符串常量或字面量
• switch 语句可以有多个 case 语句。每个 case 后面跟一个比对值和半角冒号
• expression 于 value 的数据类型需要保持一致
• 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，case 内有 break 语句，整个 switch 语句将结束
• 如果没有 break 语句，会继续执行后续分支内容，被称作 "case 穿透现象"
• 如果所以 case 分支的数值都不匹配，则执行 default 分支的内容，类似 if 语句中的 else
• default 分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个），由于 default 在没有 case 语句的值设定，所以 default 分支不需要 break 语句

public class SwitchTest{
 
    public static void main(String[] args){
 
        /*
        long a = 10L;
        int b = a;  // 编译错误
        */
 
        /*
        long x = 10L;
        switch(x){}  // 编译错误
        */
 
        // 解决编译错误
        long x = 100L;
        switch((int)x){}
        /* switch 支持 int，
        byte、short、int 、char 支持是自动转换，
        long 不能自动转换成 int
        */
 
        byte a = 10;
        switch(a){} // 通过
 
        short b = 10;
        switch(b){} // 通过
 
        char c = 'A';
        switch(c){} // 通过
 
        // switch(true){}
        // 报错，布尔型不支持
 
        String name = "XXX";
        switch(name){}  // 通过
        // 但注意版本 1.7 java 中才加入 switch 字符串 String 类型的支持
        // 所以在此之前的版本不支持
 
    }
}

循环结构

for循环

语法结构：

for(初始表达式; 布尔表达式; 更新表达式){
    循环体
}

• 循环体：需要重复执行的 java 语句
• 初始表达式：最先执行，且只执行一次
• 布尔表达式：表达式值必为 true/false
• for 执行流程：
  • 先执行初始表达式，只执行本次
  • 判断布尔表达式
    • true :
      1. 执行循环体
      2. 执行更新表达式
      3. 判断布尔表达式
    • false: 循环结束
• Java5 引入了一种主要用于数组的增强型 for 循环

for(声明语句 : 表达式)
{
   //代码句子
}

• 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

• 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

示例

public class ForTest{
 
    public static void main(String[] args){
 
        System.out.println("你好！");
        System.out.println("你好！");
        System.out.println("你好！");
        System.out.println("你好！");
        System.out.println("你好！");
 
        System.out.println("----------以下为 for 输出-------------");
 
        for(int x = 1; x <= 5; i++){
            System.out.println("你好！");
        }
 
        // for循环中的 i 变量作用域只限于 for 循环内部使用
        // 注意：i < 10 和 i <= 10 的使用
        for(int i = 0; i < 10; i++){
            System.out.println("i --> " + i);
        }
 
        for(int i = 0; i <= 10; i++){
            System.out.println("i --> " + i);
        }
 
        // Java5 引入
        int [] numbers = {10, 20, 30, 40, 50};
 
        for(int x : numbers ){
            System.out.print( x );
            System.out.print(",");
        }
    }
}

while循环

语法结构：

while(布尔表达式){
    循环体
}

• while 循环的执行过程：

    - 判断布尔表达式
        - true 执行循环体
            - 判断布尔表达式
                - true 执行循环体
                    ...
                - false 结束循环
        - false 结束循环

• while 循环：0 ~ N

实例代码：

public class WhileTest{
 
    public static void main(String[] args){
 
        // 死循环，注意下面三段代码的不同
        /* 1:
        while(true){
            System.out.println("死循环");
        }
        System.out.println("Hello World !");    // 编译报错
        */
        // 因为编译器检测到该程序永远都无法被执行，所以编译报错
 
 
        /* 2:
        int a = 10;
        int b = 3;
        while(a > b){
            System.out.println("Hi");
        }
        System.out.println("Hello World !");    // 编译通过
        */
 
        /* 3:
        while(10 > 3){
            // 10 > 3 为 true，但只是人为判断，编译器无法区分认为不符合语法
            // 编译器时
            System.out.println("Hi");
        }
        System.out.println("Hello World !");    // 编译报错
        */
 
        // 直接暴露字面值 和 使用变量效果不一样
 
 
        int i = 1;
        while(i <= 10){
            System.out.println(i);
            i++;
        }
        System.out.println("---------------------分隔");
        i = 1;
        while(i <= 10){
            i++;
            System.out.println(i);
        }
 
        System.out.println("---------------------分隔");
        // -------------------------------------------------------
 
        int n = 1;
        int m = 1;
 
        while(n <= 10){
            System.out.print("n++ --> " + n++);
            System.out.println(" end ++m --> " + ++m);
        }
    }
}

do...while循环

语法结构：

do{
    循环体
}while(布尔表达式);

• do...while循环执行过程：

    - 执行do内循环体
        - 判断布尔表达式
            - true
                - 执行do内循环体
                    - 判断布尔表达式
                            ...
            - false 循环结束

• do...while循环次数：1 ~ N【至少一次】
• do...while最后有一个 ;

示例代码

public class DoWhileTest{
 
    public static void main(String[] args){
 
        int i = 10;
 
        do{
            System.out.println(i);
            i++;
        }while(i > 20);
 
        System.out.println("-------------------");
 
        i = 10;
        while(i > 20){
            System.out.println(i);
            i++;
        }
 
        // do...while必定执行一次
    }
}

循环控制

break 语句

• break 是Java语句当中的关键字，被翻译成“中断/折断”
• break 使用在其后添加 ;，即可单独成为一个完整的Java语句

break;

• break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块
• 在循环中当满足某些条件，就不需要执行后续内容，可以使用 break 跳出循环提高程序效率
• break 跳出最里层的循环，并且继续执行该循环下面的语句（默认只是当前层的循环）
• 跳出指定循环

break 循环名;

示例

public class BreakTest{
 
    public static void main(String[] args){
 
        for(int i = 0; i < 10; i++){
            if (i == 5){
                break;
            }
            System.out.println("i -> " + i);
        }
        System.out.println("-----------------跳出当前的循环-----------------------");
 
        for(int i = 0; i < 10; i++){
 
            for(int j = 0; j < 10; j++){
 
                if (j == 5){
                    System.out.println("跳出");
                    break;  // 只是跳出当前的循环
                }
 
                System.out.print("i -> " + i);
                System.out.println("  end  j -> " + j);
            }
        }
        System.out.println("---------------跳出指定循环-------------------------");
 
        // for1 和 for2 是为循环命名
        for1: for(int i = 0; i < 10; i++){
 
            for2: for(int j = 0; j < 10; j++){
 
                if (j == 5){
                    System.out.println("跳出");
                    break for1;  // 跳出指定循环for1的循环
                }
 
                System.out.print("i -> " + i);
                System.out.println("  end  j -> " + j);
            }
 
        }
    }
}

continue 语句

• continue 表示：继续/go on/下一个
• 用法(类似break)：

continue;

• continue 适用于任何循环控制结构中，作用是让程序立刻跳转到下一次循环的迭代
• 在 for 循环中，continue 语句使程序立即跳转到更新语句
• 在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句

public class ContinueTest{
 
    public static void main(String[] args){
 
        // continue 和 break 区别
        System.out.println("------continue------");
        for(int i = 0; i < 5; i++){
            if(i == 1){
                continue;
            }
            System.out.println("i --> " + i);
        }
 
        System.out.println("------break------");
        for(int i = 0; i < 5; i++){
            if(i == 1){
                break;
            }
            System.out.println("i --> " + i);
        }
        System.out.println("-----------------------");
 
 
        // continue 也可以跳指定循环
        System.out.println("------默认------");
        for1: for(int i = 0; i < 5; i++){
            for2: for(int j = 0; j < 5; j++){
                if(j == 1){
                System.out.println("跳出");
                continue;  // 默认
                }
                System.out.print("i --> " + i);
                System.out.println("  end  j --> " + j);
            }
        }
        System.out.println("------指定循环------");
        for1: for(int i = 0; i < 5; i++){
            for2: for(int j = 0; j < 5; j++){
                if(j == 1){
                System.out.println("跳出");
                continue for1;  // 跳指定循环for1
                }
                System.out.print("i --> " + i);
                System.out.println("  end  j --> " + j);
            }
        }
    }
}

---

---

基础章

• 我的第一个Java程序
• Java标识符
• Java 字面值
• Java中的变量
• Java中的数据类型
• Java 运算符
• Java 控制语句

---

合集总目录：学习笔记--Java合集