java基础语法——条件判断与循环语句
目录
一、流程控制语句
流程控制语句分类
二、顺序结构
顺序结构概述
顺序结构图
三、选择结构
选择结构概述
选择结构(if语句1)
选择执行图1
选择结构(if语句2)
选择执行图2
选择结构(if语句3)
选择执行图3
选择结构(switch语句)
switch语句执行流程图
四、 循环结构
for循环语句图
五、 循环结构(while循环语句)
while循环语句执行流程图
六、 循环结构(do…while循环语句)
do…while循环语句执行流程图
流程控制语句
在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。
流程控制语句分类
——顺序结构
——选择结构
——循环结构
顺序结构
顺序结构概述
——是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
——总的来说：写在前面的先执行，写在后面的后执行
顺序结构图
package com.demo01;
/*
* 顺序结构：从上往下依次进行
*/
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("结束");
}
}
选择结构
选择结构概述
–也被称为分支结构。
–选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。
–Java语言提供了两种选择结构语句
- if语句
- switch语句
选择结构(if语句1)
- if语句有三种格式
- if语句第一种格式：
–if(关系表达式) {
语句体
}
- 执行流程
——首先判断关系表达式看其结果是true还是false
——如果是true就执行语句体
——如果是false就不执行语句体
package com.demo02;
/*
* if语句有三种格式
*
* if语句格式：
* 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("结束");
}
}
选择执行图1
选择结构(if语句2)
- if语句第二种格式：
–if(关系表达式){
语句体1;
}else{
语句体2;
}
- 执行流程
–首先判断关系表达式看其结果是true还是false
–如果是true就执行语句体1
–如果是false就执行语句体2
选择执行图2
package com.demo02;
import java.util.Scanner;
/*
* 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("开始");
// 判断给定的数据是奇数还是偶数
Scanner sc = new Scanner(System.in);
//接受数据
System.out.println("请录入一个整数：");
int a = sc.nextInt();
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。
选择执行图3
*
* if语句的3种格式
* 第一种适合做一种判断
* 第二种适合做两种判断
* 第三种适合做多种判断
*/
public class IfDemo3 {
public static void main(String[] args) {
while (true) {
// x和y的关系满足如下：
// x>=3 y = 2x + 1;
// -1<=x<3 y = 2x;
// x<-1 y = 2x-1;
//
// 根据给定的x的值,计算y并输出
//
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个数：");
int x = sc.nextInt();
int y = 0;
//根据x的值给y赋值ֵ
if (x >= 3) {
y = 2 * x + 1;
} else if (x >= -1 && x < 3) {
y = 2 * x;
} else if(x >= -10 && x < -1){
y = 2 * x - 1;
}
System.out.println("y的值是"+y);
}
}
}
练习：键盘录入学生考试成绩，请根据成绩判断该学生属于那个级别
package com.demo02;
import java.util.Scanner;
/*
* 键盘录入学生考试成绩，请根据成绩判断属于哪个级别
* 90-100 优秀
* 80-90 好
* 70-80 良
* 60-70 及格
* 60以下 不及格
*
* 分析：
* A:键盘录入学生考试成绩
* 三步骤
* B:ͨ通过简单分析，我们决定采用if语句格式来实现
*
* 程序一定要考虑周全
* 安全数据
* 边界数据
* 错误数据
*/
public class IfTest2 {
public static void main(String[] args) {
while(true) {
// 创建对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("输入考生成绩:");
int score = sc.nextInt();
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(表达式) {
case 值1：
语句体1;
break;
case 值2：
语句体2;
break;
…
default：
语句体n+1;
break;
}
•格式解释
–switch表示这是switch语句
•表达式的取值：byte,short,int,char
•JDK5以后可以是枚举
•JDK7以后可以是String
–case后面跟的是要和表达式进行比较的值
–语句体部分可以是一条或多条语句
–break表示中断，结束的意思，可以结束switch语句
–default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
•执行流程
–首先计算出表达式的值
–其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
–最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
switch语句执行流程图
package com.demo03;
import java.util.Scanner;
/*
* switch语句格式
* switch(表达式) {
* case ֵ1:
* 语句体1;
* break;
* case ֵ2:
* 语句体22;
* 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) {
// 创建对象
while(true) {
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;
}
}
}
}
循环结构
——循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。
循环语句的组成
–初始化语句：
•一条或者多条语句，这些语句完成一些初始化操作。
–判断条件语句：
•这是一个boolean 表达式，这个表达式能决定是否执行循环体。
–循环体语句：
•这个部分是循环体语句，也就是我们要多次做的事情。
–控制条件语句：
•这个部分在一次循环体结束后，下一次循环判断条件执行前执行。通过用于控制循环条件中的变量，使得循环在合适的时候结束。
for循环语句格式：
–for(初始化语句;判断条件语句;控制条件语句){
循环体语句；
}
–执行流程
•A:执行初始化语句
•B:执行判断条件语句，看其结果是true还是false
–如果是false，循环结束。
–如果是true，继续执行。
•C:执行循环体语句
•D:执行控制条件语句
•E:回到B继续
for循环语句图
循环结构(for循环练习)
- 在控制台输出10次Hello Word
- 获取数据1-5和5-1
- 求出1-5之间数据之和
- 求出1-100之间偶数和
- 在控制台输出所有的”水仙花数”
- 统计”水仙花数”共有多少个
练习1：在控制台输出10次Hello Word
package com.demo04;
/*
* for循环语句格式
* for(初始化语句；判断条件语句；控制条件语句) {
* 循环体语句;
* }
*
*
* A:ִ执行初始化语句
* B:ִ执行判断条件语句，看结果是true还是false
* 如果是true，就继续执行
* 如果是false,就结束循环
* C:ִ执行循环体语句
* D:ִ执行控制条件语句
* E:回到B继续
*
* 需求：
* 在控制台输出10次hello word
*/
public class ForDemo {
public static void main(String[] args) {
for (int x = 1; x <= 10; x++) {
System.out.println("HelloWorld:"+x);
}
}
}
练习2：获取数据1-5和5-1
package com.demo04;
/*
* for循环语句格式
* for(初始化语句；判断条件语句；控制条件语句) {
* 循环体语句;
* }
*
* ִ执行过程
* A:ִ执行初始化语句
* B:ִ执行判断条件语句，看结果是true还是false
* 如果是true，就继续执行
* 如果是false,就结束循环
* C:ִ执行循环体语句
* D:ִ执行控制条件语句
* E:回到B继续
*
* 需求：
* 获取数据1-5和5-1
*/
public class ForDemo {
public static void main(String[] args) {
System.out.println("*************");
for (int x = 1; x <= 5; x++) {
System.out.println(x);
}
System.out.println("*************");
for(int i=5;i>=1;i--) {
System.out.println(i);
}
}
}
练习3：求出1-5之间数据之和
package com.demo04;
/*
* for循环语句格式
* for(初始化语句；判断条件语句；控制条件语句) {
* 循环体语句;
* }
*
* ִ执行过程
* A:ִ执行初始化语句
* B:ִ执行判断条件语句，看结果是true还是false
* 如果是true，就继续执行
* 如果是false,就结束循环
* C:ִ执行循环体语句
* D:ִ执行控制条件语句
* E:回到B继续
*
* 需求：
* 求出1-5之间数据之和
*/
public class ForDemo {
public static void main(String[] args) {
int sum = 0;
System.out.println("*************");
for (int x = 1; x <= 5; x++) {
sum = sum + x;
}
System.out.println("1-5之和为："+ sum);
}
}
练习4：求出1-100之间偶数和
package com.demo04;
/*
* for循环语句格式
* for(初始化语句；判断条件语句；控制条件语句) {
* 循环体语句;
* }
*
* ִ执行过程
* A:ִ执行初始化语句
* B:ִ执行判断条件语句，看结果是true还是false
* 如果是true，就继续执行
* 如果是false,就结束循环
* C:ִ执行循环体语句
* D:ִ执行控制条件语句
* E:回到B继续
*
* 需求：
* 求出1-100之间偶数和
*/
public class ForDemo {
public static void main(String[] args) {
int sum = 0;
System.out.println("*************");
for (int x = 1; x <= 100; x++) {
if (x%2==0) {
sum = sum + x; }
}
System.out.println("1-100 偶数之和为："+ sum);
}
}
练习5：在控制台输出所有的”水仙花数”
package com.demo04;
/*
* 需求：在控制台输出所有的水仙花数
*
* 分析：
* 什么是水仙花数?
* 所谓的水仙花数是指一个三位数，是指各位数字的立方和等于该数本身
* 举例子：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<=999; 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);
}
}
}
}
练习6：统计”水仙花数”共有多少个
package com.demo04;
/*
* 需求：在控制台输出所有的水仙花数
*
* 分析：
* 什么是水仙花数?
* 所谓的水仙花数是指一个三位数，是指各位数字的立方和等于该数本身
* 举例子：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) {
//ͨ通过循环获取到每一个三位数
int count = 0;
for(int x=100; x<=999; 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(判断条件语句) {
循环体语句;
控制条件语句; }
while循环语句执行流程图
package com.demo05;
/*
* while循环语句的基本格式
* while(判断条件语句) {
* 循环体语句;
* }
* 扩展格式
* 初始化语句;
* while(判断条件语句) {
* 循环体语句;
* 控制条件语句
* }
*
* 回顾for循环语句格式
* for(初始化语句；判断条件语句；控制条件语句) {
* 循环体语句;
* }
*/
public class WhileDemo {
public static void main(String[] args) {
//输出10次hello World
/*
* for(int x=1; x<=10; x++) { System.out.println("HellloWorld"); }
*/
//while循环实现
int x=1;
while(x<=10) {
System.out.println("HellloWorld");
x++;
}
System.out.println(x);
}
}
循环结构(do…while循环语句)
do…while循环语句格式：
–基本格式
do {
循环体语句;
}while((判断条件语句);
–改版格式
初始化语句;
do {
循环体语句;
控制条件语句;}
while((判断条件语句);
do…while循环语句执行流程图
package com.demo06;
/*
* do...while循环基本格式
* do {
* 循环体语句;
* }while(判断条件语句);
* 扩展格式
* 初始化语句;
* do {
* 循环体语句;
* 控制条件语句;
* }while(判断条件语句);
* ִ执行流程
* A:ִ执行初始化语句
* B:ִ执行循环体语句
* C:ִ执行控制条件语句;
* D:ִ执行判断条件语句
* 如果是true，回到B继续
* 如果是false,就结束
*
*
*/
public class DoWhileDemo {
public static void main(String[] args) {
int x=1;
System.out.println("************************");
do {
System.out.println("HelloWorld");
x++;
}while(x<=10);
}
}
循环结构(三种循环的区别)
虽然可以完成同样的功能，但是还是有小区别：
–do…while循环至少会执行一次循环体。
–for循环和while循环只有在条件成立的时候才会去执行循环体
for循环语句和while循环语句的小区别：
–使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。（for 变量定义在括号里边，while 变量定义在括号外边）
跳转控制语句
- 我想让循环在某一步的时候结束或者跳过某些数据不要，现在就做不了这件事情。为了弥补这个缺陷，Java就提供了break，continue来实现控制语句的中断和跳转。
- break 中断
- continue 继续
- break的使用场景：
–在选择结构switch语句中
–在循环语句中
–离开使用场景的存在是没有意义的
- break的作用：
–跳出单层循环
package com.demo07;
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的作用：
–单层循环对比break，然后总结两个的区别
•break 退出当前循环
•continue 退出本次循环
package com.demo07;
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");
}
}
}
退出当前循环，往后走
随机数
- 作用：———– 用于产生一个随机数
- 使用步骤(和Scanner类似)
–导包
•import java.util.Random;
–创建对象
•Random r = new Random()
–获取随机数
•int number = r.nextInt(10);
•产生的数据在0到10之间，包括0，不包括10。
•如何获取一个1-100之间的随机数呢?
import java.util.Random;
/**
*
* @author 无限嚣张(菜菜)
* 使用步骤(和Scanner类似)
* –导包
*
* •import java.util.Random;
*
* –创建对象
*
* •Random r = new Random()
*
* –获取随机数
*
* •int number = r.nextInt(10);
*/
public class SuiJiShu {
public static void main(String[] args) {
for(int x=1;x<=10;x++) {
// TODO Auto-generated method stub
// 创建对象
Random Sc = new Random();
//接收数据
int i = Sc.nextInt(10);
System.out.println(i);}
//如何获取1-100
//int i = Sc.nextInt(100)+1;
}
}
随机数练习：猜数字小游戏 (拒绝赌博，热爱家庭)
import java.util.Random;
import java.util.Scanner;
/**
*
* @author 无限嚣张(菜菜)
* 使用步骤(和Scanner类似)
* –导包
*
* •import java.util.Random;
*
* –创建对象
*
* •Random r = new Random()
*
* –获取随机数
*
* •int number = r.nextInt(10);
* 猜数字小游戏案例
* 系统产生一个1-100之间的随机数
* 分析：
* A：系统产生一个1-100之间的随机数
* random r = new Random();
* int number = r.nextInt(100)+1;
* B:键盘录入我们要猜的数据
* C：比较这两个数据，用if语句实现
* 大了：提示大了
* 笑了：提示小了
* 猜中：提示恭喜你猜中了
* D：多次猜数据，而我们不知道猜多少次怎么办呢？
* while(true) 循环体语句
*/
public class SuiJiShu {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 创建对象
while(true) {
Random Sc = new Random();
//接收数据
int i = Sc.nextInt(10);
System.out.println("随机数为：");
System.out.println(i);
//创建键盘录入数据
Scanner sc = new Scanner(System.in);
//接受数据
System.out.println("请输入您要猜的数字：");
int j = sc.nextInt();
if(i>j) {
System.out.println("猜小了");
}
else if(i