• java基本语法 下

    目录

    运算符

    运算符：算术运算符

    运算符：赋值运算符

    运算符：比较运算符

    运算符：逻辑运算符

    运算符：三元运算符

    运算符的优先级

     程序流程控制

    概念

    顺序结构

    if-else结构

    switch-case结构

    循环结构

     循环结构之for循环

    循环结构之while循环

    循环结构之do-while循环

    嵌套循环结构

    break、continue

    break的使用 终止本次循环

    continue的使用   跳过本层循环

    运算符

    运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
    • 算术运算符
    • 赋值运算符
    • 比较运算符（关系运算符）
    • 逻辑运算符
    • 位运算符（了解）
    • 三元运算符

    运算符：算术运算符

     术运算符的注意问题

    • 如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。
    • 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
    • +”除字符串相加功能外，还能把非字符串转换成字符串
    • 前++ ：先自增 后运算        后++ 先运算 后自增 :不会改变本身变量的数据类型，

        注意点 取余运算% 结果的符号与被取余的符号相同，整型和整型做运算得到的是int类型 

    1. class AirrTest 
    2. /*
    3. 运算符之一 算数运算符
    4. + - + - / % 前++ 后++ 前-- 后--
    5. 除法运算取商数 取余运算取余数
    6. */
    7. {
    8. 	public static void main(String[] args) 
    9. 	{
    10. 		//除号 /
    11. 		int num1=12;
    12. 		int num2=5;
    13. 		//整型和整型做运算得到的是int类型 2
    14. 		int result=num1 / num2;
    15. 		//0.0是double类型，所以num2+0.0是double类型 2.4
    16. 		double resul2=num1 /(num2+0.0);
    17. 		double result3=num1/ (double)num2;
    18. 		System.out.println(result3);
    19.  
    20. 		//取余运算% 结果的符号与被取余的符号相同
    21. 		int m1=12;
    22. 		int m2=-5;
    23. 		System.out.println("res1"+ m1%m2);//2
    24. 		int m3=-12;
    25. 		int m4=5;
    26. 		System.out.println("res2"+m3%m4);//-2
    27. 		int m5=-12;
    28. 		int m6=-5;
    29. 		System.out.println("res3"+m5%m6);//-2、
    30.  
    31. 		//前++ ：先自增 后运算
    32. 		//后++ 先运算 后自增
    33. 		int a1=10;
    34. 		int b1=++a1;
    35. 		System.out.println("a1="+a1+",b1="+b1);//11 11
    36. 		int a2=10;
    37. 		int b2=a2++;
    38. 		System.out.println("a2="+a2+",b2="+b2);//11 10
    39. 		//注意点 :不会改变本身变量的数据类型
    40. 		short s1=10;
    41. 		//s1=s1+1;
    42.  
    43. 		//前-- ：先自增 后运算
    44. 		//后-- 先运算 后自增
    45. 		int a3=10;
    46. 		int b3=--a3;
    47. 		System.out.println("a3="+a3+",b3="+b3);//11 11
    48. 		int a4=10;
    49. 		int b4=a4--;
    50. 		System.out.println("a4="+a4+",b4="+b4);//11 10
    51.  
    52. 		}
    53. }

    运算符：赋值运算符

    • 符号：=  当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制
    • 类型转换原则进行处理。 支持连续赋值。
    • 扩展赋值运算符： +=, -=, *=, /=, %=
    1. class setValue
    2. // 赋值 = += *= /= %=
    3. {
    4. 	public static void main(String[] args) 
    5. 	{
    6. 	//赋值符号=
    7. 	int j1=10;
    8. 	int j2=20;
    9. 	 //连续赋值
    10. 	 int i1,i2;
    11. 	 i1=i2=10;
    12. 	 int i3=10,j3=20;
    13.  
    14. 	 //********
    15. 	 int num=10;
    16. 	 num+=2;//mum=num+2
    17. 	 short s1=10;
    18. 	// s1=s1+2;编译失败
    19. 	s1+=2;// 不会改变 变量本身数据类
    20. 	System.out.println("Hello World!");
    21. 	}
    22. }

    运算符：比较运算符

     比较运算符的结果都是boolean型，也就是要么是true，要么是false。

    比较运算符“==”不能误写成“=” 。

    1.  
    2. /*
    3. 运算符之三 比较运算符
    4. == != > < >= <= instanceof
    5. 比较运算符的结果是boolean类型
    6.  
    7. */
    8.  
    9. class compare 
    10. {
    11. 	public static void main(String[] args) 
    12. 	{	
    13. 		boolean i=true;
    14. 		boolean  j=false;
    15. 		
    16. 		System.out.println(i==j);//false
    17. 		System.out.println(j=i);//false
    18. 	}
    19. }

    运算符：逻辑运算符

    • &—逻辑与
    • | —逻辑或
    • ！—逻辑非
    • && —短路与
    • || —短路或
    • ^ —逻辑异或

     

    逻辑运算符用于连接布尔型表达式，在Java中不可以写成3，应该写 成x>3 & x<6 。

    &”和“&&”的区别：

    • 单&时，左边无论真假，右边都进行运算；
    • 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
    • “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。

    异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。  理解：异或，追求的是“异”

    1. /*
    2. 运算符之四：逻辑运算符
    3. & && | || ！ ^
    4.  
    5. && 与 & 运算结果是相同的，符号左边是true时 都会执行右边的运算
    6. 		当符号左边是false时，&继续执行右边的运算，&&不在执行右边的运算
    7. || 与 | 运算结果是相同的，符号左边是false时 都会执行右边的运算
    8. 		当符号左边是true时，|继续执行右边的运算，||不在执行右边的运算
    9.  
    10.  
    11. 逻辑运算符操作的都是Boolean类型	
    12. */
    13. class logic {
    14. 	public static void main(String[] args){
    15. 	
    16. 	//逻辑与
    17. 	boolean b1=false;
    18. 	int num1=10;
    19. 	if(b1&(num1++>0)){
    20. 		System.out.println("真的");
    21. 	}else{
    22. 		System.out.println("假的");
    23. 	}
    24. 	System.out.println("num1："+num1);
    25.  
    26. 	//短路与
    27. 	boolean b2=false;
    28. 	int num2=10;
    29. 	if(b2&&(num2++>0)){
    30. 		System.out.println("真的");
    31. 	}else{
    32. 		System.out.println("假的");
    33. 	}
    34. 	System.out.println("num2："+num2);
    35.  
    36. // 逻辑或
    37.  
    38. 	boolean b3=true;
    39. 	int num3=10;
    40. 	if(b3|(num3++>0)){
    41. 		System.out.println("真的");
    42. 	}else{
    43. 		System.out.println("假的");
    44. 	}
    45. 	System.out.println("num3："+num3);
    46.  
    47. 	//短路或
    48. 	boolean b4=true;
    49. 	int num4=10;
    50. 	if(b4 ||(num4++>0)){
    51. 		System.out.println("真的");
    52. 	}else{
    53. 		System.out.println("假的");
    54. 	}
    55. 	System.out.println("num4："+num4);
    56.  
    57. }
    58. }

    运算符：三元运算符

    表达式1和表达式2为同种类型

    三元运算符与if-else的联系与区别：

    • 1）三元运算符可简化if-else语句
    • 2）三元运算符要求必须返回一个结果。
    • 3）if后的代码块可有多个语句
    1.  
    2. class sanYuan 
    3. /*
    4. 运算符之五：三元运算符
    5. 结构条件表达式？（表达式1：表达式2）
    6. 根据表达式真或假 决定执行表达式1或表达式2
    7. 	表达式为true，则执行表达式1
    8. 	表达式为false 则执行表达式2
    9. 	表达式1与表达式2的类型要求是一致的
    10. 	三元运算符可以嵌套使用
    11. 	凡是可以使用三元运算符的地方都可以改写为if---else,反之不可以
    12. */
    13. {
    14. 	public static void main(String[] args) {
    15. 	//获取两个整数的较大值
    16. 	int m=12;
    17. 	int n=12;
    18. 	int max=(m>n)?m:n;
    19. 	String maxstr=m>n?"m大":((m==n)?"m和n相等":"n大");
    20. 	if(m>n){
    21. 	System.out.println(m);
    22. 	}else{
    23. 	System.out.println(n);
    24. 	}
    25. 	System.out.println(maxstr);
    26. 	}
    27.  
    28. }

    运算符的优先级

    • 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序 
    • 只有单目运算符、三元运算符、 赋值运算符是从右向左运算的

     程序流程控制

    概念

    流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组 合成能完成一定功能的小逻辑模块。  其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：

    • 顺序结构  程序从上到下逐行地执行，中间没有任何判断和跳转。
    • 分支结构 根据条件，选择性地执行某段代码 有if…else和switch-case两种分支语句
    • 循环结构 根据循环条件，重复性的执行某段代码 有while、do…while、for三种循环语句。
    注： JDK1.5 提供了 foreach 循环，方便的遍历集合、数组元素。

    顺序结构

    顺序结构 Java中定义成员变量时采用合法的 前向引用 。如

     

    1. Java中定义成员变量时采用合法的前向引用。如：
    2. public class Test{
    3. int num1 = 12;
    4. int num2 = num1 + 2;
    5. }
    6. 错误形式：
    7. public class Test{
    8. int num2 = num1 + 2；
    9. int num1 = 12;
    10. }

    if-else结构

     

    • 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
    • 语句块只有一条执行语句时，一对{}可以省略，但建议保留
    • if-else语句结构，根据需要可以嵌套使用
    • 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
    • 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓
    • 当多个条件是“包含”关系时，“小上大下 / 子上父下”
    1. /*
    2. 分支结构中的if--else
    3. 三种结构
    4.  
    5. 第一种
    6. if（条件表达式）{执行表达式}
    7.  
    8. 第二种 二选一
    9. if（条件表达式）{
    10. 	执行表达式1
    11. }else{
    12. 	执行表达式2
    13. }
    14. 第三种 多选一
    15.  
    16. if（条件表达式）{
    17. 	执行表达式1
    18. }else if（条件表达式）{
    19. 	执行表达式2
    20. }else{
    21. 	执行表达式3
    22. }
    23.  
    24.  
    25. */
    26.  
    27.  
    28. class ifTest 
    29. {
    30. 	public static void main(String[] args) 
    31. 	{ 
    32. 		int n=10;
    33. 		int m=5;
    34. 		if(m>n){
    35. 				System.out.println("m:"+m);
    36. 		}else if(m==n){
    37. 					System.out.println("相等");
    38. 		}else{
    39. 				System.out.println("n:"+n);
    40. 		}
    41. 		System.out.println("Hello World!");
    42. 	}
    43. }

    switch-case结构

     

    • switch(表达式)中表达式的值必须是下述几种类型之一：byte，short， char，int，枚举 (jdk 5.0)，String (jdk 7.0)；
    • case子句中的值必须是常量，不能是变量名或不确定的表达式值；
    • 同一个switch语句，所有case子句中的常量值互不相同；
    • break语句用来在执行完一个case分支后使程序跳出switch语句块；如 果没有break，程序会顺序执行到switch结尾
    • default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时， 执行default
    1. /*
    2. 分支结构之二：switch-case
    3.  
    4. 1.格式
    5. switch(表达式){
    6. case 常量1:
    7. 	执行语句1;
    8. 	//break;
    9.  
    10. case 常量2:
    11. 	执行语句2;
    12. 	//break;
    13.  
    14. ...
    15.  
    16. default:
    17. 	执行语句n;
    18. 	//break;
    19.  
    20. }
    21.  
    22. 2.说明：
    23. ① 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
    24.   当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构
    25.   末尾结束为止。
    26.  
    27. ② break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构
    28.  
    29. ③ switch结构中的表达式，只能是如下的6种数据类型之一：
    30.    byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)
    31.  
    32. ④ case 之后只能声明常量。不能声明范围。
    33.  
    34. ⑤ break关键字是可选的。
    35.  
    36. ⑥ default:相当于if-else结构中的else.  
    37.   default结构是可选的，而且位置是灵活的。
    38. */
    39.  
    40. class SwitchCaseTest {
    41. 	public static void main(String[] args) {
    42. 		
    43. 		int number = 5;
    44. 		switch(number){
    45. 		
    46. 		case 0:
    47. 			System.out.println("zero");
    48. 			break;
    49. 		case 1:
    50. 			System.out.println("one");
    51. 			break;
    52. 		case 2:
    53. 			System.out.println("two");
    54. 			break;
    55. 		case 3:
    56. 			System.out.println("three");
    57. 			break;
    58. 		default:
    59. 			System.out.println("other");
    60. 			//break;
    61. 		}
    62.  
    63.  
    64. 		String season = "summer";
    65. 		switch (season) {
    66. 		case "spring":
    67. 			System.out.println("春暖花开");
    68. 			break;
    69. 		case "summer":
    70. 			System.out.println("夏日炎炎");
    71. 			break;
    72. 		case "autumn":
    73. 			System.out.println("秋高气爽");
    74. 			break;
    75. 		case "winter":
    76. 			System.out.println("冬雪皑皑");
    77. 			break;
    78. 		default:
    79. 			System.out.println("季节输入有误");
    80. 			break;
    81. 		}
    82.  
    83.  
    84.  
    85. 		//**************如下的两种情况都编译不通过*********************
    86. 		//情况一
    87. 		/*
    88. 		boolean isHandsome = true;
    89. 		switch(isHandsome){
    90. 		
    91. 		case true:
    92. 			System.out.println("我好帅啊~~~");
    93. 			break;
    94. 		case false:
    95. 			System.out.println("我好丑啊~~~");
    96. 			break;
    97. 		default:
    98. 			System.out.println("输入有误~~~");
    99. 		}
    100. 		*/
    101. 		//情况二
    102. 		/*
    103. 		int age = 10;
    104. 		switch(age){
    105. 		case age > 18:
    106. 			System.out.println("成年了");
    107. 			break;
    108. 		default:
    109. 			System.out.println("未成年");
    110. 		}
    111. 		*/
    112. 	}
    113. }
    f 和 switch 语句很像，具体什么场景下，应用哪个语句呢？
    • 如果判断的具体数值不多，而且符合byte、short 、char、int、String、枚举等几种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。
    • 其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。
    • 也就是说，使用switch-case的，都可以改写为if-else。反之不成立。

    循环结构

    循环结构 在某些条件满足的情况下，反复执行特定代码的功能

    循环语句分类  for 循环  while 循环  do-while 循环

    循环语句的四个组成部分 

    • 初始化部分(init_statement)
    • 循环条件部分(test_exp)
    • 循环体部分(body_statement)
    • 迭代部分(alter_statement)

     循环结构之for循环

    语法格式

    for (①初始化部分; ②循环条件部分; ④迭代部分)｛

    ③循环体部分;

    ｝

    执行过程： ①-②-③-④-②-③-④-②-③-④-.....-②

    说明：

    • ②循环条件部分为boolean类型表达式，当值为false时，退出循环
    • ①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
    • ④可以有多个变量更新，用逗号分隔

     

    1. /*
    2. For循环结构的使用
    3. 一、循环结构的4个要素
    4. ① 初始化条件
    5. ② 循环条件  --->是boolean类型
    6. ③ 循环体
    7. ④ 迭代条件
    8.  
    9. 二、for循环的结构
    10.  
    11. for(①;②;④){
    12. 	③
    13. }
    14.  
    15. 执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
    16.  
    17. */
    18. class ForTest {
    19. 	public static void main(String[] args) {
    20.  
    21. 		/*
    22. 		System.out.println("Hello World!");
    23. 		System.out.println("Hello World!");
    24. 		System.out.println("Hello World!");
    25. 		System.out.println("Hello World!");
    26. 		System.out.println("Hello World!");
    27. 		*/
    28.  
    29. 		for(int i = 1;i <= 5;i++){//i:1,2,3,4,5
    30. 			System.out.println("Hello World!");
    31. 		}
    32. 		//i:在for循环内有效。出了for循环就失效了。
    33. 		//System.out.println(i);
    34. 		
    35. 		//练习：
    36. 		int num = 1;
    37. 		for(System.out.print('a');num <= 3;System.out.print('c'),num++){
    38. 			System.out.print('b');
    39. 		}
    40. 		//输出结果：abcbcbc
    41.  
    42. 		System.out.println();
    43.  
    44. 		//例题：遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
    45. 		int sum = 0;//记录所有偶数的和
    46. 		int count = 0;//记录偶数的个数
    47. 		for(int i = 1;i <= 100;i++){
    48. 			
    49. 			if(i % 2 == 0){
    50. 				System.out.println(i);
    51. 				sum += i;
    52. 				count++;
    53. 			}
    54. 			//System.out.println("总和为：" + sum);
    55. 		}
    56.  
    57. 		System.out.println("总和为：" + sum);
    58. 		System.out.println("个数为：" + count);
    59.  
    60. 	}
    61. }

    循环结构之while循环

    语法格式

    ①初始化部分

    while(②循环条件部分)｛

    ③循环体部分;

    ④迭代部分;

    }

    执行过程： ①-②-③-④-②-③-④-②-③-④-...-②

    说明：

    • 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
    • for循环和while循环可以相互转换
    1. /*
    2. While 循环的使用
    3.  
    4. 一、循环结构的4个要素
    5. ① 初始化条件
    6. ② 循环条件  --->是boolean类型
    7. ③ 循环体
    8. ④ 迭代条件
    9.  
    10. 二、while循环的结构
    11.  
    12. ①
    13. while(②){
    14. 	③;
    15. 	④;
    16. }
    17.  
    18. 执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
    19.  
    20. 说明：
    21. 1.写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
    22. 2.我们写程序，要避免出现死循环。
    23. 3.for循环和while循环是可以相互转换的！ 
    24.   区别：for循环和while循环的初始化条件部分的作用范围不同。
    25.  
    26.  
    27. 算法：有限性。
    28.  
    29. */
    30. class  WhileTest{
    31. 	public static void main(String[] args) {
    32. 		
    33. 		//遍历100以内的所有偶数
    34. 		int i = 1;
    35. 		while(i <= 100){
    36. 			
    37. 			if(i % 2 == 0){
    38. 				System.out.println(i);
    39. 			}
    40. 			
    41. 			i++;
    42. 		}
    43. 		//出了while循环以后，仍可以调用。
    44. 		System.out.println(i);//101
    45.  
    46. 	}
    47. }

    循环结构之do-while循环

    语法格式

    ①初始化部分;

    do{

    ③循环体部分

    ④迭代部分

    }while(②循环条件部分);

    执行过程： ①-③-④-②-③-④-②-③-④-...②

    说明： do-while循环至少执行一次循环体。

    1. /*
    2. do-while循环的使用
    3.  
    4. 一、循环结构的4个要素
    5. ① 初始化条件
    6. ② 循环条件  --->是boolean类型
    7. ③ 循环体
    8. ④ 迭代条件
    9.  
    10. 二、do-while循环结构：
    11.  
    12. ①
    13. do{
    14. 	③;
    15. 	④;
    16.  
    17. }while(②);
    18.  
    19. 执行过程：① - ③ - ④ - ② - ③ - ④ - ... - ②
    20.  
    21. 说明：
    22. 1.do-while循环至少会执行一次循环体！
    23. 2.开发中，使用for和while更多一些。较少使用do-while
    24.  
    25. */
    26. class DoWhileTest {
    27. 	public static void main(String[] args) {
    28. 		
    29. 		//遍历100以内的偶数,并计算所有偶数的和及偶数的个数
    30. 		int num = 1;
    31. 		int sum = 0;//记录总和
    32. 		int count = 0;//记录个数
    33. 		do{
    34. 			
    35. 			if(num % 2 == 0){
    36. 				System.out.println(num);
    37. 				sum += num;
    38. 				count++;
    39. 			}
    40.  
    41. 			num++;
    42.  
    43. 		}while(num <= 100);
    44. 		
    45.  
    46. 		System.out.println("总和为：" + sum);
    47. 		System.out.println("个数为：" + count);
    48.  
    49. 		//*************体会do-while至少执行一次循环体***************
    50. 		int number1 = 10;
    51. 		while(number1 > 10){
    52. 			System.out.println("hello:while");
    53. 			number1--;
    54. 		}
    55.  
    56. 		int number2 = 10;
    57. 		do{
    58. 			System.out.println("hello:do-while");
    59. 			number2--;
    60. 		}while(number2 > 10);
    61.  
    62. 	}
    63. }

    嵌套循环结构

    将一个循环放在另一个循环体内，就形成了嵌套循环。其中， for ,while ,do…while均可以作为外层循环或内层循环。

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

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

    1. /*
    2. 嵌套循环的使用
    3. 1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环
    4.  
    5. 2.
    6. 外层循环：循环结构B
    7. 内层循环：循环结构A
    8.  
    9. 3. 说明
    10. ① 内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
    11. ② 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次
    12.  
    13. 4. 技巧：
    14.    外层循环控制行数，内层循环控制列数
    15. */
    16. class ForForTest {
    17. 	public static void main(String[] args) {
    18. 		
    19. 		//******
    20. 		//System.out.println("******");
    21. 		for(int i = 1;i <= 6;i++){
    22. 			System.out.print('*');
    23. 		}
    24.  
    25. 		System.out.println("\n");
    26.  
    27. 		/*
    28. 		******
    29. 		******
    30. 		******
    31. 		******
    32. 		*/
    33. 		for(int j = 1;j <= 4;j++ ){
    34. 			for(int i = 1;i <= 6;i++){
    35. 				System.out.print('*');
    36. 			}
    37. 			System.out.println();
    38. 		}
    39.  
    40. 		/*			i(行号)		j(*的个数)
    41. 		*			1			1
    42. 		**			2			2
    43. 		***			3			3
    44. 		****		4			4
    45. 		*****		5			5
    46. 		*/
    47.  
    48. 		for(int i = 1;i <= 5;i++){//控制行数
    49. 			for(int j = 1;j <= i;j++){//控制列数
    50. 				System.out.print("*");
    51. 			
    52. 			}
    53. 			System.out.println();
    54. 		}
    55. 		
    56. 		/*			i(行号)		j(*的个数)   规律：i + j = 5 换句话说：j = 5 - i;
    57. 		****		1			4
    58. 		***			2			3
    59. 		**			3			2
    60. 		*			4			1
    61. 		*/	
    62.  
    63. 		for(int i = 1;i <= 4;i++){
    64. 			for(int j = 1;j <= 5 - i;j++){
    65. 				System.out.print("*");	
    66. 			}
    67. 			System.out.println();
    68. 		}
    69. 	}
    70. }

    break、continue

    break的使用 终止本次循环

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

    continue的使用   跳过本层循环

    • continue只能使用在循环结构中
    • continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
    • continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
    1. /*
    2. break和continue关键字的使用
    3. 				使用范围			循环中使用的作用(不同点)		相同点
    4. break:			switch-case			
    5. 				循环结构中			结束当前循环					关键字后面不能声明执行语句	
    6.  
    7. continue:		循环结构中			结束当次循环					关键字后面不能声明执行语句
    8.  
    9.  
    10.  
    11. */
    12. class BreakContinueTest {
    13. 	public static void main(String[] args) {
    14.  
    15. 		for(int i = 1;i <= 10;i++){
    16. 		
    17. 			if(i % 4 == 0){
    18. 				break;//123
    19. 				//continue;//123567910
    20. 				//System.out.println("今晚迪丽热巴要约我！！！");
    21. 			}
    22. 			System.out.print(i);
    23. 		}
    24.  
    25. 		System.out.println("\n");
    26. 		//******************************
    27. 		
    28. 		label:for(int i = 1;i <= 4;i++){
    29. 		
    30. 			for(int j = 1;j <= 10;j++){
    31. 				
    32. 				if(j % 4 == 0){
    33. 					//break;//默认跳出包裹此关键字最近的一层循环。
    34. 					//continue;
    35.  
    36. 					//break label;//结束指定标识的一层循环结构
    37. 					continue label;//结束指定标识的一层循环结构当次循环
    38. 				}
    39. 				
    40. 				System.out.print(j);
    41. 			}
    42. 			
    43. 			System.out.println();
    44. 		}
    45. 	}
    46. }

     

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

    • 二者功能类似，但continue是终止本次循环，break是终止本层循环。
    • break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
    • 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。

  • 相关阅读:
    快速排序 O(nlgn)
    K8S名称空间和资源配额
    数仓：数仓建设中的数据建模和日志体系
    Android通知监听服务之NotificationListenerService使用篇
    二进制、八进制、十进制、十六进制之间的转换
    HuggingFace 国内下载 阿里云盘下载速度20MB/s
    Vuex：辅助函数：mapState，mapMutations，mapActions，mapGetters
    零基础 从 yolo8 入门计算机视觉超简单：物体识别、图像分类、轨迹追踪、姿势识别
    SV--面向对象class（三）
    Jsoup抓取Https出现unable to find valid certification path to requested target
  • 原文地址：https://blog.csdn.net/qq_63358859/article/details/128053789