我要评论顺序结构
从上到下逐行执行（前向引用）
分支结构
根据条件，选择性执行某段代码
if-else结构
格式：
格式1:
if(条件表达式) {
语句块;
}格式2: "二选一"
if(条件表达式) {
语句块1;
} else{
语句块2;
}格式3: "多选一"
if (条件表达式1) {
语句块1;
} else if (条件表达式2) {
语句块2;
} ...
} else if (条件表达式n) {
语句块n;
} else {
语句块n+1;
}结论：
1. 如果多个条件表达式之间没有交集（理解是互斥关系），则哪个条件表达式声明在上面，哪个声明在下面都可以。
如果多个条件表达式之间是包含关系，则需要将范围小的条件表达式声明在范围大的条件表达式的上面。否则，范围小的条件不可能被执行
/*
分支结构1：if-else条件判断结构
格式1:
if(条件表达式) {
语句块;
}
格式2: "二选一"
if(条件表达式) {
语句块1;
} else{
语句块2;
}
格式3: "多选一"
if (条件表达式1) {
语句块1;
} else if (条件表达式2) {
语句块2;
} ...
} else if (条件表达式n) {
语句块n;
} else {
语句块n+1;
}
*/
class ifelsetest {
public static void main(string[] args) {
/*
案例1：成年人心率的正常范围是每分钟60-100次。体检时，
如果心率不在此范围内，则提示需要做进一步的检查。
*/
int heartbeats = 89;
//错误的写法：if(60 <= heartbeats <= 100){
if (heartbeats < 60 || heartbeats > 100) {
system.out.println("你需要做进一步的检查");
}
system.out.println("体检结束");
//*******************************
/*
案例2：定义一个整数，判定是偶数还是奇数
*/
int num = 13;
if (num % 2 == 0) {
system.out.println(num + "是偶数");
} else {
system.out.println(num + "是奇数");
}
//*******************************
/*
岳小鹏参加java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆跑车；
成绩为(80, 99]时，奖励一辆山地自行车；
当成绩为[60, 80]时，奖励环球影城一日游；
其它时，胖揍一顿。
说明：默认成绩是在[0,100]范围内
*/
int score = 61;
// if (score == 100) {
// system.out.println("奖励一辆跑车");
// } else if (score > 80 && score <= 99) {
// system.out.println("奖励一辆山地自行车");
// } else if (score >= 60 && score <= 80) {
// system.out.println("奖励环球影城一日游");
// } else {
// system.out.println("胖揍一顿");
// }
if (score == 100) {
system.out.println("奖励一辆跑车");
} else if (score > 80) {
system.out.println("奖励一辆山地自行车");
} else if (score >= 60) {
system.out.println("奖励环球影城一日游");
}
// else {
// system.out.println("胖揍一顿");
// }
}
}if-else嵌套
1. 从开发经验上讲，没有写过超过三层的嵌套if-else结构。
2. 如果if-else中的执行语句块中只有一行执行语句，则此执行语句所在的一对{}可以省略。但是，不建议省略
/*
测试if-else的嵌套使用
案例：
由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else)，并且从小到大输出。
拓展：你能实现从大到小顺序的排列吗？
1. 从开发经验上讲，没有写过超过三层的嵌套if-else结构。
2. 如果if-else中的执行语句块中只有一行执行语句，则此执行语句所在的一对{}可以省略。但是，不建议省略
*/
class ifelsetest2 {
public static void main(string[] args) {
int num1 = 30;
int num2 = 21;
int num3 = 44;
//int num1 = 30,num2 = 21,num3 = 44;
if(num1 >= num2){
if(num3 >= num1){
system.out.println(num2 + "," + num1 + "," + num3);
}else if(num3 <= num2){
system.out.println(num3 + "," + num2 + "," + num1);
}else{
system.out.println(num2 + "," + num3 + "," + num1);
}
}else{ // num1 < num2
if(num3 >= num2){
system.out.println(num1 + "," + num2 + "," + num3);
}else if(num3 <= num1){
system.out.println(num3 + "," + num1 + "," + num2);
}else{
system.out.println(num1 + "," + num3 + "," + num2);
}
}
}
}switch-case结构
格式：
switch(表达式){
case 常量值1:
语句块1;
//break;
case 常量值2:
语句块2;
//break;
// ...
[default:
语句块n+1;
break;
]
}
根据表达式中的值，依次匹配case语句。一旦与某一个case中的常量相等，那么就执行此case中的执行语句。
执行完此执行语句之后，
情况1：遇到break，则执行break后，跳出当前的switch-case结构
情况2：没有遇到break，则继续执行其后的case中的执行语句(不再进行比较)。---> case穿透
...
直到遇到break或者执行完所有的case及default中的语句，退出当前的switch-case结构
说明：
① switch中的表达式只能是特定的数据类型。如下：byte \ short \ char \ int \ 枚举(jdk5.0新增) \ string(jdk7.0新增)
② case 后都是跟的常量，使用表达式与这些常量做相等的判断，不能进行范围的判断。
③ 开发中，使用switch-case时，通常case匹配的情况都有限。
④ break:可以使用在switch-case中。一旦执行此break关键字，就跳出当前的switch-case结构
⑤ default:类似于if-else中的else结构。
default是可选的，而且位置是灵活的。
switch-case 与 if-else之间的转换
① 开发中凡是可以使用switch-case结构的场景，都可以改写为if-else。反之，不成立
② 开发中，如果一个具体问题既可以使用switch-case，又可以使用if-else的时候，推荐使用switch-case。
为什么？switch-case相较于if-else效率稍高。/*
分支结构之switch-case的使用
1. 语法格式
switch(表达式){
case 常量1:
//执行语句1
//break;
case 常量2:
//执行语句2
//break;
...
default:
//执行语句2
//break;
}
2. 执行过程：
根据表达式中的值，依次匹配case语句。一旦与某一个case中的常量相等，那么就执行此case中的执行语句。
执行完此执行语句之后，
情况1：遇到break，则执行break后，跳出当前的switch-case结构
情况2：没有遇到break，则继续执行其后的case中的执行语句(不再进行比较)。---> case穿透
...
直到遇到break或者执行完所有的case及default中的语句，退出当前的switch-case结构
3. 说明：
① switch中的表达式只能是特定的数据类型。如下：byte \ short \ char \ int \ 枚举(jdk5.0新增) \ string(jdk7.0新增)
② case 后都是跟的常量，使用表达式与这些常量做相等的判断，不能进行范围的判断。
③ 开发中，使用switch-case时，通常case匹配的情况都有限。
④ break:可以使用在switch-case中。一旦执行此break关键字，就跳出当前的switch-case结构
⑤ default:类似于if-else中的else结构。
default是可选的，而且位置是灵活的。
4. switch-case 与 if-else之间的转换
① 开发中凡是可以使用switch-case结构的场景，都可以改写为if-else。反之，不成立
② 开发中，如果一个具体问题既可以使用switch-case，又可以使用if-else的时候，推荐使用switch-case。为什么？switch-case相较于if-else效率稍高。
*/
class switchcasetest {
public static void main(string[] args) {
int num = 1;
switch (num) {
case 0:
system.out.println("zero");
break;
case 1:
system.out.println("one");
break; //结束当前的switch-case结构
case 2:
system.out.println("two");
break;
case 3:
system.out.println("three");
break;
default:
system.out.println("other");
break;
}
// 另例：
string season = "summer";
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;
}
}
}case穿透
/**
* 案例3：使用switch-case实现：对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。
*/
class switchcasetest1 {
public static void main(string[] args) {
//定义一个学生成绩的变量
int score = 78;
//根据需求，进行分支
//方式1：
/*
switch (score) {
case 0:
system.out.println("不及格");
break;
case 1:
system.out.println("不及格");
break;
//...
case 100:
system.out.println("及格");
break;
default:
system.out.println("成绩输入有误");
break;
}
*/
// 方式2:体会case穿透
switch (score / 10) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
system.out.println("不及格");
break;
case 6:
case 7 :
case 8:
case 9:
case 10:
system.out.println("及格");
break;
default:
system.out.println("成绩输入有误");
break;
}
//方式3:
switch(score / 60){
case 0:
system.out.println("不及格");
break;
case 1:
system.out.println("及格");
break;
default:
system.out.println("成绩输入有误");
break;
}
}
}/*
案例：编写程序：从键盘上输入2023年的“month”和“day”，要求通过程序输出输入的日期为2023年的第几天。
*/
import java.util.scanner;
class switchcasetest2 {
public static void main(string[] args) {
//1.使用scanner，从键盘获取2023年的month、day
scanner input = new scanner(system.in);
system.out.println("请输入2023年的月份：");
int month = input.nextint();//阻塞式方法
system.out.println("请输入2023年的天：");
int day = input.nextint();
//假设用户输入的数据是合法的。后期我们在开发中，使用正则表达式进行校验。
//2. 使用switch-case实现分支结构
int sumdays = 0; //记录总天数
//方式1：不推荐，存在数据冗余
/*
switch (month) {
case 1:
sumdays = day;
break;
case 2:
sumdays = 31 + day;
break;
case 3:
sumdays = 31 + 28 + day;
break;
case 4:
sumdays = 31 + 28 + 31 + day;
break;
//...
case 12:
sumdays = 31 + 28 + ...+30 + day;
break;
}
*/
//方式2:
switch (month) {
case 12:
sumdays += 30; //11月的天数
case 11:
sumdays += 31; //10月的天数
case 10:
sumdays += 30; //9月的天数
case 9:
sumdays += 31; //8月的天数
case 8:
sumdays += 31; //7月的天数
case 7:
sumdays += 30; //6月的天数
case 6:
sumdays += 31; //5月的天数
case 5:
sumdays += 30; //4月的天数
case 4:
sumdays += 31; //3月的天数
case 3:
sumdays += 28; //28:2月份的总天数
case 2:
sumdays += 31; //31:1月份的总天数
case 1:
sumdays += day; //31:1月份的总天数
}
system.out.println("2023年" + month + "月" + day + "日是当前的第" + sumdays + "天");
input.close();//为了防止内存泄漏
}
}循环结构
根据循环条件，满足某些条件时，重复执行某段代码
凡是循环结构，就一定会有4个要素：
① 初始化条件
② 循环条件 ---> 一定是boolean类型的变量或表达式
③ 循环体
④ 迭代部分
for结构
for循环的格式
for(①;②;③){
④
}
执行过程：
① → ② → ④ → ③ → ② → ④ → ③ → ... → ②(不满足时结束循环)class fortest {
public static void main(string[] args) {
//需求1：题目：输出5行helloworld
/*
system.out.println("helloworld");
system.out.println("helloworld");
system.out.println("helloworld");
system.out.println("helloword");
system.out.println("helloworld");
*/
for (int i = 1; i <= 5; i++) {
system.out.println("helloworld");
}
// 需求2:
int num = 1;
for (system.out.print("a"); num < 3; system.out.print("c"), num++) {
system.out.print("b");
}
// 输出结果：abcbc
system.out.println();//换行
//需求3：遍历1-100以内的偶数，并获取偶数的个数，获取所有的偶数的和
int count = 0;//记录偶数的个数
int sum = 0;//记录所有偶数的和
for(int i = 1;i <= 100;i++){
if(i % 2 == 0){
system.out.println(i);
count++;
sum += i;
}
}
system.out.println("偶数的个数为：" + count);
system.out.println("偶数的总和为：" + sum);
}
}案例：
/**
题目：输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
例如：153 = 1*1*1 + 3*3*3 + 5*5*5
*/
class fortest1 {
public static void main(string[] args) {
//遍历所有的3位数
for(int i = 100; i <= 999; i++){
//针对于每一个三位数i，获取其各个位上数值
int ge = i % 10;
int shi = i / 10 % 10; //或 int shi = i % 100 / 10
int bai = i / 100;
//判断是否满足水仙花数的规则
if(i == ge * ge * ge + shi * shi * shi + bai * bai * bai){
system.out.println(i);
}
}
}
}/*
案例：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。
约数：12为例，约数有1,2,3,4,6,12
20为例，约数有1,2,4,5,10,20
倍数：12为例，倍数有 12, 24, 36, 48, 60, 72, …
20为例，倍数有 20, 40, 60, 80, …
说明：
1. 我们可以在循环结构中使用break。一旦执行break，就跳出（或结束）当前循环结构。
2. 如何结束一个循环结构？
方式1：循环条件不满足。（即循环条件执行完以后是false）
方式2：在循环体中执行了break
*/
class fortest2 {
public static void main(string[] args) {
int m = 12;
int n = 20;
// 获取m和n中的较小值
int min = (m < n) ? m : n;
// 需求1：最大公约数
// 方式1:
int result = 1;
for (int i = 1; i <= min; i++) {
if (m % i == 0 && n % i == 0) {
//system.out.println(i);
result = i;
}
}
system.out.println(result);
// 方式2:推荐
for (int i = min; i >= 1; i--) {
if (m % i == 0 && n % i == 0) {
system.out.println("最大公约数为：" + i);
break; // 找到最大公约数后跳出循环
}
}
// 需求2：最小公倍数
int max = (m > n) ? m : n;
for (int i = max; i <= m * n; i++) {
if (i % m == 0 && i % n == 0) {
system.out.println("最小公倍数为：" + i);
break;
}
}
}
}注：
1. 我们可以在循环结构中使用break。一旦执行break，就跳出（或结束）当前循环结构。
2. 如何结束一个循环结构？
方式1：循环条件不满足。（即循环条件执行完以后是false）
方式2：在循环体中执行了break
while结构
while的格式
①
while(②){
③
④
}
执行过程：
① → ② → ③ → ④ → ② → ③ → ④ → ... → ②(不满足时结束循环)class whiletest {
public static void main(string[] args) {
// 需求1：遍历50次helloworld
int i = 1;
while (i <= 50) {
system.out.println("helloworld");
i++; // 一定要小心！不要丢了
}
// 需求2：遍历1-100以内的偶数，并获取偶数的个数，获取所有的偶数的和
int j = 1;
int count = 0; // 记录偶数的个数
int sum = 0; // 记录偶数的总和
while (j <= 100) {
if (j % 2 == 0) {
system.out.println(j);
count++;
sum += j;
}
j++;
}
system.out.println("偶数的个数为: " + count);
system.out.println("偶数的总和为: " + sum);
}
}案例：
/*
随机生成一个100以内的数，猜这个随机数是多少？
从键盘输入数，如果大了，提示大了；如果小了，提示小了；如果对了，就不再猜了，并统计一共猜了多少次。
提示：生成一个[a,b]范围的随机数的方式：(int)(math.random()*(b-a+1)+a)
*/
import java.util.scanner;
class whiletest1 {
public static void main(string[] args) {
//1. 生成一个[1,100]范围的随机整数
int random = (int) (math.random() * 100) + 1;
//2. 使用scanner，从键盘获取数据
scanner scan = new scanner(system.in);
system.out.print("请输入1-100范围的一个整数: ");
int guess = scan.nextint();
//3. 声明一个变量，记录猜的次数
int guesscount = 1;
//4. 使用循环结构，进行多次循环的对比和获取数据
while (random != guess) {
if (guess > random) {
system.out.println("你输入的数据大了");
} else if (guess < random) {
system.out.println("你输入的数据小了");
}//else{
// break;
//}
system.out.print("请输入1-100范围的一个整数: ");
guess = scan.nextint();
guesscount++;
}
//能结束结束，就意味着random和guess相等了
system.out.println("恭喜你！猜对了！");
system.out.println("共猜了" + guesscount + "次");
}
}/*
世界最高山峰是珠穆朗玛峰，它的高度是8848.86米，假如我有一张足够大的纸，它的厚度是0.1毫米。
请问，我折叠多少次，可以折成珠穆朗玛峰的高度？
*/
class whiletest2 {
public static void main(string[] args) {
// 1. 声明珠峰的高度、纸的默认厚度
double paper = 0.1; // 单位：毫米
double zf = 8848860; // 单位：毫米
// 2. 定义一个变量，记录折纸的次数
int count = 0;
// 3. 通过循环结构，不断调整纸的厚度（当纸的厚度超过珠峰高度时，停止循环）
while (paper <= zf) {
paper *= 2;
count++;
}
system.out.println("paper的高度为: " + (paper / 1000) + ",超过了珠峰的高度" + zf / 1000);
system.out.println("共折纸" + count + "次");
}
}注意：
1. for循环与while循环可以相互转换！
2. for循环和while循环的小区别：初始化条件的作用域范围不同。while循环中的初始化条件在while循环结束后，依然有效。
do-while结构
do-while的格式
①
do{
③
④
}while(②);
执行过程：① → ③ → ④ → ② → ③ → ④ → ... → ②(不满足时结束循环)案例：
/*
题目：模拟atm取款
声明变量balance并初始化为0，用以表示银行账户的余额，下面通过atm机程序实现存款、取款等功能。
=========atm=========
1. 存款
2. 取款
3. 显示余额
4. 退出
请选择(1-4):
*/
import java.util.scanner;
class dowhiletest1 {
public static void main(string[] args) {
//1. 定义balance的变量，记录账户余额
double balance = 0.0;
boolean flag = true;//控制循环结束
scanner scan = new scanner(system.in);//实例化scanner
do {
//2. 声明atm取款的界面
system.out.println("======atm======");
system.out.println(" 1、存款");
system.out.println(" 2、取款");
system.out.println(" 3、显示余额");
system.out.println(" 4、退出");
system.out.print("请选择(1-4): ");
//3. 使用scanner获取用户的选择
int selection = scan.nextint();
switch (selection) {
//4. 根据用户的选择，决定执行存款、取款、显示余额、退出的操作
case 1:
system.out.print("请输入存款的金额: ");
double money1 = scan.nextdouble();
if (money1 > 0) {
balance += money1;
}
break;
case 2:
system.out.print("请输入取款的金额: ");
double money2 = scan.nextdouble();
if (money2 > 0 && money2 <= balance) {
balance -= money2;
} else {
system.out.println("输入的数据有误或余额不足");
}
break;
case 3:
system.out.println("账号余额为：: " + balance);
break;
case 4:
flag = false;
system.out.println("感谢使用，欢迎下次光临");
break;
default:
system.out.println("输入有误，请重新输入");
}
} while (flag);
//关闭资源
scan.close();
}
}注意：
1) do-while循环至少执行一次循环体。
int num1 = 10;
while(num1 > 10){
system.out.println("while:hello");
num1--;
}
int num2 = 10;
do{
system.out.println("do-while:hello");
num2--;
}while(num2 > 10);2) for、while、do-while循环三者之间是可以相互转换的。
- 遍历有明显的循环次数（范围）的需求，选择for循环 - 遍历没有明显的循环次数（范围）的需求，选择while循环 - 如果循环体语句块至少执行一次，可以考虑使用do-while循环
3) do-while循环结构，在开发中，相较于for、while循环来讲，使用的较少。
循环拓展
“无限”循环
while(true) , for(;;)
- 开发中，有时并不确定需要循环多少次，需要根据循环体内部某些条件，来控制循环的结束（使用break）。
- 如果此循环结构不能终止，则构成了死循环！开发中要避免出现死循环。
/*
“无限”循环结构的使用
1. 格式： while(true) 或 for(;;)
2. 开发中，有时并不确定需要循环多少次，需要根据循环体内部某些条件，来控制循环的结束（使用break）。
3. 如果此循环结构不能终止，则构成了死循环！开发中要避免出现死循环。
*/
class forwhiletest {
public static void main(string[] args) {
for (; true; ) {//for (; ; ) {//while(true){
system.out.println("i love you!");
}
//死循环的后面不能有执行语句。
//system.out.println("end");
}
}案例：
/*
案例：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
*/
import java.util.scanner;
class forwhiletest1 {
public static void main(string[] args) {
scanner scan = new scanner(system.in);
int positivecount = 0; //记录正数的个数
int negativecount = 0; //记录负数的个数
while (true) {
system.out.print("请输入一个整数(输入为0时结束程序): ");
int num = scan.nextint(); //获取用户输入的整数
if (num > 0) { //正数
positivecount++;
} else if (num < 0) {//负数
negativecount++;
} else {//0
system.out.println("程序结束");
break;
}
}
system.out.println("正数的个数为：" + positivecount);
system.out.println("负数的个数为：" + negativecount);
scan.close();
}
}嵌套循环（多重循环）
1. 嵌套循环：是指一个循环结构a的循环体是另一个循环结构b。
- 外层循环：循环结构a
- 内层循环：循环结构b
2. 说明：
1）内层循环充当了外层循环的循环体。
2）对于两层嵌套循环来说，外层循环控制行数，内层循环控制列数。
3）举例：外层循环执行m次，内层循环执行n次，则内层循环的循环体共执行 \( m \times n \) 次。
4）实际开发中，我们不会出现三层以上的循环结构，三层的循环结构都很少见。
class forfortest {
public static void main(string[] args) {
// ******
for (int i = 1; i <= 6; i++) {
system.out.print('*');
}
system.out.println("\n#############");
/*
******
******
******
******
******
******
*/
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 6; j++) {
system.out.print('*');
}
system.out.println();
}
/*
i(第几行) j(每一行中*的个数)
* 1 1
** 2 2
*** 3 3
**** 4 4
***** 5 5
*/
for(int i = 1; i <= 5; i++) {
for(int j = 1; j <= i; j++){
system.out.print("*");
}
system.out.println();
}
/*
i(第几行) j(每一行中*的个数) i + j = 7 --> j = 7 - i
****** 1 6
***** 2 5
**** 3 4
*** 4 3
** 5 2
* 6 1
*/
for(int i = 1; i <= 6; i++) {
for(int j = 1; j <= 7 - i; j++){
system.out.print("*");
}
system.out.println();
}
}
}案例：
/*
练习：九九乘法表
*/
class nineninetable {
public static void main(string[] args) {
for(int i = 1;i <= 9;i++){
for(int j = 1;j <= i;j++){
system.out.print(i + "×" + j + "=" + i * j + "\t");
}
system.out.println();
}
}
}技巧
键盘输入
使用scanner获取不同类型数据的步骤
步骤1：导入import java.util.scanner;
步骤2：提供（或创建）一个scanner类的实例；
步骤3：调用scanner类中的方法，获取指定类型的变量
步骤4：关闭资源，调用scanner类的close()
/*
如何从键盘获取不同类型（基本数据类型、string类型）的变量：使用scanner类。
1. 使用scanner获取不同类型数据的步骤
步骤1：导入import java.util.scanner;
步骤2：提供（或创建）一个scanner类的实例；
步骤3：调用scanner类中的方法，获取指定类型的变量
步骤4：关闭资源，调用scanner类的close()
2. 案例：小明注册某交友网站，要求录入个人相关信息。如下：
请输入你的网名、你的年龄、你的体重、你是否单身、你的性别等情况。
3. scanner类中提供了获取byte \ short \ int \ long \ float \ double \ boolean \ string类型变量的方法。
注意，没有提供获取char类型变量的方法。需要使用next().charat(0)
*/
//步骤1：导入import java.util.scanner;
import java.util.scanner;
class scannertest {
public static void main(string[] args) {
//步骤2：提供（或创建）一个scanner类的实例
scanner scan = new scanner(system.in);
system.out.println("欢迎光临你来我往交友网");
system.out.print("请输入你的网名：");
//步骤3：调用scanner类中的方法，获取指定类型的变量
string name = scan.next();
system.out.print("请输入你的年龄：");
int age = scan.nextint();
system.out.print("请输入你的体重：");
double weight = scan.nextdouble();
system.out.print("你是否单身（单身：true;不单身：false）：");
boolean issingle = scan.nextboolean();
system.out.print("请输入你的性别：（男\\女）");
char gender = scan.next().charat(0);
system.out.println("网名: " + name + ",年龄: " + age + ",体重: " + weight + ",是否单身: " + issingle + ",性别: " + gender);
system.out.println("注册完成，欢迎继续进入体验！");
//步骤4：关闭资源，调用scanner类的close()
scan.close();
}
}
练习
import java.util.scanner;
class scannerexer {
public static void main(string[] args) {
scanner scan = new scanner(system.in);
system.out.println("请输入你的身高：(cm)");
int height = scan.nextint();
system.out.println("请输入你的财富：(以千万为单位)");
double wealth = scan.nextdouble();
// 关于是否帅问题，我们使用string类型接收
system.out.println("帅否？(是/否)");
string ishandsome = scan.next();
// 判断
if (height >= 180 && wealth >= 1.0 && ishandsome.equals("是")) {
system.out.println("我一定要嫁给他!!!");
} else if (height >= 180 || wealth >= 1.0 || ishandsome.equals("是")) {
system.out.println("嫁吧，比上不足，比下有余。");
} else {
system.out.println("不嫁");
}
// 关闭资源
scan.close();
}
}获取随机数
获取一个[a,b]范围的随机整数
(int)(math.random() * (b - a + 1)) + a
/*
如何获取一个随机数？
1. 可以使用java提供的api:math类的random()
2. random()调用以后，会返回一个[0.0,1.0)范围的double型的随机数
3. 需求1：获取一个[0,100]范围的随机整数？
需求1：获取一个[1,100]范围的随机整数？
4. 需求：获取一个[a,b]范围的随机整数？
(int)(math.random() * (b - a + 1)) + a
*/
class randomtest {
public static void main(string[] args) {
double d1 = math.random();
system.out.println("d1 = " + d1);
int num1 = (int) (math.random() * 101); // [0.0,1.0) --> [0.0,101.0) ---->[0,100]
system.out.println("num1 = " + num1);
int num2 = (int) (math.random() * 100) + 1; // [0.0,1.0) --> [0.0,100.0) ---->[0,99] ---->[1,100]
system.out.println("num1 = " + num2);
}
}关键字break与continue
/*
1. break和continue关键字的使用
使用范围 在循环结构中的作用 相同点
break: switch-case
循环结构中 结束（或跳出）当前循环结构 在此关键字的后面不能声明执行语句。
continue: 循环结构中 结束（或跳出）当次循环 在此关键字的后面不能声明执行语句。
2. 了解带标签的break和continue的使用
3. 开发中，break的使用频率要远高于continue。
*/
class breakcontinuetest {
public static void main(string[] args) {
for (int i = 1; i <= 10; i++) {
if (i % 4 == 0) {
//break;
continue;
//编译不通过
//system.out.println("！！！！！！！！！");
}
system.out.print(i);
}
system.out.println();
//*******************************************
//lable:
for (int j = 1; j <= 4; j++) {
for (int i = 1; i <= 10; i++) {
if (i % 4 == 0) {
break;
//continue;
//了解
//break lable;
//continue lable;
}
system.out.print(i);
}
system.out.println();
}
}
}经典算法
/*
题目：找出100以内所有的素数（质数）？1000000以内的呢？
质数：只能被1和它本身整除的自然数。比如：2,3,5,7,11,13,17,19,23,……
---> 换句话说，从2开始到这个自然数-1为止，不存在在此自然数的约数。
*/
class primenumbertest {
public static void main(string[] args) {
//方式1：
/*
for(int i = 2; i <= 100; i++){ //遍历100以内的自然数
int number = 0; //i的约数的个数（从2开始，到i-1为止）
//判定i是否是质数
for(int j = 2; j < i; j++){
if(i % j == 0){
number++;
}
}
if(number == 0){
system.out.println(i);
}
}
*/
//方式2:
boolean isflag = true;
for (int i = 2; i <= 100; i++) { //遍历100以内的自然数
//判定i是否是质数
for (int j = 2; j < i; j++) {
if (i % j == 0) {
isflag = false;
}
}
if (isflag) {//if(isflag == true){
system.out.println(i);
}
//重置isflag
isflag = true;
}
}
}方式1
/*
遍历100000以内的所有的质数。体会不同的算法实现，其性能的差别
此primenumbertest1.java是实现方式1
*/
class primenumbertest1 {
public static void main(string[] args) {
boolean isflag = true;
int count = 0;//记录质数的个数
//获取系统当前的时间：
long start = system.currenttimemillis();
for (int i = 2; i <= 100000; i++) { //遍历100000以内的自然数
//判定i是否是质数
for (int j = 2; j < i; j++) {
if (i % j == 0) {
isflag = false;
}
}
if (isflag) {//if(isflag == true){
count++;
}
//重置isflag
isflag = true;
}
long end = system.currenttimemillis();
system.out.println("质数的总个数是：" + count);
system.out.println("花费的时间为：" + (end - start));
}
}方式2：
/*
遍历100000以内的所有的质数。体会不同的算法实现，其性能的差别
此primenumbertest2.java是实现方式2，针对primenumbertest1.java中算法的优化
*/
class primenumbertest1 {
public static void main(string[] args) {
boolean isflag = true;
int count = 0;//记录质数的个数
//获取系统当前的时间：
long start = system.currenttimemillis();
for (int i = 2; i <= 100000; i++) { //遍历100000以内的自然数
//判定i是否是质数
for (int j = 2; j <= math.sqrt(i); j++) {
if (i % j == 0) {
isflag = false;
break;//针对于非质数有效果
}
}
if (isflag) {//if(isflag == true){
count++;
}
//重置isflag
isflag = true;
}
long end = system.currenttimemillis();
system.out.println("质数的总个数是：" + count);
system.out.println("花费的时间为：" + (end - start));
}
}总结
到此这篇关于java流程控制语句的文章就介绍到这了,更多相关java流程控制内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论