一、随堂复习
1.1（了解）流程控制结构
·顺序结构
·分支结构
·if-else
·switch-case
·循环结构
·for
·while
·do-while
1.2分支结构之一：if-else
·在程序中，凡是遇到了需要使用分支结构的地方，都可以考虑使用if-else
·if-else嵌套的练习多关注
基本语法：
/*
分支结构1：if-else条件判断结构
1、格式
格式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 + "是奇数");
}
案例：
//*************************************************
/*
案例3：岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆跑车；
成绩为（80,90]时，奖励一辆山地自行车；
当成绩为[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("胖揍一顿");
}
*/
/*但是这样写是错误的
score = 88;
if(score == 100){
System.out.println("奖励一辆跑车");
}else if(score >= 60){
System.out.println("奖励环球影城一日游");
}else if(score > 80){
System.out.println("奖励一辆山地自行车");
}else{
System.out.println("胖揍一顿");
}
结论：
1、如果多个条件表达式之间没有交集（理解为互不相容关系），则哪个条件表达式声明在上面，哪个声明在下面都可以。
如果多个条件表达式之间是包含关系，则需要将范围小的条件表达式声明在范围大的条件表达式上面。否则，范围小的条件表达式不可能被执行
2、特别地：如果else后面没有任何操作，则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);
//System.out.println(num1 + "," + num3 + "," + num2);
}
}
}
1.3分支结构之二：switch-case
·在特殊的场景下，分支结构可以考虑使用switch-case
·指定的数据类型：byte、short、char、int、枚举类（jdk5.0）、String（jdk7.0）
·可以考虑的常量值有限且取值情况不多
·特别之处：case穿透
·在能使用switch-case的情况下，推荐使用switch-case，因为switch-case的效率稍高
基本语法：
/*
分支结构之switch-case的使用
1、语法格式
switch(表达式){
case 常量1:
//执行语句1
break;
case 常量2:
//执行语句2
break;
.....
default:
//执行语句3
break;
}
2、执行过程：
根据表达式中的值，依次匹配case语句。一旦与某一个case中的常量相等，那么久执行此case此case中的执行语句。
执行完此执行语句之后
情况1：遇到break，则执行break后，跳出当前的switch-case结构
情况2：没有遇到break，则继续执行其后的case中的执行语句。（并不会再与其它case语句中的常量匹配了，直接执行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;
}
//default位置任意时：
int num1 = 10;
switch(num1){
default:
System.out.println("other");
//break; // 若此时不加break，则结果出了输出other外，还会输出zero
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;
}
//另例：
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;
*/
}
//错误的例子：编译不通过
/*
int number = 20;
switch(number){
case number > 0:
System.out.println("正数");
break;
case number > 0:
System.out.println("负数");
break;
default:
System.out.println("零");
break;
}
*/
}
}
案例：
/*
案例：使用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：
switch(score / 10){
case 0:
System.out.println("不及格");
break;
case 1:
System.out.println("不及格");
break;
case 2:
System.out.println("不及格");
break;
case 3:
System.out.println("不及格");
break;
case 4:
System.out.println("不及格");
break;
case 5:
System.out.println("不及格");
break;
case 6:
System.out.println("及格");
break;
case 7:
System.out.println("及格");
break;
case 8:
System.out.println("及格");
break;
case 9:
System.out.println("及格");
break;
case 10:
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:
default:
System.out.println("成绩输入有误");
break;
}
//方式3：不是很严谨，如果超过分数区间，则结果是不对的
switch (score / 60){
case 0:
System.out.println("不及格");
case 1:
System.out.println("及格");
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 12;
sumDays = 31 + 28 +...+ 30 + day;
break;
}
*/
//方式2：
switch (month){
case 12:
sumDays += 30;
case 11:
sumDays += 31;
case 10:
sumDays += 30;
case 9:
sumDays += 31;
case 8:
sumDays += 31;
case 7:
sumDays += 30;
case 6:
sumDays += 31;
case 5:
sumDays += 30;
case 4:
sumDays += 31;
case 3:
sumDays += 28; //28:二月份的总天数
case 2:
sumDays += 31; //31:一月份的总天数
case 1:
sumDays += day;
//break;
}
System.out.println("2023年" + month + "月" + day + "日是当年的第" + sumDays + "天");
input.close();//防止内存泄漏
}
}
1.4循环结构之一：for
·凡是循环结构，都有四个要素：①初始化条件 ②循环条件(boolean类型) ③循环体 ④迭代条件
·应用场景：有明确的遍历次数。for(int i = 1;i <= 100;i++)
基本语法：
/*
循环结构之一：for循环
1、Java规范了3种循环结构：for、while、do-while
2、凡是循环结构，就一定会有四个要素：
①初始化条件
②循环条件 ----> 一定是boolean类型的变量或者表达式
③循环体
④迭代部分
3、for循环的格式
for(①;②;④){
③
}
执行过程：① - ② - ③ - ④ - ② - ③ - .....- ②
*/
class ForTest{
public static void main(String[] args) {
//需求1：题目：输出5行Hello World!
for(int i = 1;i <= 5;i++){
System.out.println("Hello World!");
}
//此时编译不通过,因为i已经出了其作用域范围
//System.out.println(i);
//需求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;//sum = 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;//或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,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){
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.5循环结构之二：while
·应用场景：没有明确的遍历次数。
基本语法：
/*
循环结构之一：while循环
1、凡是循环结构，就一定会有四个要素：
①初始化条件
②循环条件 ----> 一定是boolean类型的变量或者表达式
③循环体
④迭代部分
2、while的格式
①
while(②){
③
④
}
3、执行过程：① - ② - ③ - ④ - ② - ③ - ④ - .... - ②
4、for循环与while循环可以相互转换！
5、for循环和while循环的小区别：初始化条件的作用域范围不同。while循环的初始化条件在while循环结束后，依然有效。
*/
class WhileTest{
public static void main(String[] args) {
//需求1：遍历5次HelloWorld
int i = 1;
while (i <= 5){
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 + "次");
scan.close();
}
}
/*
世界上最高山峰是珠穆朗玛峰，它的高度是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.6循环结构之三：do-while
·至少会执行一次循环体
·开发中，使用较少
基本语法：
/*
循环结构之一：do-while循环
1、凡是循环结构，就一定会有四个要素：
①初始化条件
②循环条件 ----> 一定是boolean类型的变量或者表达式
③循环体
④迭代部分
2、do-while的格式
①
do{
③
④
}while(②);
执行过程：① - ③ - ④ - ② - ③ - ④ - .... - ②
3、说明：
1）do - while 循环至少执行一个循环体。
2）当第一次就满足循环条件时，for、while、do-while循环三者之间是可以相互转换的。
3）do-while循环结构，在开发中，相较于for、while循环来讲，使用的较少。
*/
class DoWhileTest {
public static void main(String[] args){
//需求：遍历100以内的偶数，并输出偶数的个数和总和
int i = 1;
int count = 0;//记录偶数的个数
int sum = 0;//记录偶数的总和
do{
if (i % 2 == 0){
System.out.println(i);
count++;
sum += i;
}
i++;
}while (i <= 100);
System.out.println("偶数个数为：" + count);
System.out.println("偶数的总和为：" + sum);
//**************************************************
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);
}
}
案例：
/*
题目：模拟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);
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("输入有误，请重新输入");
//break;
}
}while (flag);
//关闭资源
scan.close();
}
}
1.7“无限”循环
基本语法：
/*
“无限”循环结构的使用
1、格式：while(true)或for(;;)
2、开发中，有时并不确定需要循环多少次，需要根据循环体内部某些条件，来控制循环的结束（使用break）。
3、如果此循环结构不能终止，则构成了死循环！开发中要避免死循环。
*/
class ForWhileTest{
public static void main(String[] args) {
/*
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;//记录负数的个数
for (; ; ){//while (true){
System.out.print("请输入一个整数（输入为0时结束程序）：");
int num = scan.nextInt();//获取用户输入的整数
if (num > 0){ // 正数
positiveCount++;
}else if (num < 0){ //负数
negativeCount++;
}else{ // 零
System.out.println("程序结束");
break;
}
}
System.out.println("正数的个数为：" + positiveCount);
System.out.println("负数的个数为：" + negativeCount);
scan.close();
}
}
1.8嵌套循环
基本语法：
/*
嵌套循环的使用：
1、嵌套循环：是指一个循环结构A的循环体是另一个循环结构B。
外层循环：循环结构A
内存循环：循环结构B
2、说明：
1）内层循环充当了外层循环的循环体。
2）对于两层嵌套循环来说，外层循环控制行数，内层循环控制列数。
3）举例：外层循环执行m次，内层循环执行n次，则内层循环的循环体共执行m*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 j = 1;j <= 5;j++ ){
for (int i = 1;i <= 6;i++){
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();
}
/* i(第几行) j(每一行中-的个数) k(每一行中*的个数) 2*i + j = 10 ---->j = 10 - 2 * i k = 2 * i - 1
--------* 1 8 1
------* * * 2 6 3
----* * * * * 3 4 5
--* * * * * * * 4 2 7
* * * * * * * * * 5 0 9
* * * * * * *
* * * * *
* * *
*
*/
//上半部分
for (int i = 1;i <= 5;i++){
// 空格
for (int j = 1;j <= 10 - 2 * i;j++){
System.out.print(" ");
}
// *
for (int k = 1;k <= 2 * i - 1;k++){
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();
}
}
}
1.9关键字break、continue
·break在开发中常用，而continue较少使用
·笔试题：break和continue的区别
基本语法：
/*
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();
//**********************************************
/*label:*/ for (int j = 1;j <= 4;j++){
for (int i = 1;i <= 10;i++){
if(i % 4 ==0){
//break;
//continue;
//了解
//break label;
//continue label;
}
System.out.print(i);
}
System.out.println();
}
}
}
1.10项目一：谷粒记账软件
·特点1：代码量增大，逻辑更复杂。----->推荐多写，多写几遍
·特点2：内部不包含新的知识点。 ----->不太着急写
1.11 Scanner类的使用
基本语法：
/*
如何从键盘获取不同类型（基本数据类型、String类型）的变量：使用Scanner类。
1、使用Scanner获取不同类型数据的步骤
步骤1：导包 import java.util.Scanner;
步骤2：提供（或创建）一个Scanner类的实例
步骤3：调用Scanner类中的方法，获取指定类型的变量(nextXxx())
步骤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();
}
}
1.12获取随机数
基本语法：
/*
如何获取一个随机数？
1、可以使用Java提供的API：math类的random()
2、random()调用以后，会返回一个[0.0,1.0)范围的double型的随机数
3、需求1、获取一个[0,100]范围的随机整数？
需求2、获取一个[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("num2 = " + num2);
}
}
1.13体会算法魅力
·基本实现：
/*
题目：找出100以内的所有的素数（质数）？100000以内的呢？
质数：只能被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以内的自然数
boolean isFlag = true;
//判定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) {
//获取系统当前的时间：
long start = System.currentTimeMillis();
boolean isFlag = true;
int count = 0;//记录质数的个数
for (int i = 2;i <= 100000;i++){ //遍历100000以内的自然数
//判定i是否是质数
for (int j = 2;j < i;j++){
if (i % j == 0){
isFlag = false;
}
}
if(isFlag){
count++;
}
//重置isFlag
isFlag = true;
}
//获取当前系统的时间：
long end = System.currentTimeMillis();
System.out.println("质数的总个数为：" + count);//9592个
System.out.println("花费的时间为：" + (end - start));//19秒
}
}
测试性能：方式2
/*
遍历100000以内的所有的质数。体会不同的算法实现，其性能的差别
此PrimeNumberTest2.java是实现方式2，针对于PrimeNumberTest1.java中算法的优化
*/
class PrimeNumberTest2{
public static void main(String[] args) {
//获取系统当前的时间：
long start = System.currentTimeMillis();
boolean isFlag = true;
int count = 0;//记录质数的个数
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){
count++;
}
//重置isFlag
isFlag = true;
}
//获取当前系统的时间：
long end = System.currentTimeMillis();
System.out.println("质数的总个数为：" + count);//9592个
System.out.println("花费的时间为：" + (end - start));//19秒 -->加上break：1.8秒 -->加上Math.sqrt(i ):24毫秒
}
}
二、企业真题
1、break和continue的作用
略
2、if分支语句和switch分支语句的异同之处
if语句优势：
if语句的条件是一个布尔类型值，if条件表达式为true则进入分支，可以用于范围的判断，也可以用于等值的判断，使用范围更广。
switch语句的条件是一个常量值（byte、short、int、char、枚举、String），只能判断某个变量或表达式的结果是否等于某个常量值，使用场景较狭窄。
switch语句优势：
当条件是判断某个变量或表达式是否等于某个固定的常量值时，使用if和switch都可以，习惯上使用switch更多。因为效率更高。当条件是区间范围的判断时，只能使用if语句。
使用switch可以利用其穿透性，同时执行多个分支，而if-else没有穿透性
3、什么时候用if，什么时候选用语句switch
同上
4、switch语句中忘写break会发生什么
case穿透
5、Java支持哪些类型循环
for、while、do-while
增强for，放到集合中讲解
6、while和do-while循环的区别
do-while至少执行一次
1271
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
