1 概述
- 不论哪种编程语言，都会提供三种基本的流程控制结构：顺序结构、分支结构和循环结构。其中，顺序结构就是程序从上到下逐行的执行，中间没有任何判断和跳转；分支结构用于实现根据条件来选择性的执行某段代码；循环结构用于实现根据循环条件重复执行某段代码。
2 顺序结构
2.1 概述
- 任何编程语言中最常见的程序结构就是
顺序结构。顺序结构就是程序从上向下逐行的执行，中间没有任何判断和跳转。如果main方法的多行代码之间没有任何任何分支结构和循环结构，则程序总是从上向下依次执行，排在前面的代码先执行，排在后面的代码后执行。
public static void main(String[] args){
//顺序执行，根据编写的顺序，从上到下运行
System.out.println(1);
System.out.println(2);
System.out.println(3);
}
2.2 键盘输入
-
步骤：
-
- ①准备Scanner类型的变量。
-
- ②提示输入xxx。
-
- ③接收输入内容。
-
示例：
import java.util.Scanner;
/**
* 键盘输入
*
* @author open1024
* @version 1.0
* @since 2021-08-07 06:49
*/
public class ScannerDemo {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入姓名：");
String name = input.next();
System.out.println("name = " + name);
System.out.println("------------------------");
System.out.print("请输入年龄：");
int age = input.nextInt();
System.out.println("age = " + age);
System.out.println("------------------------");
System.out.print("请输入体重：");
double weight = input.nextDouble();
System.out.println("weight = " + weight);
System.out.println("------------------------");
System.out.print("请输入性别（男或女）：");
String gender = input.next();
System.out.println("gender = " + gender);
System.out.println("------------------------");
System.out.print("是否已婚（true或false）：");
boolean isMarry = input.nextBoolean();
System.out.println("isMarry = " + isMarry);
}
}
next()和nextLine()的区别：
-
next()：遇到空格等空白符，就认为输入结束。 -
nextLine()：遇到回车换行，则认为输入结束。
3 分支结构
3.1 概述
- 分支结构：根据条件，选择性地执行某段代码。
3.2 If语句
- 语法：
if(条件表达式){
// 执行语句
}
- 流程图：
- 示例：
import java.util.Scanner;
/**
* @author open1024
* @version 1.0
* @since 2021-08-07 07:14
*/
public class IfDemo {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入i：");
int i = input.nextInt();
System.out.print("请输入j：");
int j = input.nextInt();
if (i > j) {
System.out.println(i + "比" + j + "大");
}
System.out.println("结束");
}
}
3.3 if…else语句
- 语法：
if(条件表达式){
// 执行语句1
}else{
// 执行语句2
}
- 流程图：
- 示例：
import java.util.Scanner;
/**
* @author open1024
* @version 1.0
* @since 2021-08-07 07:23
*/
public class IfElseDemo2 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入i：");
int i = input.nextInt();
System.out.print("请输入j：");
int j = input.nextInt();
if (i > j) {
System.out.println(i + "比" + j + "大");
} else {
System.out.println(i + "小于或等于" + j);
}
System.out.println("结束");
}
}
3.4 if…else if…else语句
- 语法：
if(条件表达式1){
// 执行语句1
}else if(条件表达式2){
// 执行语句2
}else{
// 执行语句3
}
- 流程图：
- 示例：
import java.util.Scanner;
/**
* @author open1024
* @version 1.0
* @since 2021-08-07 07:29
*/
public class IfElseIfDemo {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入i：");
int i = input.nextInt();
System.out.print("请输入j：");
int j = input.nextInt();
if (i > j) {
System.out.println(i + "比" + j + "大");
} else if (i < j) {
System.out.println(i + "比" + j + "小");
} else {
System.out.println(i + "和" + j + "相等");
}
System.out.println("结束");
}
}
3.5 switch…case语句
- 语法：
switch(表达式){
case 值1:
// 执行语句
break;
case 值2:
// 执行语句
break;
default:
// 执行语句
break;
}
注意：
-
表达式的可选值类型：byte、short、int、char、枚举（JDK1.5）、String（JDK1.7）。
-
case子句：
-
- case子句中指定的值必须是常量，不能是变量或不确定的表达式的值。
-
- 同一个switch语句中所有case子句中的常量值必须互不相同。
-
default子句：
-
- default子句是可选的。
-
- default子句的位置是灵活的。
-
流程图：
- 示例：
import java.util.Scanner;
/**
* @author open1024
* @version 1.0
* @since 2021-08-07 07:47
*/
public class SwitchDemo {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入你喜欢的季节（spring、summer、autumn、winter）：");
String season = input.nextLine();
switch (season) {
case "spring":
System.out.println("我喜欢春天");
break;
case "summer":
System.out.println("我喜欢夏天");
break;
case "autumn":
System.out.println("我喜欢秋天");
break;
case "winter":
System.out.println("我喜欢冬天");
break;
default:
System.out.println("我一个季节都不喜欢");
break;
}
}
}
3.6 练习
3.6.1 练习1
- 岳小鹏参加Java考试，他和父亲岳不群达成承诺：
| 成绩 | 奖励 |
|---|---|
| 100 | BMW |
| (80,99] | iphone xs max |
| [60,80] | ipad |
| 其它 | 无 |
-
请从键盘输入岳小鹏的期末成绩，并加以判断。
-
示例：
import java.util.Scanner;
/**
* @author open1024
* @version 1.0
* @since 2021-08-07 14:25
*/
public class BranchStructureExercise1 {
public static void main(String[] args) {
// ① 用户输入成绩
Scanner input = new Scanner(System.in);
System.out.print("请输入岳小鹏的期末成绩：");
double score = input.nextDouble();
// ② 按照100、(80,99]、[60,80]的顺序检查输入的成绩数据，在各个分支内打印对应的奖励
if (score == 100) {
System.out.println("BMW");
} else if (score > 80 && score <= 99) {
System.out.println("iphone xs max");
} else if (score >= 60 && score <= 80) {
System.out.println("ipad");
} else {
System.out.println("其他");
}
}
}
3.6.2 练习2
-
由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序，并且从小到大输出。
-
示例：
import java.util.Scanner;
/**
* @author open1024
* @version 1.0
* @since 2021-08-07 14:47
*/
public class BranchStructureExercise2 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入num1的值：");
int num1 = input.nextInt();
System.out.print("请输入num2的值：");
int num2 = input.nextInt();
System.out.print("请输入num3的值：");
int num3 = input.nextInt();
int temp = 0;
if (num1 >= num2) {
// 交换 num1 和 num2的值
temp = num1;
num1 = num2;
num2 = temp;
}
if (num2 >= num3) {
// 交换 num2 和 num3的值，这样num3的值最大
temp = num2;
num2 = num3;
num3 = temp;
// 如果 num2 和 num3进行了交换，就再比较一下num1和num2（新的）
if (num1 >= num2) {
// 比较 num1 和 num2的值，这样就能决定num1和num2谁大
temp = num2;
num2 = num1;
num1 = temp;
}
}
System.out.println(num1 + "<" + num2 + "<" + num3);
}
}
3.6.3 练习3
- 下面的代码，如果有输出，指出输出的结果。
/**
* @author open1024
* @version 1.0
* @since 2021-08-07 15:40
*/
public class BranchStructureExercise3 {
public static void main(String[] args) {
int x = 4;
int y = 1;
if (x > 2) {
if (y > 2)
System.out.println(x + y);
System.out.println("open1024");
} else
System.out.println("x is " + x);
}
}
注意：实际开发中，强烈建议不要这么写。
- 输出结果：
open1024
3.6.4 练习4
-
编写程序，声明2个int型变量并赋值。判断两数之和，如果大于等于50，打印“hello world!”。
-
示例：
/**
* @author open1024
* @version 1.0
* @since 2021-08-07 19:51
*/
public class BranchStructureExercise4 {
public static void main(String[] args) {
int i = 20;
int j = 30;
if ((i + j) >= 50) {
System.out.println("Hello World!");
}
}
}
3.6.5 练习5
-
编写程序，声明2个double型变量并赋值。判断第一个数大于10.0，且第2个数小于20.0，打印两数之和。否则，打印两数的乘积。
-
示例：
/**
* @author open1024
* @version 1.0
* @since 2021-08-07 19:55
*/
public class BranchStructureExercise5 {
public static void main(String[] args) {
double a = 11.5;
double b = 19.8;
if (a >= 10.0 && b < 20.0) {
System.out.println(a + b);
} else {
System.out.println(a * b);
}
}
}
3.6.6 练习6
-
我家的狗5岁了，5岁的狗相当于人类多大呢？其实，狗的前两年每一年相当于人类的10.5岁，之后每增加一年就增加四岁。那么5岁的狗相当于人类多少年龄呢？应该是：10.5 + 10.5 + 4 + 4 + 4 = 33岁。
-
编写一个程序，获取用户输入的狗的年龄，通过程序显示其相当于人类的年龄。如果用户输入负数，请显示一个提示信息。
-
示例：
import java.util.Scanner;
/**
* @author open1024
* @version 1.0
* @since 2021-08-07 20:03
*/
public class BranchStructureExercise6 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入狗的年龄：");
int age = input.nextInt();
if (age <= 0) {
System.out.println("年龄不能为负数或0");
} else if (age <= 2) {
System.out.println("狗的年龄相当于：" + age * 10.5);
} else {
// 前两年
double towYearAge = 10.5 * 2;
// 比2大的
double moreYearAge = (age - 2) * 4;
// 总的年龄
double totalAge = towYearAge + moreYearAge;
System.out.println("狗的年龄相当于：" + totalAge);
}
}
}
3.6.7 练习7
-
假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票中奖号码，提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢。
-
① 如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。
-
② 如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000美元。
-
③ 如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。
-
④ 如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
-
⑤ 如果用户输入的数字没有匹配任何一个数字，则彩票作废。
-
示例：
import java.util.Random;
import java.util.Scanner;
/**
* @author open1024
* @version 1.0
* @since 2021-08-07 20:11
*/
public class BranchStructureExercise7 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入两位数（01~99）：");
int number = input.nextInt();
Random random = new Random();
int prizeNumber = random.nextInt(100);
int gePrize = prizeNumber % 10;
int shiPrize = prizeNumber / 10;
if (number <= 0 || number > 100) {
System.out.println("用户输入号码不合法");
} else {
System.out.println("用户输入号码：" + number);
System.out.println("彩票中奖号码：" + prizeNumber);
int ge = number % 10;
int shi = number / 10;
if (number == prizeNumber) {
System.out.println("奖金10 000美元");
} else if (gePrize == shi && shiPrize == ge) {
System.out.println("奖金 3 000美元");
} else if (gePrize == ge || shiPrize == shi) {
System.out.println("奖金1 000美元");
} else if (gePrize == shi || shiPrize == ge) {
System.out.println("奖金500美元");
} else {
System.out.println("没有中奖");
}
}
}
}
4 循环结构
4.1 概述
- 循环结构：在某些条件满足的情况下，反复执行特定代码的功能。
4.2 for循环
- 语法：
for(初始化条件①;循环条件语句②;迭代语句④){
循环体语句③
}
for(;;){
循环体语句块；//如果循环体中没有跳出循环体的语句，那么就是死循环
}
注意：
-
for(;;){}中的两个;是不能多也不能少的。 -
循环条件必须是boolean类型。
-
如果循环条件语句②省略的话，就默认为循环条件成立。
-
执行流程：
-
- 第一步：执行初始化语句①，完成循环变量的初始化；
-
- 第二步：执行循环条件语句②，看循环条件语句的值是true，还是false；
-
-
- 如果是true，执行第三步；
-
-
-
- 如果是false，循环语句中止，循环不再执行。
-
-
- 第三步：执行循环体语句③；
-
- 第四步：执行迭代语句④，针对循环变量重新赋值；
-
- 第五步：根据循环变量的新值，重新从第二步开始再执行一遍；
-
示例：
/**
* 打印10次"Hello"
*
* @author open1024
* @version 1.0
* @since 2021-08-08 08:08
*/
public class ForDemo1 {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
System.out.println("Hello");
}
}
}
- 示例：
/**
* 从1累加到5
*
* @author open1024
* @version 1.0
* @since 2021-08-08 08:09
*/
public class ForDemo2 {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 5; i++) {
sum += i;
}
System.out.println("sum = " + sum);
}
}
- 示例：
/**
* 1~100的偶数和
*
* @author open1024
* @version 1.0
* @since 2021-08-08 09:11
*/
public class ForDemo3 {
public static void main(String[] args) {
int sum = 0;
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
sum += i;
}
}
System.out.println("sum = " + sum);
}
}
- 示例：
/**
* 编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”。
*
* @author open1024
* @version 1.0
* @since 2021-08-08 15:04
*/
public class ForDemo4 {
public static void main(String[] args) {
for (int i = 1; i <= 150; 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" + "\t");
}
System.out.println();
}
}
}
- 示例：
/**
* 输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
* <p>
* 例如： 153 = 111 + 333 + 555
*
* @author open1024
* @version 1.0
* @since 2021-08-08 15:14
*/
public class ForDemo5 {
public static void main(String[] args) {
for (int i = 100; i <= 999; i++) {
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100;
if (i == Math.pow(ge, 3) + Math.pow(shi, 3) + Math.pow(bai, 3)) {
System.out.println("水仙花数 = " + i);
}
}
}
}
4.3 while循环
- 语法：
初始化语句①；
while (循环条件语句②) {
循环体语句③；
迭代语句④；
}
-
执行流程：
-
- 第一步：执行初始化语句①，完成循环变量的初始化；
-
- 第二步：执行循环条件语句②，看循环条件语句的值是true，还是false；
-
-
- 如果是true，执行第三步；
-
-
-
- 如果是false，循环语句中止，循环不再执行；
-
-
- 第三步：执行循环体语句③；
-
- 第四步：执行迭代语句④，针对循环变量重新赋值；
-
- 第五步：根据循环变量的新值，重新从第二步开始再执行一遍；
注意：while(循环条件)中循环条件必须是boolean类型。
- 示例：
/**
* 打印1~10
*
* @author open1024
* @version 1.0
* @since 2021-08-08 16:02
*/
public class WhileDemo {
public static void main(String[] args) {
int i = 1;
while (i <= 10) {
System.out.println(i);
i++;
}
}
}
- 示例：
/**
* 世界最高山峰是珠穆朗玛峰，它的高度是8844.43米，假如我有一张足够大的纸，它的厚度是0.1毫米。
* 请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
*
* @author open1024
* @version 1.0
* @since 2021-08-08 16:07
*/
public class WhileDemo2 {
public static void main(String[] args) {
// 统一计量单位
double height = 88444300;
double paper = 1.0;
// 折叠次数
int count = 0;
// 折纸的高度，初始化时为纸张没有折叠的高度
double paperHeight = paper;
while (paperHeight <= height) {
// 每折叠一次，厚度翻倍
paperHeight *= 2;
// 折叠次数自增
count++;
}
System.out.println("最终纸的厚度 = " + paperHeight);
System.out.println("最终折叠的次数 = " + count);
}
}
- 示例：
import java.util.Scanner;
/**
* 从键盘读入个数不确定的整数，并判断读入的奇数和偶数的个数，输入为0时结束程序。
*
* @author open1024
* @version 1.0
* @since 2021-08-08 16:19
*/
public class WhileDemo3 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入整数：");
int number = input.nextInt();
int oddCount = 0;
int evenCount = 0;
while (number != 0) {
if (number % 2 == 0) {
evenCount++;
} else {
oddCount++;
}
System.out.print("请输入整数：");
number = input.nextInt();
}
System.out.println("奇数的个数 = " + oddCount);
System.out.println("偶数的个数 = " + evenCount);
}
}
4.4 do…while循环
- 语法：
初始化语句①
do {
循环体语句②；
迭代语句③；
} while (循环条件语句④)；
-
执行流程：
-
- 第一步：执行初始化语句①，完成循环变量的初始化；
-
- 第二步：执行循环体语句②；
-
- 第三步：执行迭代语句③，针对循环变量重新赋值；
-
- 第四步：执行循环条件语句④，看循环条件语句的值是true，还是false；
-
-
- 如果是true，根据循环变量的新值，重新从第二步开始再执行一遍；
-
-
-
- 如果是false，循环语句中止，循环不再执行；
-
-
示例：
/**
* @author open1024
* @version 1.0
* @since 2021-08-08 20:32
*/
public class DoWhileTest {
public static void main(String[] args) {
int sum = 0;
int i = 1;
do {
sum += i;
i++;
} while (i <= 100);
System.out.println("sum = " + sum);
}
}
4.5 循环语句的区别
-
从循环次数角度分析：
-
- do...while循环至少执行一次循环体语句。
-
- for和while循环先循环条件语句是否成立，然后决定是否执行循环体，至少执行零次循环体语句。
-
从循环变量的生命周期角度分析：
-
- for循环的循环变量在for()中声明的，在循环语句结束后，不可以被访问。
-
- while和do...while循环的循环变量因为在外面声明的，所以while和do...while结束后可以被继续使用的。
-
如何选择：
-
- 遍历有明显的循环次数（范围）的需求，选择for循环。
-
- 遍历没有明显的循环次数（范围）的需求，循环while循环。
-
- 如果循环体语句块至少执行一次，可以考虑使用do...while循环。
-
- 本质上：三种循环之间是可以互相转换的，都能实现循环的功能。
-
三种循环结构都具有四要素：
-
- ①循环变量的初始化表达式。
-
- ②循环条件。
-
- ③循环变量的修改的迭代表达式。
-
- ④循环体语句块。
4.6 嵌套循环（多重循环）
-
将一个循环放在另一个循环体内，就形成了多重循环。其中，for、while、do…while均可以作为外层循环或内层循环。
-
实际上，嵌套循环就是将内层循环当成外层循环的循环体。当只有内层循环的循环条件为false，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次循环。
-
假设外层循环次数为
m次，内层循环次数为n次，则内层循环体实际上需要执行m*n次。 -
示例：
/**
* 九九乘法表
*
* @author open1024
* @version 1.0
* @since 2021-08-08 20:43
*/
public class ForForDemo {
public static void main(String[] args) {
// 外层循环控制行数
for (int i = 1; i <= 9; i++) {
// 内层循环控制列数
for (int j = 1; j <= i; j++) {
System.out.print(j + "*" + i + "=" + i * j + "\t");
}
System.out.println();
}
}
}
4.7 控制语句
4.7.1 break
-
使用场景：
-
- ①在选择结构switch语句中。
-
- ②在循环语句中。
-
示例：
/**
* @author open1024
* @version 1.0
* @since 2021-08-08 21:14
*/
public class BreakDemo {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i == 5) {
// 将本层的循环结束
break;
}
System.out.println(i);
}
}
}
- 示例：
import java.util.Scanner;
/**
* 从键盘输入不断输入整数，输入0表示结束，统计一共有几个正数、负数。
*
* @author open1024
* @version 1.0
* @since 2021-08-09 15:57
*/
public class BreakDemo2 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
// 正数的个数
int positive = 0;
// 负数的个数
int negative = 0;
while (true) {
System.out.print("请输入数字：");
int number = input.nextInt();
if (number > 0) {
positive++;
} else if (number < 0) {
negative++;
} else {
break;
}
}
System.out.println("正数的个数 = " + positive);
System.out.println("负数的个数 = " + negative);
}
}
- 示例：
/**
* 求1-100之间的质数
* ps: 质数是指能被1和其本身整除的数
*
* @author open1024
* @version 1.0
* @since 2021-08-08 21:07
*/
public class PrimeNumber {
public static void main(String[] args) {
// 外层循环，列出从2~100的所有的数字
for (int i = 2; i <= 100; i++) {
// 标记：先设置为true，后面再使用内层循环进行排序
boolean flag = true;
// 内层循环：验证i变量中保存的这个数是不是质数
// 验证方式：用i 对 从2到i/2的所有数 取模，如果发现能够整除，那么说明i不是质数
for (int j = 2; j <= i / 2; j++) {
if (i % j == 0) {
// 如果不是素数，就将标记改为false
flag = false;
break;
}
}
if (flag) {
System.out.println("i = " + i);
}
}
}
}
4.7.2 continue
-
使用场景：结束本次循环，继续下一次的循环。
-
示例：
/**
* @author open1024
* @version 1.0
* @since 2021-08-09 16:07
*/
public class ContinueDemo {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i % 3 == 0) {
continue;
}
System.out.println("i = " + i);
}
}
}
- 示例：
/**
* 打印1-100之间的整数，跳过7的倍数和7结尾的数
*
* @author open1024
* @version 1.0
* @since 2021-08-09 16:08
*/
public class ContinueDemo2 {
public static void main(String[] args) {
for (int i = 1; i <= 100; i++) {
if (i % 7 == 0 || i % 10 == 7) {
continue;
}
System.out.println("i = " + i);
}
}
}
4.7.3 return
-
reutrn：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句的时候，这个方法将被结束。
-
和break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内。
-
示例：
/**
* @author open1024
* @version 1.0
* @since 2021-08-09 16:13
*/
public class ReturnDemo {
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
if (i == 7) {
return;
}
System.out.println(i);
}
}
}
评论区