第03天 java基础知识

今日内容介绍

• 选择流程控制语句

• 循环流程控制语句

• 控制循环语句

选择流程控制语句

顺序结构的基本使用

顺序结构概述

是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的

顺序流程流程图

代码案例一

**package** com.itheima_01;

/\*

\* 顺序结构：从上往下，依次执行

\*/

**public class** OrderDemo {

**public static void** main(String[] args) {

System.*out*.println("开始");

System.*out*.println("语句A");

System.*out*.println("语句B");

System.*out*.println("语句C");

System.*out*.println("结束");

}

}

If语句的格式

If语句格式1及执行流程

if语句第一种格式：

if(关系表达式) {

语句体

}

执行流程:

首先判断关系表达式看其结果是true还是false

如果是true就执行语句体

如果是false就不执行语句体

if语句格式1执行流程图

代码案例二

**package** com.itheima_02;

/\*

\* if语句有三种格式。

\*

\* if语句格式1：

\* if(关系表达式) {

\* 语句体;

\* }

\*

\* 执行流程：

\* A:首先判断关系表达式看其结果是true还是false

\* B:如果是true,就执行语句体

\* C:如果是false,就不执行语句体

\*/

**public class** IfDemo {

**public static void** main(String[] args) {

System.*out*.println("开始");

// 定义两个变量

**int** a = 10;

**int** b = 20;

**if** (a == b) {

System.*out*.println("a等于b");

}

**int** c = 10;

**if** (a == c) {

System.*out*.println("a等于c");

}

System.*out*.println("结束");

}

}

If语句格式2及执行流程

if语句第二种格式：

if(关系表达式) {

语句体1;

}else {

语句体2;

}

执行流程

首先判断关系表达式看其结果是true还是false

如果是true就执行语句体1

如果是false就执行语句体2

if语句格式2执行流程图

代码案例三

**package** com.itheima_02;

/\*

\* if语句格式2：

\* if(关系表达式) {

\* 语句体1;

\* }else {

\* 语句体2;

\* }

\*

\* 执行流程：

\* A:判断关系表达式的值是true还是false

\* B:如果是true，就执行语句体1

\* C:如果是false，就执行语句体2

\*/

**public class** IfDemo2 {

**public static void** main(String[] args) {

System.*out*.println("开始");

// 判断给定的数据是奇数还是偶数

// 定义变量

**int** a = 100;

// 给a重新赋值

a = 99;

**if** (a % 2 == 0) {

System.*out*.println("a是偶数");

} **else** {

System.*out*.println("a是奇数");

}

System.*out*.println("结束");

}

}

If语句格式3及执行流程

if语句第三种格式：

if(关系表达式1) {

语句体1;

}else if (关系表达式2) {

语句体2;

}

…

else {

语句体n+1;

}

执行流程

首先判断关系表达式1看其结果是true还是false

如果是true就执行语句体1

如果是false就继续判断关系表达式2看其结果是true还是false

如果是true就执行语句体2

如果是false就继续判断关系表达式…看其结果是true还是false

…

如果没有任何关系表达式为true，就执行语句体n+1

if语句格式3执行流程图

代码案例四

**package** com.itheima_02;

/\*

\* if语句格式3：

\* if(关系表达式1) {

\* 语句体1;

\* }else if(关系表达式2) {

\* 语句体2;

\* }else if(关系表达式3) {

\* 语句体3;

\* }

\* ...

\* else {

\* 语句体n+1;

\* }

\*

\* 执行流程：

\* A:首先判断关系表达式1看其结果是true还是false

\* B:如果是true，就执行语句体1

\* 如果是false，就继续进行关系表达式2的判断看其结果是true还是false

\* C:如果是true，就执行语句体2

\* 如果是false，就继续进行关系表达式...的判断看其结果是true还是false

\* ...

\* D:如果没有一个为true的，就执行语句体n+1

\*

\* if语句的三种格式：

\* 第一种格式适合做一种情况的判断

\* 第二种格式适合做二种情况的判断

\* 第三种格式适合做多种情况的判断

\*/

**public class** IfDemo3 {

**public static void** main(String[] args) {

// x和y的关系满足如下：

// x\>=3 y = 2x + 1;

// -1\<=x\<3 y = 2x;

// x\<=-1 y = 2x – 1;

// 根据给定的x的值，计算出y的值并输出。

// 定义变量

**int** x = 5;

/\*

*int* y;

if (x \>= 3) {

y = 2 \* x + 1;

} else if (x \>= -1 && x \< 3) {

y = 2 \* x;

} else if (x \<= -1) {

y = 2 \* x - 1;

}else {

y = 0;

}

\*/

**int** y = 0;

**if** (x \>= 3) {

y = 2 \* x + 1;

} **else if** (x \>= -1 && x \< 3) {

y = 2 \* x;

} **else if** (x \<= -1) {

y = 2 \* x - 1;

}

System.*out*.println("y的值是："+y);

}

}

If语句的练习

if语句实现获取两个数据较大值

代码案例五

**package** com.itheima_02;

**import** java.util.Scanner;

/\*

\* 键盘录入两个数据，获取这两个数据的较大值

\*

\* 分析：

\* A:看到键盘录入，我们就应该想到键盘录入的三步骤

\* 导包，创建对象，接收数据

\* B:获取这两个数据的较大值，其实就是判断两个数据谁大，把大的输出就可以了。

\*

\* 导包：

\* A:手动导包

\* import java.util.Scanner;

\* B:鼠标点击红色叉叉，自动生成

\* C:快捷键(推荐)

\* *ctrl*+shift+o

\*/

**public class** IfTest {

**public static void** main(String[] args) {

//创建对象

Scanner *sc* = **new** Scanner(System.*in*);

//接收数据

System.*out*.println("请输入第一个数据：");

**int** a = sc.nextInt();

System.*out*.println("请输入第二个数据：");

**int** b = sc.nextInt();

//采用if语句格式2实现

/\*

if(a\>b){

System.out.println("较大的值是："+a);

}else {

System.out.println("较大的值是："+b);

}

\*/

//拿到较大的值之后，我未必想直接输出，所以我们定义变量接收这个较大的值

**int** max;

**if**(a\>b){

max = a;

}**else** {

max = b;

}

//可能做其他的操作

//max += 100;

System.*out*.println("较大的值是："+max);

}

}

if语句实现判断学生等级

代码案例六

**package** com.itheima_02;

**import** java.util.Scanner;

/\*

\* 键盘录入学生考试成绩，请根据成绩判断该学生属于哪个级别

\* 90-100 优秀

\* 80-90 好

\* 70-80 良

\* 60-70 及格

\* 60以下 不及格

\*

\* 分析：

\* A:键盘录入学生考试成绩

\* 三步骤

\* B:通过简单的分析，我们决定采用if语句格式3来实现

\*

\* 程序一定要考虑周全了。

\* 安全数据

\* 边界数据

\* 错误数据

\*/

**public class** IfTest2 {

**public static void** main(String[] args) {

//创建对象

Scanner *sc* = **new** Scanner(System.*in*);

//接收数据

System.*out*.println("请输入学生的考试成绩：");

**int** score = sc.nextInt();

//if语句格式3

/\*

if(score\>=90 && score\<=100){

System.out.println("你的成绩属于优秀");

}else if(score\>=80 && score\<90){

System.out.println("你的成绩属于好");

}else if(score\>=70 && score\<80){

System.out.println("你的成绩属于良");

}else if(score\>=60 && score\<70){

System.out.println("你的成绩属于及格");

}else {

System.out.println("你的成绩属于不及格");

}

\*/

//我们发现程序不够健壮,加入错误数据的判断

**if**(score\<0 \|\| score\>100){

System.*out*.println("你的成绩是错误的");

}**else if**(score\>=90 && score\<=100){

System.*out*.println("你的成绩属于优秀");

}**else if**(score\>=80 && score\<90){

System.*out*.println("你的成绩属于好");

}**else if**(score\>=70 && score\<80){

System.*out*.println("你的成绩属于良");

}**else if**(score\>=60 && score\<70){

System.*out*.println("你的成绩属于及格");

}**else** {

System.*out*.println("你的成绩属于不及格");

}

}

}

switch语句的格式及执行流程

格式解释:

switch表示这是switch语句

表达式的取值：byte,short,int,char

JDK5以后可以是枚举

JDK7以后可以是String

case后面跟的是要和表达式进行比较的值

语句体部分可以是一条或多条语句

break表示中断，结束的意思，可以结束switch语句

default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

执行流程

首先计算出表达式的值

其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。

最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

switch语句执行流程图

switch语句的练习

switch语句实现根据数字输出对应星期

代码案例七

**package** com.itheima_03;

**import** java.util.Scanner;

/\*

\* switch语句格式：

\* switch(表达式) {

\* case 值1:

\* 语句体1;

\* break;

\* case 值2:

\* 语句体2;

\* break;

\* ...

\* default:

\* 语句体n+1;

\* break;

\* }

\* 格式解释：

\* 表达式:byte,short,*int*,char

\* JDK5以后可以是枚举

\* JDK7以后可以是字符串

\* case:就是要和表达式进行比较的值

\* break:表示中断,结束的意思。

\* default:表示所有的情况都不匹配的时候，就执行语句体n+1。和if语句的else相似。

\* 执行流程：

\* A:计算出表达式的值

\*
B:拿计算出来的值和case后面的值依次比较，一旦有对应的值，就执行该处的语句，在执行过程中，遇到
break，就结束。

\* C:如果所有的case都不匹配，就会执行default控制的语句，然后结束。

\* 需求：

\* 根据键盘录入的数值1，2，3，…7输出对应的星期一，星期二，星期三…星期日。

\*/

**public class** SwitchDemo {

**public static void** main(String[] args) {

//创建键盘录入对象

Scanner *sc* = **new** Scanner(System.*in*);

//接收数据

System.*out*.println("请输入一个数字(1-7)：");

**int** weekday = sc.nextInt();

//switch语句实现选择

**switch**(weekday) {

**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**;

**default**:

System.*out*.println("你输入的数字有误");

**break**;

}

}

}

循环流程控制语句

for循环的格式及基本使用

for循环语句格式：

for(初始化语句;判断条件语句;控制条件语句) {

循环体语句;

}

执行流程

A:执行初始化语句

B:执行判断条件语句，看其结果是true还是false

如果是false，循环结束。

如果是true，继续执行。

C:执行循环体语句

D:执行控制条件语句

E:回到B继续

for循环的执行流程图

代码案例八

**package** com.itheima_04;

/\*

\* for循环语句格式：

\* for(初始化语句;判断条件语句;控制条件语句) {

\* 循环体语句;

\* }

\*

\* 执行流程：

\* A:执行初始化语句

\* B:执行判断条件语句，看结果是true还是false

\* 如果是true，就继续执行

\* 如果是false，就结束循环

\* C:执行循环体语句

\* D:执行控制条件语句

\* E:回到B继续

\*

\* 需求：

\* 在控制台输出10次”HelloWorld”的案例。

\*/

**public class** ForDemo {

**public static void** main(String[] args) {

//原始写法

System.*out*.println("HelloWorld");

System.*out*.println("HelloWorld");

System.*out*.println("HelloWorld");

System.*out*.println("HelloWorld");

System.*out*.println("HelloWorld");

System.*out*.println("HelloWorld");

System.*out*.println("HelloWorld");

System.*out*.println("HelloWorld");

System.*out*.println("HelloWorld");

System.*out*.println("HelloWorld");

System.*out*.println("-------------------------");

//用循环改进

**for**(**int** x=1; x\<=10; x++) {

System.*out*.println("HelloWorld");

}

}

}

for循环的练习

for循环实现获取指定范围数据

代码案例九

**package** com.itheima_04;

/\*

\* 需求：获取数据1-5和5-1

\*/

**public class** ForTest {

**public static void** main(String[] args) {

//原始做法

System.*out*.println(1);

System.*out*.println(2);

System.*out*.println(3);

System.*out*.println(4);

System.*out*.println(5);

System.*out*.println("-------------");

//用循环改进

**for**(**int** x=1; x\<=5; x++) {

System.*out*.println(x);

}

System.*out*.println("-------------");

//1-5的数据我们获取到了，如何获取5-1呢?

**for**(**int** x=5; x\>=1; x--){

System.*out*.println(x);

}

}

}

for循环实现1-5之间数据求和

代码案例十

**package** com.itheima_04;

/\*

\* 需求：求出1-5之间数据之和

\*

\* 分析：

\* A:定义求和变量，初始化值是0

\* B:获取1-5之间的数据，用for循环实现

\* C:把每一次获取到的数据，累加起来就可以了

\* D:输出求和变量即可

\*/

**public class** ForTest2 {

**public static void** main(String[] args) {

//定义求和变量，初始化值是0

**int** sum = 0;

//获取1-5之间的数据，用for循环实现

**for**(**int** x=1; x\<=5; x++) {

//把每一次获取到的数据，累加起来就可以了

//sum = sum + x;

/\*

\* 第一次：sum = 0 + 1 = 1

\* 第二次：sum = 1 + 2 = 3

\* 第三次：sum = 3 + 3 = 6

\* 第四次：sum = 6 + 4 = 10

\* 第五次：sum = 10 + 5 = 15

\*/

sum += x;

}

//输出求和结果

System.*out*.println("sum:"+sum);

}

}

for循环实现1-100之间偶数和

代码案例十一

**package** com.itheima_04;

/\*

\* 需求：求出1-100之间偶数和

\*

\* 分析：

\* A:定义求和变量，初始化值是0

\* B:获取1-100之间的数据，用for循环实现

\* C:把获取到的数据进行判断，看是否是偶数

\* 如果是，就累加

\* D:输出求和结果

\*/

**public class** ForTest3 {

**public static void** main(String[] args) {

//定义求和变量，初始化值是0

**int** sum = 0;

//获取1-100之间的数据，用for循环实现

**for**(**int** x=1; x\<=100; x++) {

//把获取到的数据进行判断，看是否是偶数

**if**(x%2 ==0) {

sum += x;

}

}

//输出求和结果

System.*out*.println("sum:"+sum);

}

}

for循环实现在控制台打印水仙花数

代码案例十二

**package** com.itheima_04;

/\*

\* 需求：在控制台输出所有的”水仙花数”

\*

\* 分析：

\* 什么是水仙花数呢?

\* 所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。

\* 举例：153就是一个水仙花数。

\* 153 = 1\*1\*1 + 5\*5\*5 + 3\*3\*3

\*

\* A:三位数其实就告诉了我们水仙花数的范围

\* 100-999

\* B:如何获取一个数据的每一个位上的数呢?

\* 举例：我有一个数据153，请问如何获取到个位，十位，百位

\* 个位：153%10 = 3;

\* 十位：153/10%10 = 5;

\* 百位：153/10/10%10 = 1;

\* 千位：...

\* 万位：...

\*
C:让每个位上的立方和相加，并和该数据进行比较，如果相等，就说明该数据是水仙花数，在控制台输出

\*/

**public class** ForTest4 {

**public static void** main(String[] args) {

//通过循环获取到每一个三位数

**for**(**int** x=100; x\<1000; x++) {

//获取个位，十位，百位

**int** ge = x%10;

**int** shi = x/10%10;

**int** bai = x/10/10%10;

//让每个位上的立方和相加，并和该数据进行比较，如果相等，就说明该数据是水仙花数，在控制台输出

**if**((ge\*ge\*ge+shi\*shi\*shi+bai\*bai\*bai) == x) {

System.*out*.println(x);

}

}

}

}

for循环实现统计水仙花的个数

代码案例十三

**package** com.itheima_04;

/\*

\* 需求：统计”水仙花数”共有多少个

\*

\* 分析：

\* A:定义统计变量，初始化值是0

\* B:获取三位数，用for循环实现

\* C:获取三位数的个位，十位，百位

\* D:判断这个三位数是否是水仙花数，如果是，统计变量++

\* E:输出统计结果就可以了

\*/

**public class** ForTest5 {

**public static void** main(String[] args) {

//定义统计变量，初始化值是0

**int** count = 0;

//获取三位数，用for循环实现

**for**(**int** x=100; x\<1000; x++) {

//获取三位数的个位，十位，百位

**int** ge = x%10;

**int** shi = x/10%10;

**int** bai = x/10/10%10;

//判断这个三位数是否是水仙花数，如果是，统计变量++

**if**((ge\*ge\*ge+shi\*shi\*shi+bai\*bai\*bai) == x) {

count++;

}

}

//输出统计结果就可以了

System.*out*.println("水仙花数共有："+count+"个");

}

}

while循环的格式及基本使用

while循环语句格式

基本格式

while(判断条件语句) {

循环体语句;

}

扩展格式

初始化语句;

while(判断条件语句) {

循环体语句;

控制条件语句;

}

执行流程图

代码案例十四

**package** com.itheima_05;

/\*

\* while循环语句的基本格式：

\* while(判断条件语句) {

\* 循环体语句;

\* }

\* 扩展格式：

\* 初始化语句;

\* while(判断条件语句) {

\* 循环体语句;

\* 控制条件语句;

\* }

\*

\* 回顾for循环的语句格式：

\* for(初始化语句;判断条件语句;控制条件语句) {

\* 循环体语句;

\* }

\*/

**public class** WhileDemo {

**public static void** main(String[] args) {

//输出10次HelloWorld

/\*

for(*int* x=1; x\<=10; x++) {

System.out.println("HellloWorld");

}

\*/

//while循环实现

**int** x=1;

**while**(x\<=10) {

System.*out*.println("HellloWorld");

x++;

}

}

}

while循环的练习

while循环实现1-100之间数据求和

代码案例十五

**package** com.itheima_05;

/\*

\* 求1-100之和。

\* 练习：统计水仙花个数。

\*/

**public class** WhileTest {

**public static void** main(String[] args) {

//回顾for循环实现

/\*

//定义求和变量

*int* sum = 0;

//获取1-100之间的数据

for(*int* x=1; x\<=100; x++) {

//累加

sum += x;

}

System.out.println("1-100的和是："+sum);

\*/

//while循环实现

//定义求和变量

**int** sum = 0;

**int** x = 1;

**while**(x\<=100) {

sum += x;

x++;

}

System.*out*.println("1-100的和是："+sum);

}

}

do…while循环的格式及基本使用

do…while循环语句格式

基本格式

do {

循环体语句;

}while((判断条件语句);

扩展格式

初始化语句;

do {

循环体语句;

控制条件语句;

} while((判断条件语句);

执行流程图

代码案例十六

**package** com.itheima_06;

/\*

\* do...while循环的基本格式：

\* do {

\* 循环体语句;

\* }while(判断条件语句);

\* 扩展格式：

\* 初始化语句;

\* do {

\* 循环体语句;

\* 控制条件语句;

\* }while(判断条件语句);

\* 执行流程：

\* A:执行初始化语句;

\* B:执行循环体语句;

\* C:执行控制条件语句;

\* D:执行判断条件语句，看是true还是false

\* 如果是true，回到B继续

\* 如果是false，就结束

\*

\* 练习：

\* 求和案例

\* 统计水仙花个数

\*/

**public class** DoWhileDemo {

**public static void** main(String[] args) {

//输出10次 HelloWorld

/\*

for(*int* x=1; x\<=10; x++) {

System.out.println("HelloWorld");

}

\*/

//do...while改写

**int** x=1;

**do** {

System.*out*.println("HelloWorld");

x++;

}**while**(x\<=10);

}

}

三种循环的区别

区别概述

虽然可以完成同样的功能，但是还是有小区别：

do…while循环至少会执行一次循环体。

for循环和while循环只有在条件成立的时候才会去执行循环体

for循环语句和while循环语句的小区别：

使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。

代码案例十七

**package** com.itheima_06;

/\*

\* 三种循环的区别：

\* A:do...while至少执行一次循环体

\* B:for,while循环先判断条件是否成立，然后决定是否执行循环体

\*

\* for和while的小区别：

\*
for循环的初始化变量，在循环结束后，不可以被访问。而while循环的初始化变量，是可以被继续使用的。

\* 如果初始化变量，后面还要继续访问，就使用while，否则，推荐使用for。

\*

\* 循环的使用推荐：

\* for -- while -- do...while

\*/

**public class** DoWhileDemo2 {

**public static void** main(String[] args) {

/\*

*int* x = 3;

while(x\<3) {

System.out.println("我爱林青霞");

x++;

}

System.out.println("--------------");

*int* y = 3;

do {

System.out.println("我爱林青霞");

y++;

}while(y\<3);

\*/

**for**(**int** x=1; x\<=10; x++){

System.*out*.println("爱生活，爱Java");

}

//这里的x无法继续访问

//System.out.println(x);

System.*out*.println("-----------------");

**int** y = 1;

**while**(y\<=10) {

System.*out*.println("爱生活，爱Java");

y++;

}

System.*out*.println(y);

}

}

控制循环语句

控制跳转语句break

Break的使用场景和作用

break的使用场景：

在选择结构switch语句中

在循环语句中

离开使用场景的存在是没有意义的

break的作用：

跳出单层循环

代码案例十八

**package** com.itheima_07;

/\*

\* break:中断的意思

\* 使用场景：

\* A:switch语句中

\* B:循环中

\* 注意：

\* 离开使用场景是没有意义的。

\* 作用：

\* 跳出循环，让循环提前结束

\*/

**public class** BreakDemo {

**public static void** main(String[] args) {

//break;

**for**(**int** x=1; x\<=10; x++) {

**if**(x == 3) {

**break**;

}

System.*out*.println("HelloWorld");

}

}

}

控制跳转语句continue

continue的使用场景：

在循环语句中

离开使用场景的存在是没有意义的

continue的作用：

单层循环对比break，然后总结两个的区别

break 退出当前循环

continue 退出本次循环

代码案例十九

**package** com.itheima_07;

/\*

\* continue:继续的意思

\* 使用场景：

\* 循环中

\* 注意：

\* 离开使用场景是没有意义的

\* 作用：

\* 结束一次循环，继续下一次的循环

\* 区别：

\* break:退出循环

\* continue:结束一次循环，继续下一次的循环

\*/

**public class** ContinueDemo {

**public static void** main(String[] args) {

//continue;

**for**(**int** x=1; x\<=10; x++) {

**if**(x == 3) {

//break;

**continue**;

}

System.*out*.println("HelloWorld");

}

}

}

控制跳转语句练习

练习需求:

按要求分析结果，并验证

for(int x=1; x\<=10; x++) {

if(x%3==0) {

**//分别写break，continue，说说输出几次**

}

System.out.println(“我爱林青霞”);

}

代码案例二十

**package** com.itheima_07;

/\*

\* 按要求分析结果，并验证

\*

\* break：输出2次

\* continue:输出7次

\*/

**public class** BreakAndContinueDemo {

**public static void** main(String[] args) {

**for** (**int** x = 1; x \<= 10; x++) {

**if** (x % 3 == 0) {

// 分别写break，continue，说说输出几次

//break;

**continue**;

}

System.*out*.println("我爱林青霞");

}

}

}