• Java学习笔记（四）——程序控制结构

    一、顺序控制

    二、分支控制

    （一）单分支

    （二）双分支

    （三）多分支

    （四）嵌套分支

     （五）switch分支结构

    （六）if和switch的选择

    三、循环控制

    （一）for循环

    （二）while循环

    （三）do while循环

    （四）多重循环控制

     （五）跳转控制语句-break

    （六）跳转控制语句-continue

    （七）跳转控制语句-return

    一、顺序控制

    程序从上到下逐行地执行，中间没有任何判断和跳转。

    二、分支控制

    让程序有选择的执行。

    （一）单分支

    基本语法：

    if(条件表达式){

            执行代码块;

    }

    说明：当条件表达式为true时，就会执行{}的代码；如果为false就不执行。

    1. import java.util.Scanner; //表示把java.util下的Scanner类导入
    2.  
    3. public class If01{
    4.  
    5. 	public static void main(String[] args){
    6. 		Scanner myScanner = new Scanner(System.in);
    7. 		System.out.print("请输入年龄：");
    8. 		int age = myScanner.nextInt(); //接收用户输入int
    9. 		if(age > 18){
    10. 			System.out.println("你年龄大于18，要对自己的行为负责");
    11. 		}
    12. 		System.out.println("程序继续...");
    13. 	}
    14. }

    （二）双分支

    基本语法：

    if(条件表达式){

            执行代码块1;

    }else{

            执行代码块2;

    }

    说明：当条件表达式为true时，就会执行代码块1，否则执行代码块2。

    1. import java.util.Scanner; //表示把java.util下的Scanner类导入
    2.  
    3. public class If02{
    4.  
    5. 	public static void main(String[] args){
    6. 		Scanner myScanner = new Scanner(System.in);
    7. 		System.out.print("请输入年龄：");
    8. 		int age = myScanner.nextInt(); //接收用户输入int
    9. 		if(age > 18){
    10. 			System.out.println("你年龄大于18，要对自己的行为负责");
    11. 		}else{
    12. 			System.out.println("你的年龄不大，这次放过你了");
    13. 		}
    14. 		System.out.println("程序继续...");
    15. 	}
    16. }

    （三）多分支

    基本语法：

    if(条件表达式1){

            执行代码块1;

    }else if(条件表达式2){

            执行代码块2;

    }

    ......

    else{

            执行代码块n;

    }

    注意：多分支可以没有else，如果所有的条件表达式都不成立，则一个执行入口都没有

    1. import java.util.Scanner; 
    2.  
    3. public class If03{
    4.  
    5. 	public static void main(String[] args){
    6. 		Scanner myScanner = new Scanner(System.in);
    7. 		System.out.print("请输入芝麻信用分：");
    8. 		int grade = myScanner.nextInt(); 
    9. 		// 数据正确性验证
    10. 		if(grade >= 1 && grade <=100){
    11. 			if(grade == 100){
    12. 				System.out.println("信用极好");
    13. 			}else if(grade >80 && grade <= 99){
    14. 				System.out.println("信用优秀");
    15. 			}else if(grade >=60 && grade <= 80){
    16. 				System.out.println("信用一般");
    17. 			}else{
    18. 				System.out.println("信用不及格");
    19. 			}
    20. 		}else{
    21. 			System.out.println("信用分需要在1-100，请重新输入：）");
    22. 		}
    23. 	}
    24. }

    （四）嵌套分支

    在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支结构称为内层分支，外面的分支结构称为外层分支。规范：不要超过3层（可读性不好）。

    基本语法：

    if(){

            if(){

            }else{

            }

    }

    1. import java.util.Scanner; 
    2.  
    3. public class If04{
    4.  
    5. 	public static void main(String[] args){
    6. 		Scanner myScanner = new Scanner(System.in);
    7. 		System.out.print("请输入该歌手的初赛成绩：");
    8. 		double score = myScanner.nextDouble(); 
    9. 		// 数据正确性验证
    10. 		if(score >= 0 && score <=10){
    11. 			if(score > 8.0){
    12. 				System.out.print("请输入性别：");
    13. 				char sex = myScanner.next().charAt(0); 
    14. 				if(sex == '男'){
    15. 					System.out.println("恭喜进入复赛男子组");
    16. 				}else if(sex == '女'){
    17. 					System.out.println("恭喜进入复赛女子组");
    18. 				}else{
    19. 					System.out.println("性别输入有误，请重新输入：）");
    20. 				}
    21. 			}else{
    22. 				System.out.println("不好意思，你被淘汰了");
    23. 			}
    24. 		}else{
    25. 			System.out.println("初赛成绩需要在0-10，请重新输入：）");
    26. 		}
    27. 	}
    28. }

     （五）switch分支结构

    基本语法：

    switch(表达式){

            case 常量1: 语句块1;break;

            case 常量2: 语句块2;break;

            ......

            case 常量n: 语句块n;break;

            default:default语句块;break;

    }

    1、switch关键字，表示switch分支

    2、表达式对应一个值

    3、case 常量1：当表达式等于常量1，就执行语句块1

    4、break：表示退出switch

    5、如果和case 常量1匹配，就执行语句块1，如果没有匹配，就继续匹配case 常量2

    6、如果一个都没有匹配上，执行default

    1. import java.util.Scanner; 
    2.  
    3. public class Switch01{
    4.  
    5. 	public static void main(String[] args){
    6. 		Scanner myScanner = new Scanner(System.in);
    7. 		System.out.print("请输入一个字符（a-g）：");
    8. 		char ch = myScanner.next().charAt(0);
    9. 		switch(ch){
    10. 			case 'a':
    11. 				System.out.println("星期一");
    12. 				break;
    13. 			case 'b':
    14. 				System.out.println("星期二");
    15. 				break;
    16. 			case 'c':
    17. 				System.out.println("星期三");
    18. 				break;
    19. 			case 'd':
    20. 				System.out.println("星期四");
    21. 				break;
    22. 			case 'e':
    23. 				System.out.println("星期五");
    24. 				break;
    25. 			case 'f':
    26. 				System.out.println("星期六");
    27. 				break;
    28. 			case 'g':
    29. 				System.out.println("星期七");
    30. 				break;
    31. 			default:
    32. 				System.out.println("输入的字符不正确，没有匹配");
    33. 				break;
    34.  
    35. 		} 
    36. 		
    37. 	}
    38. }

    细节：

    1、表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以相互比较的，比如输入的字符是字符，而常量是int

    2、switch(表达式)中表达式的返回值必须是：byte,short,int,char,enum（枚举）,String

    3、case子句中的值必须是常量或常量表达式，而不能是变量

    4、default子句是可选的，当没有匹配的case时，执行default

    5、break语句用来在执行完一个case分支后使程序跳出switch语句块。如果没有写break，程序会顺序执行到switch结尾，除非遇到break。（穿透）

    1. import java.util.Scanner; 
    2.  
    3. public class Switch04{
    4.  
    5. 	public static void main(String[] args){
    6. 		// 根据用于指定月份，打印该月份所属季节。3,4,5春季 6,7,8夏季 9,10,11秋季 12,1,2,冬季
    7. 		Scanner myScanner = new Scanner(System.in);
    8. 		System.out.print("请输入月份（0-12）：");
    9. 		int month = myScanner.nextInt();
    10. 		switch(month){
    11. 			case 3:
    12. 			case 4:
    13. 			case 5:
    14. 				System.out.println("春季");
    15. 				break;
    16. 			case 6:
    17. 			case 7:
    18. 			case 8:
    19. 				System.out.println("夏季");
    20. 				break;
    21. 			case 9:
    22. 			case 10:
    23. 			case 11:
    24. 				System.out.println("秋季");
    25. 				break;
    26. 			case 12:
    27. 			case 1:
    28. 			case 2:
    29. 				System.out.println("冬季");
    30. 				break;
    31. 			default:
    32. 				System.out.println("输入的月份不正确");
    33. 				break;
    34.  
    35. 		} 
    36. 		
    37. 	}
    38. }

    （六）if和switch的选择

    1、如果判断的具体数值不多，而且符合byte,short,int,char,enum,String这6种类型。虽然两个语句都可以使用，建议使用switch语句。

    2、其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。

    三、循环控制

    （一）for循环

    基本语法：

    for(循环变量初始化;循环条件;循环变量迭代){

            循环操作;

    }

    1、for关键字，表示循环控制

    2、for有四要素：（1）循环变量初始化（2）循环条件（3）循环操作（4）循环变量迭代

    3、循环操作，这里可以有多条语句，也就是我们要循环执行的代码

    细节：

    1、循环条件是返回一个布尔值的表达式

    2、for(;循环判断条件;)中的初始化和变量迭代可以写到其他地方，但是两边的分号不能省略

    3、循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。

    1. import java.util.Scanner;
    2. public class For01{
    3.  
    4. 	public static void main(String[] args){
    5. 		// 1-100中能被num整除的数的个数、和
    6. 		Scanner myScanner = new Scanner(System.in);
    7. 		int num = myScanner.nextInt();
    8. 		int start = 1;
    9. 		int end = 100;
    10. 		int count = 0;
    11. 		int sum = 0;
    12. 		for(int i = start; i <= end; i++){
    13. 			if(i % num == 0){
    14. 				count++;
    15. 				sum += i;
    16. 			}
    17. 		}
    18. 		System.out.println("count=" + count + ",sum=" + sum);
    19. 	}
    20. }
    1. // 输出小写的a-z以及大写的A-Z
    2. public class Homework07{
    3.  
    4. 	public static void main(String[] args){
    5. 		
    6. 		for(char i = 'a'; i <= 'z'; i++){
    7. 			System.out.print(i + " ");
    8. 		}
    9. 		System.out.println();
    10. 		for(char i = 'A'; i <= 'Z'; i++){
    11. 			System.out.print(i + " ");
    12. 		}
    13. 	}
    14. }

    （二）while循环

    基本语法：

    while(循环条件){

            循环体（语句）;

            循环变量迭代;

    };

    说明：while循环也有四要素（循环变量初始化、循环条件、循环操作、循环变量迭代），只是四要素放的位置不一样。

    细节：1、循环条件是返回一个布尔值的表达式 2、while循环是先判断再执行语句

    1. import java.util.Scanner;
    2. public class While01{
    3.  
    4. 	public static void main(String[] args){
    5. 		// 1-100中所有能被num整除的数
    6. 		Scanner myScanner = new Scanner(System.in);
    7. 		int num = myScanner.nextInt();
    8. 		int end = 100;
    9. 		int i = 1;
    10. 		while(i <= end){
    11. 			if(i % num == 0){
    12. 				System.out.println(i);
    13. 			}
    14. 			i++;
    15. 		}
    16. 	}
    17. }

    （三）do while循环

    基本语法：

    do{

            循环体（语句）;

            循环变量迭代;

    }while(循环条件);

    说明：先执行再判断，至少执行一次

    1.  
    2. public class DoWhile02{
    3.  
    4. 	public static void main(String[] args){
    5. 		// 统计1-200中能被5整除但不能被3整除的数的个数
    6. 		int end = 200;
    7. 		int i = 1;
    8. 		int count = 0;
    9. 		do{
    10. 			if(i % 5 == 0 && i % 3 != 0){
    11. 				count++;
    12. 			}
    13. 			i++;
    14. 		}while(i <= end);
    15. 		System.out.println("count=" + count);
    16. 	}
    17. }

    （四）多重循环控制

    1、将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for,while,do..while均可以作为外层循环和内层循环。（建议一般使用两层，最多不要超过3层，否则代码的可读性很差）

    2、实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

    3、设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

     九九乘法表：

    1. public class MulFor02{
    2.  
    3. 	public static void main(String[] args){
    4. 		
    5. 		for(int i = 1; i <= 9; i++){
    6. 			for(int j = 1; j <= i; j++){
    7. 				System.out.print(j + "*" + i + "=" + j * i + '\t');
    8. 			}
    9. 			System.out.println('\n');
    10. 		}
    11. 	}
    12. }

     （五）跳转控制语句-break

    break语句用于终止某个语句块的执行，一般使用在switch或者循环中。

     注意事项和说明：

    1、break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块

    2、标签的基本使用：

    label1:{ ......

    label2:        {......

    label3:                {   ......

                                    break label2;

                                    ......

                                }

                         }

                  }

    （1）break语句可以指定退出哪层

    （2）label1是标签，由程序员指定

    （3）break后指定到哪个label就退出到哪里

    （4）实际开发中，尽量不要使用标签

    （5）如果没有指定break，默认退出最近的循环体

    1.  
    2. public class Break01{
    3.  
    4. 	public static void main(String[] args){
    5. 		
    6. 		label1:
    7. 		for(int i = 0; i < 4; i++){
    8. 			label2:
    9. 			for(int j = 0; j < 10; j++){
    10. 				if(j == 2){
    11. 					break label1;
    12. 				}
    13. 				System.out.println("j = " + j);
    14. 			}
    15. 		}
    16. 	}
    17. }

    （六）跳转控制语句-continue

    1、continue语句用于结束本次循环，继续执行下一次循环

    2、continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用规则一样。

    1.  
    2. public class Continue01{
    3.  
    4. 	public static void main(String[] args){
    5. 		
    6. 		label1:
    7. 		for(int i = 0; i < 4; i++){
    8. 			label2:
    9. 			for(int j = 0; j < 10; j++){
    10. 				if(j == 2){
    11. 					// continue; //等价于continue label2
    12. 					// continue label2;
    13. 					continue label1;
    14. 				}
    15. 				System.out.println("j = " + j);
    16. 			}
    17. 		}
    18. 	}
    19. }

    （七）跳转控制语句-return

    return使用在方法，表示跳出所在的方法。如果return写在main方法，退出程序。

    1.  
    2. public class Return01{
    3.  
    4. 	public static void main(String[] args){
    5. 		
    6. 		for(int i = 1; i <= 5; i++){
    7. 			if(i == 3){
    8. 				System.out.println("hello" + i);
    9. 				return;
    10. 			}
    11. 			System.out.println("hello world!");
    12. 		}
    13. 		System.out.println("go on...");
    14. 	}
    15. }

     

  • 相关阅读:
    计算机毕设 大数据电商用户行为分析 -python 大数据
    牛逼！2022 最新 Spring 面试题
    STM32 + CT1711超级准的人体测温方案
    03-瑞吉外卖关于菜品/套餐分类表的增删改查
    快速搜索多个word、excel等文件中内容
    kvm 创建win11虚拟机
    react--redux
    Go语言 Map教程
    HTML+CSS+JS静态网页设计【篮球NBA介绍体育运动】web前端学生作业源码
    【附源码】计算机毕业设计SSM万达影院售票管理系统
  • 原文地址：https://blog.csdn.net/weixin_45827876/article/details/133806142