ChapterTwo---Java基本语法：变量、运算符与流程控制（下）
- 程序流程控制
- ① 顺序结构
- ② 分支结构
- ⑴if-else结构
- ⑵ switch-case结构
- ③ 循环结构
- ⑴ 循环结构之for循环
- ●代码演示
- ⑵ 循环结构之while循环
- ●代码演示
- ⑶ 循环结构之do-while循环
- ●代码演示
- ●循环语句综合例题
- ⑷嵌套循环
- ●代码演示
- ●九九乘法表
- ●素数问题一
- ④ 特殊关键字的使用break、continue
- ⑴ break的使用
- ●代码演示
- ⑵continue的使用
- ●代码演示
- ●break-continue综合演示
- ●素数问题优化一
- ●素数问题优化二
- ⑤return的使用
- ⑥特殊流程控制语句说明
程序流程控制
① 顺序结构
② 分支结构
⑴if-else结构
if-else的使用说明
- 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量。
- 语句块只有一条执行语句时，一对{}可以省略，但建议保留
- if-else语句结构，根据需要可以嵌套使用。
- 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略。
- 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓。当多个条件是“包含”关系时，“小上大下 / 子上父下”
Scanner类的使用说明
import java.util.Scanner;
/*
* 如何从键盘获取不同类型的变量：需要使用Scanner类
*
* 具体实现步骤：
* 1.导包：import java.util.Scanner;
* 2.Scanner的实例化：Scanner scan=new Scanner(System.in)
* 3.调用Scanner类的相关方法，来获取指定类型的变量:字符串是next()；基本类型就是nextXxx()，但是没有nextChar()一说
*
* 注意：需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不
* 匹配时，会报异常：导致程序终止。
*/
public class ScannerTest {
public static void main(String[] args) {
//Scanner的实例化
Scanner scan=new Scanner(System.in);
//调用Scanner类的相关方法
System.out.println("请输入你的姓名：");
String name=scan.next();
System.out.println("请输入你的芳龄:");
int age=scan.nextInt();
System.out.println(age);
System.out.println("请输入你的体重：");
double weight=scan.nextDouble();
System.out.println(weight);
System.out.println("请输入你的性别");
String sex=scan.next();
char sexChar=sex.charAt(0);
System.out.println(sexChar);
System.out.println("是否相中我了：true/false");
boolean bool=scan.nextBoolean();
System.out.println(bool);
//课后练习4：如何获取一个随机数：10-99
//方式一：
int value=(int)(Math.random()*90+10);//[0.0,1.0)-->[0.0,90.0)--->[10.0,100.0)--->[10,100)
//方式二：
int value1=(int)(Math.random()*90)+10;//[0.0,1.0)--->[0.0,90.0)--->[0,90)--->[10,100)
//总结[a,b)的随机
//int value=(int)(Math.random()*(b-a+1)+a);
System.out.println(value);
System.out.println(value1);
}
}import java.util.Scanner;
/*
* 分支结构中的if-else(条件判断结构)
*
* 一、三种结构
* 第一种：
* if(条件表达式){
*
* }
*
* 第二种：二选一
* if（条件表达式）{
* 执行表达式1
* }else{
* 执行表达式2
* }
*
* 第三种：多选一
* i条件表达式f（条件表达式）{
* 执行表达式1
* }else if（）{
* 执行表达式2
* }
* else if（）{
* 执行表达式3
* }
* ...
* else{
* 执行表达式n
* }
*
* 说明：
* 1.else结构是可选的。
* 2.针对条件表达式：
* >如果多个条件表达式之间时“互斥”关系（或没有交集的关系），哪个判断和执行语句声明在上面还是下面，无所谓。
* >如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结果声明在上面。
* >如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
*/
public class ifTest {
public static void main(String[] args) {
//举例1
int heartBeats=70;
if(heartBeats < 60 || heartBeats>100){
System.out.println("需要做进一步检查");
}
System.out.println("检查结束");
//举例2
int age=23;
if(age<18){
System.out.println("你还可以看动画片");
}else{
System.out.println("可以看成人电影了");
}
//举例3
if(age<0){
System.out.println("您输入的数据非法");
}else if(age<18){
System.out.println("青少年时期");
}else if(age<35){
System.out.println("青壮年时期");
}else if(age<60){
System.out.println("中年时期");
}else if(age<120){
System.out.println("老年时期");
}else{
System.out.println("你是要成仙啊");
}
/*练习题:岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆BMW；
成绩为(80，99]时，奖励一台iphone xs max；
当成绩为[60,80]时，奖励一个 iPad；
其它时，什么奖励也没有。
请从键盘输入岳小鹏的期末成绩，并加以判断*/
System.out.println("请输入岳小鹏的期末成绩：（0-100）");
Scanner scan=new Scanner(System.in);
int score=scan.nextInt();
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("什么奖励也没有");
}
}
}⑵ switch-case结构
switch语句有关规则
- switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，char，int，枚举 (jdk 5.0)，String (jdk 7.0)；
- case子句中的值必须是常量，不能是变量名或不确定的表达式值；
- 同一个switch语句，所有case子句中的常量值互不相同；
- break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾;
- default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，执行default。
package com.shangguigu.flowcontrol;
import java.util.Scanner;
/**
*
* @author 刘瘦瘦
*分支结构之二：switch-case
*
* 1.格式
* switch(表达式){
* case 常量1：
* //执行语句1;
* //break;
* case 常量2：
* //执行语句1;
* //break;
* ...
* default:
* 执行语句n;
* //break;
* }
* 2.说明：
* ①根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
* 当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case末尾结束为止。
*
* ②break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构。
*
* ③switch结构中的表达式，只能是如下的6中数据类型之一：byte、short、char、int、枚举类型（JDK5.0）新增
* String类型（JDK7.0新增）
*
* ④case之后只能声明常量。不能声明范围。
*
* ⑤break关键字是可选的。
*
* ⑥default：相当于if-else结构中的else
* default结构是可选的，而且位置是灵活的。
*
* ⑦ 1. 凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立。
2. 我们写分支结构时，当发现既可以使用switch-case,（同时，switch中表达式的取值情况不太多），
又可以使用if-else时，我们优先选择使用switch-case。原因：switch-case执行效率稍高。
*/
public class SwitchCaseTest {
public static void main(String[] args) {
int number=2;
switch(number){
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
default:
System.out.println("three");
//break;可加可不加，最后加上
}
String season="autumn";
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;
}
//*****如下的两种情况都编译不通过****
//情况一
boolean isHandsome = true;
/*switch(isHandsome){
case true:
System.out.println("我好帅啊~~~");
break;
case false:
System.out.println("我好丑啊~~~");
break;
default:
System.out.println("输入有误~~~");
}*/
//情况二：
/*
int age = 10;
switch(age){
case age > 18:
System.out.println("成年了");
break;
default:
System.out.println("未成年");
}
*/
/*
例题：对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。
说明：如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。
*/
/*
int score = 78;
switch(score){
case 0:
case 1:
case 2:
...
case 100:
}
*/
/*
int score = 78;
if(score >= 60){
}else{
}
*/
int score = 78;
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;
}
//更优的解决方案：
switch(score / 60){
case 0:
System.out.println("不及格");
break;
case 1:
System.out.println("及格");
break;
}
//default是可选的
/*
编写程序：从键盘上输入2019年的“month”和“day”，要求通过程序输出输入的日期为2019年的第几天。
2 15: 31 + 15
5 7: 31 + 28 + 31 + 30 + 7
....
说明:break在switch-case中是可选的
*/
Scanner scan=new Scanner(System.in);
System.out.println("请输入2019年的month:");
int month=scan.nextInt();
System.out.println("请输入2019的day:");
int day=scan.nextInt();
//定义一个变量来保存天数
int sumDays=0;
//方式一：冗余
/*
if(month == 1){
sumDays = day;
}else if(month == 2){
sumDays = 31 + day;
}else if(month == 3){
sumDays = 31 + 28 + day;
}else if(month == 4){
sumDays = 31 + 28 + 31 + day;
}
//...
else{//month == 12
//sumDays = ..... + day;
}
*/
//方式二：冗余
/*
switch(month){
case 1:
sumDays = day;
break;
case 2:
sumDays = 31 + day;
break;
case 3:
sumDays = 31 + 28 + day;
break;
...
}
*/
//方式三：
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;
case 2:
sumDays += 31;
case 1:
sumDays += day;
}
System.out.println("2019年" + month + "月" + day + "日是当年的第" + sumDays + "天");
/*
从键盘分别输入年、月、日，判断这一天是当年的第几天
注：判断一年是否是闰年的标准：
1）可以被4整除，但不可被100整除
或
2）可以被400整除
说明：
1. 凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立。
2. 我们写分支结构时，当发现既可以使用switch-case,（同时，switch中表达式的取值情况不太多），
又可以使用if-else时，我们优先选择使用switch-case。原因：switch-case执行效率稍高。
*/
System.out.println("请输入year：");
int year=scan.nextInt();
System.out.println("请输入month:");
int month2=scan.nextInt();
System.out.println("请输入day:");
int day2=scan.nextInt();
//定义一个变量来保存天数
int sumDays2=0;
switch(month2){
case 12:
sumDays2 += 30;
case 11:
sumDays2 += 31;
case 10:
sumDays2 += 30;
case 9:
sumDays2 += 31;
case 8:
sumDays2 += 31;
case 7:
sumDays2 += 30;
case 6:
sumDays2 += 31;
case 5:
sumDays2 += 30;
case 4:
sumDays2 += 31;
case 3:
if((year%4==0&&year%100!=0)||year %400==0){
sumDays2 += 29;
}else{
sumDays2 += 28;
}
case 2:
sumDays2 += 31;
case 1:
sumDays2 += day2;
}
System.out.println(year+"年" + month2 + "月" + day2+ "日是当年的第" + sumDays2 + "天");
}
}③ 循环结构
⑴ 循环结构之for循环
●代码演示
/**
* For循环结构的使用
* 一、循环结构的4个要素
* ①初始化条件
* ②循环条件--->是boolean类型
* ③循环体
* ④迭代条件
*
* 二、for循环的结构
* for(①;②;④){
* ③
* }
* 执行过程：①-②-③-④-②-③-④-...-②
*
*
*/
public class ForTest {
public static void main(String[] args) {
for(int i=1;i<=5;i++){
System.out.println("Hello World!");
}
//i:for循环内有效。出了for循环就失效了
//Syste.out.println(i);
//练习：
int num=1;
for(System.out.print('a');num<=3;System.out.print("c"),num++){
System.out.print('b');
}
//输出结果：abcbcbc
System.out.println();
例题：遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
int sum=0;//记录所有偶数的和
int count=0;//记录偶数的个数
for(int i=1;i<=100;i++){
if(i%2==0){
System.out.println(i);
sum+=i;
count++;
}
}
System.out.println("总和为:"+sum);
System.out.println("个数为:"+count);
/*题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60。*/
Scanner sc=new Scanner(System.in);
System.out.println("请输入第一个整数：m");
int m=sc.nextInt();
System.out.println("请输入第二个整数：n");
int n=sc.nextInt();
//获取最大公约数（从大到小遍历）
//1.获取两个数中的最小值
int min=(m>=n)? m:n;
//2.遍历
for(int i=min;i>=1;i--){
if(m%i==0 && n%i==0){
System.out.println("最大公约数:"+i);//最大公约数:4
break;
}
}
//获取最小公倍数，取值范围是[两者中的最小数--两个数的乘积]
//1.获取两个数中的最大值
int max=(m>n)?m:n;
//2.遍历
for(int i=max;i<=m*n;i++){
if(i%m==0 && i%n==0){
System.out.println("最小公倍数为："+i);//最小公倍数为：60
break;
}
}
}
}⑵ 循环结构之while循环
●代码演示
*
* while循环的使用
*
* 一、循环结构的四个要素
* ①初始化条件
* ②循环条件-->是boolean类型
* ③循环体
* ④迭代条件
*
* 二、while循环的结构
*
* ①
* while（②）{
* ③；
* ④；
* }
* 执行过程：①-->②-->③-->④-->②-->③-->④-...-②
* 说明：
* 1.写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环。
* 2.我们写程序，要避免出现死循环。
* 3.for循环和while循环都是可以相互转换的！
* 区别：for循环和while循环的初始条件部分的作用范围不同。
*
* 算法：有限性。
*/
public class WhileTest {
public static void main(String[] args) {
//遍历100以内的所有偶数
int i=1;
while(i<=100){
if(i%2==0){
System.out.println(i);
}
i++;
}
//出了while循环以后仍然可以调用。
System.out.println(i);//101
}
}⑶ 循环结构之do-while循环
●代码演示
/*
* do-while循环的使用
* 一循环的四个要素
* ①初始条件
* ②循环条件-->是boolean类型
* ③循环体
* ④迭代条件
* 二、do-while循环结构
* ①
* do {
* ③;
* ④;
* }while(②);
*
* 执行过程：①-③-④-②-③-④-...-②
* 说明：
* 1.do-while循环至少会执行一次循环体！
* 2.开发中，使用for和while更多一些。较少使用do-while
*/
public class DoWhileTest {
public static void main(String[] args) {
//遍历100以内的偶数，并计算所有偶数的和及偶数的个数
int num=1;
int sum=0;//记录总和
int count=0;//记录个数
do{
if(num%2==0){
System.out.println(num);
sum+=num;
count++;
}
num++;
}while(num<=100);
System.out.println("总和为:"+sum);
System.out.println("个数为:"+count);
//******体会do-while至少执行一次循环体*****
int number1=10;
while(number1>10){
System.out.println("hello:while");//不输出
number1--;
}
int number2=10;
do{
System.out.println("hello do-while");//输出
number2--;
}while(number2>10);
}
}●循环语句综合例题
import java.util.Scanner;
/*
题目：
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
说明：
1.不在循环条件部分限制次数的结构：for（;;）或while（true）
2.结束循环有几种方式？
方式一：循环条件部分返回false
方式二：在循环体中，执行break
*/
public class ForWhile {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int positiveNumber=0;//记录整数的个数
int negativeNumber=0;//记录负数的个数
for(;;){//while(true){
int number=sc.nextInt();
//判断number的正负情况
if(number>0){
positiveNumber++;
}else if(number<0){
negativeNumber++;
}else{
//一旦执行break，跳出循环
break;
}
}
System.out.println("输入的正数个数为："+positiveNumber);
System.out.println("输入的负数个数为："+negativeNumber);
}
}⑷嵌套循环
●代码演示
/**
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环
2.
外层循环：循环结构B
内层循环：循环结构A
3. 说明
① 内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
② 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次
4. 技巧：
外层循环控制行数，内层循环控制列数
*
*/
public class ForForTest {
public static void main(String[] args) {
//******
//System.out.println("******");
for(int i = 1;i <= 6;i++){
System.out.print('*');
}
System.out.println("\n");
/*
******
******
******
******
*/
for(int j = 1;j <= 4;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 = 5 换句话说：j = 5 - i;
**** 1 4
*** 2 3
** 3 2
* 4 1
*/
for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 5 - i;j++){
System.out.print("*");
}
System.out.println();
}
/*
*
**
***
****
*****
****
***
**
*
*/
//略
/*
----*
---* *
--* * *
-* * * *
* * * * *
* * * *
* * *
* *
*
*/
System.out.println("-----------------");
//上半部分
for(int i=1;i<=5;i++){
for(int j=1;j<=5-i;j++){
System.out.print(' ');
}
for(int z=1;z<=i;z++){
System.out.print("* ");
}
System.out.println();
}
//下半部分
for(int i=1;i<=4;i++){
for(int j=1;j<=i;j++){
System.out.print(" ");
}
for(int z=1;z<=5-i;z++){
System.out.print("* ");
}
System.out.println();
}
}
}●九九乘法表
/*
嵌套循环的应用1：
九九乘法表
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
。。。
9 * 1 = 9 。。。 9 * 9 = 81
*/
public 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();
}
}
}●素数问题一
/*
100以内的所有质数的输出。
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。
最小的质数是：2
*/
public class PrimeNumberTest {
public static void main(String[] args) {
boolean isFlag=true;//标识i是否被j除尽，一旦除尽，修改其值
for(int i=2;i<=100;i++){
for(int j=2;j<i;j++){
if(i%j==0){//除尽
isFlag=false;
}
}
if(isFlag==true){
System.out.println(i);
}
isFlag=true;
}
}
}④ 特殊关键字的使用break、continue
⑴ break的使用
●代码演示
public class BreakTest {
public static void main(String[] args) {
for(int i=0;i<10;i++){
if(i==3){
break;
}
System.out.println("i="+i);//0,1,2
}
}
}⑵continue的使用
●代码演示
public class ContinueTest {
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
if (i%10==0) continue;
System.out.println(i);
}
}
}●break-continue综合演示
/*
* break和continue关键字的使用
* 使用范围 循环使用的作用（不同点） 相同点
* break： switch-case、 结束当前循环 关键字后面不能声明执行语句
* 循环结构中
*
* continue：循环结构中 结束当次循环 关键字后面不能声明执行语句
*/
public class BreakContinueTest {
public static void main(String[] args) {
for(int i=1;i<=10;i++){
if(i%4==0){
break;//123
//continue;//123567910
//System.out.println("今晚迪丽热巴来约我喲");
}
System.out.print(i);
}
System.out.println();
//*********************
label:for(int i=1;i<=4;i++){
for(int j=1;j<=10;j++){
if(j%4==0){
//break;//默认跳出包裹此关键字最近的一层循环
//continue;
//break label;//结束指定标识的一层循环结构
continue label;//结束指定标识的一层循环结构的当次循环
}
System.out.print(j);
}
}
}
}●素数问题优化一
/*
100000以内的所有质数的输出。
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。
最小的质数是：2
*/
public class PrimeNumberTest2 {
public static void main(String[] args) {
boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
int count = 0;//记录质数的个数
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long start = System.currentTimeMillis();
for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
//优化二：对本身是质数的自然数是有效的。
//for(int j = 2;j < i;j++){
for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
if(i % j == 0){ //i被j除尽
isFlag = false;
break;//优化一：只对本身非质数的自然数是有效的。
}
}
//
if(isFlag == true){
//System.out.println(i);
count++;
}
//重置isFlag
isFlag = true;
}
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long end = System.currentTimeMillis();
System.out.println("质数的个数为：" + count);
System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13
}
}●素数问题优化二
/*
100000以内的所有质数的输出。实现方式二
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。
对PrimeNumberTest.java文件中质数输出问题的优化
*/
class PrimeNumberTest2 {
public static void main(String[] args) {
int count = 0;//记录质数的个数
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long start = System.currentTimeMillis();
label:for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
if(i % j == 0){ //i被j除尽
continue label;
}
}
//能执行到此步骤的，都是质数
count++;
}
//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long end = System.currentTimeMillis();
System.out.println("质数的个数为：" + count);
System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13
}
}⑤return的使用
⑥特殊流程控制语句说明
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
