一、分支结构之if
1.1 单分支
if(布尔表达式){
//代码块
}
代码执行到if，会对布尔表达式进行判断。
为true，则执行代码块。
为false，跳过代码块，执行后续的代码。
package com.atguigu.a_if;
/*
* 单分支：只能对表达式判断后，满足为true的结果。
* 如果要进行false的结果的处理，则再需要写一个if单分支
*
* */
public class SingleIfTest1 {
public static void main(String[] args) {
int age = 18;
if(age >=18){
System.out.println("成年了！可以上网吧了！");
}
if(age <18){
System.out.println("未成年！不可以上网，但是可以去游戏厅！");
}
System.out.println("程序结束！");
}
}
1.2 双分支结构
if(布尔表达式){
//代码块1
}else{
//代码块2
}
代码执行到if，会对布尔表达式进行判断。
为true，则执行代码块1。
为false，则执行代码块2。
再执行后续的代码。
package com.atguigu.a_if;
public class ifElseTest2 {
public static void main(String[] args) {
int age = 15;
if(age >=18){
System.out.println("可以放肆的玩王者荣耀了！");
}else{
System.out.println("需要借家长的脸，玩王者荣耀！");
}
System.out.println("程序结束！");
}
}
package com.atguigu.a_if;
/*
* if-else结构，开发最常用的！！！！
* if(isVip){可以看}else{不可以看}
* 经验：简单的双分支if-else结构，代码块要的是结果。可以选择条件表达式进行简化。
* */
public class IfElseExerTest3 {
public static void main(String[] args) {
/*
* 对年份做判断 是否为闰年。
* 判断标准：1.能被400整除
* 2.能被4整除，且不能被100整除
* */
int year = 2024;
if(year % 400 == 0 || year % 4==0 && year%100 !=0){
System.out.println(year+"年是闰年");
}else{
System.out.println(year+"年不是闰年");
}
System.out.println("程序结束");
}
}
class IfElseExerTest4{
public static void main(String[] args) {
int year = 2024;
String isRun = year %400 ==0 || year%4==0&&year%100!=0?"是闰年":"不是闰年";
System.out.println(year+isRun);
}
}
1.3 多分支
适用于范围判断！
if(布尔表达式1){
//代码块1
}else if(布尔表达式2){
//代码块2
}else if(布尔表达式3){
//代码块3
}else{
//代码块4
}
代码执行到if，对布尔表达式1做判断，为true，则执行代码块1，然后跳出整个多重if结构。
布尔表达式1为false，则执行布尔表达式2，为true，则执行代码块2，然后跳出整个多重if结构。
布尔表达式2为false，则执行布尔表达式3，为true，则执行代码块3，然后跳出整个多重if结构。
如果所有布尔表达式均为false，则执行else。else是可选的。但是一般都写！
package com.atguigu.a_if;
/*
* 区间判断。
* 自顶向下，逐个条件判断，满足则执行对应的代码块，然后跳出整个结构。
* if(isWhiteVip){}else if(isGoldVip){}else{试看6分钟}
*
* */
public class MoreIfTest4 {
public static void main(String[] args) {
int money = 36;//单位是万
/*if(money >=50){
System.out.println("买BMW 525Li");
}else if(money >=40){//money <50
System.out.println("买坦克 700 Hi4-T");
}else if(money >=30){// && money <40
System.out.println("买浴皇大帝凯迪拉克CT5");
}else if(money >= 20 ){//&& money <30
System.out.println("买小米Su7 ultra");
}else{
System.out.println("买个捷安特自行车！");
}
*/
System.out.println("购车之旅结束了！");
}
}
1.4 嵌套if分支结构
if(外层布尔表达式){
if(内层布尔表达式){
//代码块1
}else{
//代码块2
}
}else{
//代码块3
}
先执行外层布尔表达式的判断，满足进入结构，判断内层布尔表达式。满足，则执行代码块1。
外层布尔表达式为false，则执行else中的代码块3，不执行内层布尔表达式的判断。
package com.atguigu.a_if;
/*
* 在if选择结构正确的情况下，支持互相嵌套。
* if->if,if-else,if else if else if
* else->if,if-else,if else if else if
* */
public class NestedIfTest5 {
public static void main(String[] args) {
//100米赛跑，跑进15秒，进入决赛。
//再根据性别分组，进入男子组或女子组。
double time = 30;
char gender = '男';
if(time <=15){
//进入决赛，根据性别分组。
if(gender == '男'){
System.out.println("进入男子组决赛！");
}else{
System.out.println("进入女子组决赛！");
}
}else{
System.out.println("跑的这么慢，回去再练两年半");
}
System.out.println("百米决赛分组成功！");
}
}
class NestedIfTest6 {
public static void main(String[] args) {
//请从控制台输入考试成绩
Scanner input = new Scanner(System.in);
System.out.println("请输入你的期末考试成绩：");
double score = input.nextDouble();
if(score>=60){
//及格了，后续做一些奖励
if(score == 100){
System.out.println("奖励一部华为 pura 70 pro +");
}else if(score >=80){
System.out.println("奖励一部小米14 ultra");
}else if(score >=70){
System.out.println("奖励一份三年高考，五十年模拟");
}else{//score >=60 && score <70
System.out.println("奖励补课100节");
}
}else{
if(score >=30){
System.out.println("给俩嘴巴子得了！");
}else{
System.out.println("学习不好，又不是没出路！去缅甸旅游一个月");
}
}
System.out.println("考试结束！");
}
}
二、分支结构之switch
2.1 概念
switch选择结构适用于等值判断。
switch(表达式){
case 常量值1:
//代码块1;
[break;]
case 常量值2:
//代码块2;
[break;]
case ...:
//代码块N
[break;]
[default:
//默认代码块
[break;]
]
}
程序执行到switch结构，对()里的表达式做值的运算，匹配对应的case，执行代码块。
如果没有匹配的case，则执行default代码块。
package com.atguigu.b_switch;
import java.util.Scanner;
/*
* switch做的是等值判断。对()里的表达式/变量的值，做判断，匹配对应的case.执行代码，break;用于跳出整个switch结构
* break：用于跳出结构
* default可写可不写，但是一般会写。用于没有匹配的case，执行的代码。当所有的case都不匹配时，会执行default
* */
public class SwitchTest1 {
public static void main(String[] args) {
/*
* 从控制台输入数字，对数字，做转换成人民币的大写字母
* 1 -> 壹 2->贰 3->叁
* */
Scanner input = new Scanner(System.in);
System.out.println("请输入一个整数：");
int num = input.nextInt();
switch (num){
case 1:
System.out.println("壹壹壹");
break;
case 2:
System.out.println("贰贰贰");
break;
case 3:
System.out.println("叁叁叁");
default:
System.out.println("请输入正确的1、2、3的数字！");
break;
}
System.out.println("程序结束");
input.close();
}
}
2.2 switch支持的类型
package com.atguigu.b_switch;
/*
* switch()支持的类型byte、short、int、char、String、枚举（后面的）
* case 常量值：固定不变的值。可以是显示的值，也可以是表达式 结果是固定的
* break ：跳出、结束switch结构。不写，会造成case的穿透性
*
* */
public class SwitchTest2 {
public static void main(String[] args) {
// int num = 10;
//支持变量、表达式
// boolean flag = true;
// byte b = 1;
char c = 'A';
switch (c){//byte、short、int、char、String、枚举（后面的）
case 'A':
System.out.println("字母A");
// break;
case 'B':
System.out.println("字母B");
break;
default:
System.out.println("没有这个字母！");
break;
}
String season = "夏天";
switch (season){
case "春天":
System.out.println("春暖花开");
break;
case "夏天":
System.out.println("烈日炎炎");
break;
case "秋天":
System.out.println("硕果累累");
break;
case "冬天":
System.out.println("白雪皑皑");
break;
}
}
}
2.3 switch的细节案例
package com.atguigu.b_switch;
public class SwitchTest3 {
public static void main(String[] args) {
/*
* 定义一个月份变量，输出该月份的天数
* 1 3 5 7 8 10 12 31天
* 4 6 9 11 30天
* 2 28
* 利用break的穿透性，减少代码的冗余！
* */
int year = 2023;//年份的变量
int month = 2;//月份的变量
//定义一个接受结果的变量
String result = "";//在case里对result做赋值。最终只有一个结果
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
result = "31天";
break;
case 2:
if (year % 400 == 0 || year % 4 == 0 && year % 100 != 0) {
result = "29天";
} else {
result = "28天";
}
//todo 自己写成条件表达式。简化该操作。
break;
case 4:
case 6:
case 9:
case 11:
// System.out.println("30天");
result = "30天";
break;
default:
System.out.println("请输入正确的月份！");
break;
}
System.out.println(month + "月有" + result);
}
}
2.4 switch的新特性（JDK版本的新特性）
package com.atguigu.b_switch;
/*
* 1.支持case后写多个常量 case 常量,常量,常量
* 2.-> 操作符：
* 1.可以避免穿透，,可以省略break;
* 2.case里的代码>1行，要加{}
* 3.switch支持返回结果给变量赋值。case块里的代码直接就是值，只写值即可。
* 4.如果switch返回的结果是要通过逻辑的计算的。配合yield关键字进行返回。
*
* */
public class NewSwitchTest4 {
public static void main(String[] args) {
int year = 2023;//年份的变量
int month = 2;//月份的变量
//定义一个接受结果的变量
//在case里对result做赋值。最终只有一个结果
String result = switch (month) {
case 1,3,5,7,8,10,12->
"31天";
case 2->{
if (year % 400 == 0 || year % 4 == 0 && year % 100 != 0) {
yield "29天";
} else {
yield "28天";
}
}
case 4,6,9,11->
// System.out.println("30天");
"30天";
default->
"请输入正确的月份！";
};
System.out.println(month + "月有" + result);
}
}
三、循环结构
3.1 概念
-
循环：在单圈400米的跑道，完成1万米长跑，从第一圈开始跑，跑25圈，满足条件，循环跑步操作就结束了。
-
程序中的循环：通过某个条件的判断，重复的执行一段代码。判断条件为false时，循环结束，继续执行后续的代码。
-
循环的组成部分：
- 初始部分
- 循环条件
- 循环体
- 迭代部分
3.2 for循环
- 打印5遍HelloWorld
package com.atguigu.c_for;
/*
* 循环结构的组成：
* 1.初始部分：初始化一个变量，用于迭代增量及条件判断
* 2.循环条件 boolean表达式，用初始部分做条件判断，满足则执行循环体，反之，跳出循环结构
* 3.循环体 需要反复执行的一段代码。
* 4.迭代部分 控制初始部分的变量值的增长，影响循环条件
* 1->2->3->4->2->3->4->2->3->4......2不满足则跳出整个循环结构
*
* 迭代部分：可以是增量，也可以是减量。 如果是逐步+1或-1 则可以写成 ++或--
* 如果有更灵活的需要，则可以i = i+指定数值
* */
public class ForTest1 {
public static void main(String[] args) {
// 1.初始部分 2.循环条件 4.迭代部分
for (int i = 1; i <= 5; i++) {
System.out.println("HelloWorld");//3.循环体
}
System.out.println("=======");
for(int i = 5;i>=1;i--){
System.out.println("王昭君");
}
System.out.println("程序结束");
}
}
-
计算奇偶数的和。代码只写了偶数，自己写奇数
-
package com.atguigu.c_for; public class ForExerTest2 { public static void main(String[] args) { //求1~100的和 //todo 定义变量接收累加的和。 int sum = 0; for (int i = 1; i <= 100; i++) { //循环累加i的数字 sum += i; } System.out.println("sum = " + sum); System.out.println("=========="); //求1~100之间，偶数的和。 int evenSum = 0; for(int i=2;i<=100;i=i+2){ if(i % 2==0){ evenSum+=i; } } System.out.println("evenSum = " + evenSum); } } -
无限循环的可能
-
package com.atguigu.c_for; /* 无限循环的可能： * 1.初始部分、循环条件、迭代部分 三者都缺失 2.循环条件、迭代部分缺失 3.迭代部分缺失 4.循环条件缺失 * */ public class ForExerTest3 { public static void main(String[] args) { for(;;){ System.out.println("helloWorld"); } } }
-
3.3 练习
-
水仙花
-
package com.atguigu.c_for; /* * * 所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。 * 123 * 例子：1*1*1 + 2*2*2 + 3*3*3 = 123 水仙花成立！ 这个是假的！理解就行 * 例如： 153 = 1\*1\*1 + 5\*5\*5 + 3\*3\*3，找出所有的水仙花数，并统计他们有几个。 * */ public class WaterFlowerTest4 { public static void main(String[] args) { //todo 拓展：用一个变量，累计水仙花的个数 int count = 0; for (int i = 100; i <= 999; i++) { int baiWei = i / 100;//百位。整数除以整数，只保留整数 int shiWei = i % 100 / 10;//十位 // int shiWei = i/10%10; int geWei = i % 10; // System.out.println("baiWei = " + baiWei+",shiWei = "+shiWei+",geWei = "+geWei); if (baiWei * baiWei * baiWei + shiWei * shiWei * shiWei + geWei * geWei * geWei == i) { System.out.println("水仙花："+i); count++; } } System.out.println("水仙花数量："+count); } }
-
-
foobizbaz
-
package com.atguigu.c_for; /* * 1、从1循环到150并在每行打印一个值， * 2、另外在每个3的倍数行上打印出“foo”, * 在每个5的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”。例如： * * */ public class ForExerTest5 { public static void main(String[] args) { for(int i = 1;i<=150;i++){ //1.打印当前循环的值 i System.out.print(i+"\t"); if(i % 3 == 0){ System.out.print("foo\t"); } if(i % 5 == 0){ System.out.print("biz\t"); } if(i % 7 == 0){ System.out.print("baz"); } System.out.println(); } } } class ForExerTest6 { public static void main(String[] args) { for(int i = 1;i<=150;i++){ //1.打印当前循环的值 i 固定的值，每行都有 // System.out.print(i+"\t"); String str = i+"\t";//固定的格式， 数字 if(i % 3 == 0){ str +="foo\t";//条件满足，在当前字符串上拼接 数字 foo } if(i % 5 == 0){ str +="biz\t"; } if(i % 7 == 0){ str +="baz"; } System.out.println(str); } } }
-
3.4 while循环（重点）
//初始部分
while(循环条件){
//循环体
//迭代部分
}
package com.atguigu.a_while;
/*
*
*
* */
public class WhileTest1 {
public static void main(String[] args) {
//1.初始部分
int i = 1;
//2.循环条件
while(i<=5){
//循环体
System.out.println("HelloWorld");
//迭代部分
i++;
}
System.out.println("程序结束");
}
}
package com.atguigu.a_while;
public class WhileTest2 {
public static void main(String[] args) {
//求1 ~ 100之间，3的倍数的和
//todo 定义累积和的变量
int sum = 0;
int i = 1;
while(i<=100){
//判断当前循环的i是否能被3整除
if(i % 3 == 0){
//累加求和
sum +=i;
}
i++;
}
System.out.println("sum = " + sum);
System.out.println("程序结束");
}
}
package com.atguigu.a_while;
public class WhileExerTest3 {
public static void main(String[] args) {
/*
输出 1 ~ 200内能被5整除的数 每一行输出5个
5 10 15 20 25
30 35 40 45 50
55 60 65 70 75
*/
//初始部分
int i = 1;
//todo 累积记录当前循环能被5的整除的数字的个数
// int count = 0;
//循环条件
while (i <= 200) {
if (i % 5 == 0) {
System.out.print(i+"\t");
// count++;
/*if(count % 5 == 0){
System.out.println();
}*/
if(i % 25 == 0){
System.out.println();
}
}
i++;
}
}
}
3.5 do while循环
//初始部分
do{
//循环体
//迭代部分
}while(循环条件);
package com.atguigu.b_dowhile;
/*
* do while 循环 首次执行没有循环条件的判断。
* */
public class DoWhileTest1 {
public static void main(String[] args) {
//初始部分
int i = 1;
do{
//循环体
System.out.println("HelloWorld");
//迭代部分
i++;
}while(i <=5);//循环条件
System.out.println("程序结束");
}
}
package com.atguigu.b_dowhile;
public class DoWhileTest2 {
public static void main(String[] args) {
//1 ~ 100内 奇数的和
int sum = 0;
int i = 1;
do{
if(i % 2 !=0){
sum+=i;
}
i++;
}while(i<=100);
System.out.println("和："+sum);
System.out.println("i:"+i);
}
}
3.6 循环总结
package com.atguigu.b_dowhile;
/*
* for ：循环条件满足的情况下才可以执行循环
* 循环次数固定
* while：循环条件满足的情况下才可以执行循环
* 循环次数不固定
* do while ：无论何种情况，最少会执行一次。
* */
public class LoopTest3 {
public static void main(String[] args) {
//for 循环 i = for循环
for(int i = 11;i<=10;i++){
System.out.println("for");
}
//while
int j = 11;//main方法
while(j<=10){
System.out.println("while");
j++;
}
//do while
int m = 11;
do{
System.out.println("do while");
m++;
}while(m<=10);
}
}
四、 break、continue、return
4.1 break
-
break作用在switch和循环中，作用是跳出当前整个结构
-
package com.atguigu.c_keywords; /* break只能用于switch或循环 break作用在循环中，终止、跳出整个循环 * */ public class BreakTest1 { public static void main(String[] args) { /*if(3>2){ break; }*/ for(int i =1;i<=10;i++){ if(i == 5){ break; // System.out.println(); } System.out.println("HelloWorld"+i); } System.out.println("程序结束！"); } }
4.2 continue
-
continue只能作用在循环中。跳出当前本次循环，进入下一次循环，去执行迭代部分。
-
package com.atguigu.c_keywords; /* * continue 只能用于循环结构 * 跳出当前循环，进入下一次的循环 ，执行迭代部分、循环条件 * */ public class ContinueTest2 { public static void main(String[] args) { /*if(3>2){ continue; }*/ for(int i = 1;i<=10;i++){ if(i == 5){ continue; } System.out.println("HelloWolrd"+i); } System.out.println("程序结束"); } }
4.3 return（此处先了解）
-
return是写在方法里的，作用是结束整个方法。
-
package com.atguigu.c_keywords; /* * return：结束的是整个方法 * */ public class ReturnTest3 { public static void main(String[] args) { /*if(3>2){ return; }*/ for(int i = 1;i<=10;i++){ if(i == 5){ return; } System.out.println("HelloWolrd"+i); } System.out.println("程序结束"); } }
五、嵌套循环
5.1 概念
在循环结构中，定义另一个完整的循环结构。
嵌套循环分为外层循环和内层循环，内层循环是否执行取决于外层循环。内层循环作为了外层循环的循环体。
5.2 实战
-
打印3行5颗星
-
public class NestedLoopTest1 { public static void main(String[] args) { //打印5颗星，在一行 for (int i = 1; i <= 5; i++) { System.out.print("*"); } //换行 System.out.println(); for (int i = 1; i <= 5; i++) { System.out.print("*"); } System.out.println(); for (int i = 1; i <= 5; i++) { System.out.print("*"); } System.out.println(); } } class PrintStarTest { public static void main(String[] args) { //循环3次 for (int i = 1; i <= 3; i++) { //打印5颗星，在一行 for (int j = 1; j <= 5; j++) { System.out.print("*"); } //换行 System.out.println(); } } }
-
-
打印分钟和秒钟
-
class PrintClockTest{ public static void main(String[] args) { //外层打印的是分钟，外层循环1分钟 for(int i = 0;i<=60;i++){ //内层循环60秒 for(int j =0;j<=60;j++){ System.out.println(i+"分"+j+"秒"); } } } }
-
-
打印直角三角形
-
package com.atguigu.d_nested; /* h 行数 l 列数 * 1 1 ** 2 2 *** 3 3 **** 4 4 ***** 5 5 外层循环执行5行。 内层循环的次数和外层循环的行数有关 内层循环要打印*并且换行 */ public class PrintSanJiaoTest2 { public static void main(String[] args) { //外层循环5行 for(int h = 1;h<=5;h++){ //内层循环的列数和外层循环的行数有关 for(int l =1;l<=h;l++){ System.out.print("*"); } System.out.println(); } } }
-
-
打印等腰三角形
-
package com.atguigu.d_nested; public class PrintDengYaoTest3 { public static void main(String[] args) { /* h 行 l 列 k 空格 * 1 1 3 *** 2 3 2 ***** 3 5 1 ******* 4 7 0 先打印直角三角形 行数： 列数：列数是 行数 * 2 - 1 空格数： 总行数 - 当前行 4 - h */ //外层循环控制行数 for (int h = 1; h <= 4; h++) { for (int k = 1; k <= 4 - h; k++) { System.out.print(" "); } //内层循环：打印*，打印的个数由外层行数来决定 行数*2-1 = 列数 for (int l = 1; l <= h * 2 - 1; l++) { System.out.print("*"); } System.out.println(); } } }
-
5.3 break、continue标记
- 在嵌套循环中，可以通过标记的方式，来指定内层循环中的break或continue，结束的是哪层循环
package com.atguigu.d_nested;
/*
* break：
* 1.没有标记，结束break所在的循环结构。
* 2.标记：break后边跟的标记，就是要停止的循环结构
* 标记名，符合命名规范即可。
* continue:
* 1.没有标记，结束continue所在的循环结构，内层循环进入下一次
* 2.有标记，结束本次循环所在的外层循环。 外层循环进入下一次
* */
public class BreakContinueTest4 {
public static void main(String[] args) {
abc:for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 10; j++) {
if (j == 3) {
break abc;
}
System.out.print(j+" ");
}
System.out.println();
}
}
}
class ContinueTest5{
public static void main(String[] args) {
gq:for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 10; j++) {
if (j == 3) {
continue gq;
}
System.out.print(j+" ");
}
System.out.println();
}
}
}
475
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
