JAVA基础4——流程控制语句
流程控制语句
流程控制语句：可以控制程序的执行流程。
流程控制语句的分类
- 顺序结构
- 选择结构
- 循环结构
顺序语句
执行流程
从上往下，依次执行。
选择语句
选择结构的分类
- if语句
- switch语句
if语句
if语句的格式1
if(比较表达式) {
语句体;
}
public class Dome_if {
public static void main(String[] args){
int age=12;
if (age >= 18) {
System.out.println("允许访问此网站");
}
System.out.println("禁止访问此网站");
}
}
执行流程：
先计算比较表达式的值，看其返回值是true还是false。
如果是true，就执行语句体；
如果是false，就不执行语句体；
注意事项
- 比较表达式无论简单还是复杂，结果必须是boolean类型
- if语句控制的语句体如果是一条语句，大括号可以省略；
如果是多条语句，就不能省略。建议永远不要省略。 - 一般来说：有左大括号就没有分号，有分号就没有左大括号
if语句的格式2
if(比较表达式) {
语句体1;
}else {
语句体2;
}
import java.util.Scanner;
public class Dome_if {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入你的年龄");
int x=sc.nextInt();
if (x >= 18) {
System.out.println("允许访问此网站");
}
else{
System.out.println("禁止访问此网站");
}
}
}
执行流程：
首先计算比较表达式的值，看其返回值是true还是false。
如果是true，就执行语句体1；
如果是false，就执行语句体2；
- 注意事项：else后面是没有比较表达式的，只有if后面有。
if语句和三元运算符完成同一个效果
三元运算符实现的，都可以采用if语句实现。反之不成立。
什么时候if语句实现不能用三元改进呢?
当if语句控制的操作是一个输出语句的时候就不能。
为什么呢?因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。
if语句的格式3：
if(比较表达式1) {
语句体1;
}else if(比较表达式2) {
语句体2;
}else if(比较表达式3) {
语句体3;
}
...
else {
语句体n+1;
}
执行流程：
- 首先计算比较表达式1看其返回值是true还是false，
- 如果是true，就执行语句体1，if语句结束。
- 如果是false，接着计算比较表达式2看其返回值是true还是false，
- 如果是true，就执行语句体2，if语句结束。
- 如果是false，接着计算比较表达式3看其返回值是true还是false，
- 如果都是false，就执行语句体n+1。
注意事项:最后一个else可以省略,但是建议不要省略,可以对范围外的错误值提示
/*需求：
* 键盘录入x的值，计算出y的并输出。
* x>=3 y = 2 * x + 1;
* -1<x<3 y = 2 * x;
* x<=-1 y = 2 * x - 1;
*/
import java.util.Scanner;
public class Dome_if1 {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入X的值");
int x=sc.nextInt();
int y=0;
if(x>=3){
y = 2 * x + 1;
}else if(x<3&&x>-1){
y = 2 * x;
}else if(x<=-1){
y = 2 * x - 1;
}else {
System.out.println("请输入正确的实数");
}
System.out.println("y的值为"+y);
}
}
if语句的嵌套使用
需求：获取三个数据中的最大值
import java.util.Scanner;
public class Dome_if2 { //需求：获取三个数据中的最大值
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请用回车键分别提交三个整数");
int a=sc.nextInt();
int b=sc.nextInt();
int c=sc.nextInt();
if(a>b){ //a>b
if(a>c){ //a>b & a>c
System.out.println("最大值为："+a);
}else{ //a>b & c>=a
System.out.println("最大值为："+c);
}
}else{ //b>=a
if (b>c){ //b>=a & b>c
System.out.println("最大值为："+b);
}else{ //b>=a & c>=b
System.out.println("最大值为："+c);
}
}
}
}
switch语句
switch语句的格式
switch(表达式) {
case 值1：
语句体1;
break;
case 值2：
语句体2;
break;
…
default：
语句体n+1;
break;
}
执行流程
- 先计算表达式的值
- 然后和case后面的匹配，如果有就执行对应的语句，否则执行default控制的语句
import java.util.Scanner;
public class Dome_switch {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("AI智能预测你喜欢的人");
System.out.println("请输入你的名字：");
String name=sc.next();
switch (name){
case "圆圆":System.out.println(name+"喜欢糖糖");
break;
case "糖糖":System.out.println(name+"喜欢圆圆");
break;
default:System.out.println("我他妈管你喜欢谁");
break;
}
}
}
switch用于定义选择结构范围。
表达式：被选择的结果，该表达式只能有四种类型：byte,short,int,char
注意：在JDK5以后，还支持一个叫做枚举的类型(enum);JDK7以后，还支持String类型。
case：被选择的答案
break：跳出，结束switch语句。
default：默认的意思。当所有的case都不匹配时，执行default里面的内容。相当于if语句中的else。
注意事项
- case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
- default可以省略吗?
- 可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
- 特殊情况：
- case就可以把值固定。
- A,B,C,D
- break可以省略吗?
- 最后一个可以省略,其他最好不要省略
- 会出现一个现象：case穿透。
- 最终我们建议不要省略
- default一定要在最后吗?
- 不是，可以在任意位置。但是建议在最后。
- switch语句的结束条件
- 遇到break就结束了
- 执行到switch的右大括号就结束了
练习：
看程序写结果：
public class switch1 {
public static void main(String[] args){
int x = 2;
int y = 3;
switch(x){
default:
y++;
break;
case 3:
y++;
case 4:
y++;
}
System.out.println("y="+y);
}
}
输出结果如下：y=4
public class switch1 {
public static void main(String[] args){
int x = 2;
int y = 3;
switch(x){
default:
y++; //没有break不跳转，继续往下执行
case 3:
y++;
case 4:
y++;
}
System.out.println("y="+y);
}
}
输出结果如下：y=6
两段代码的不同之处在于default下面break的有无，第二段代码利用了case穿透
if语句和switch语句的区别:
- 如果是对具体的个数的数值进行判断两种皆可，
建议使用switch，因为它会将被选答案加载进内存，选择效率会稍高。 - switch建议判断固定值的时候用
- if建议如果运算结果是Boolean类型或者判断区间或范围的时候用
练习：
分别用switch语句和if语句实现下列需求：
键盘录入月份，输出对应的季节
if语句
import java.util.Scanner;
public class Text_if {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入月份");
int month=sc.nextInt();
if(month==3 |month==4 | month==5){
System.out.println(month+"月是春季");
}else if (month==6 |month==7 | month==8){
System.out.println(month+"月是夏季");
}else if (month==9 |month==10 | month==11){
System.out.println(month+"月是秋季");
}else if (month==12 |month==1 | month==2){
System.out.println(month+"月是冬季");
}else{
System.out.println("请输入正确的月份");
}
}
}
switch语句
import java.util.Scanner;
public class Text_switch {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入月份");
int month=sc.nextInt();
switch (month){
case 3:
case 4:
case 5: System.out.println(month+"月是春季");
break;
case 6:
case 7:
case 8: System.out.println(month+"月是夏季");
break;
case 9:
case 10:
case 11: System.out.println(month+"月是秋季");
break;
case 12:
case 1:
case 2: System.out.println(month+"月是冬季");
break;
default:System.out.println("请输入正确的月份");
break;
}
}
}
循环结构
- 循环结构的分类
for,while,do...while
for语句
for语句的格式：
for(初始化表达式;条件表达式;循环后的操作表达式) {
循环体;
}
例子
for(int x=0;x<10;x++){
System.ot.println("输出语句");
}
执行流程：
- 执行初始化语句
- 执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环 - 执行循环体语句;
- 执行循环后的操作表达式
- 回到2继续。
练习
- 需求：求出1-10之间整数之和
- 需求：求出1-100之间偶数和
- 需求：求出1-100之间奇数和
public class Dome_for {
public static void main(String[] args){
int sum=0;
for(int i=1;i<=10;i++){
sum=sum+i;
}
System.out.println("sum="+sum);
System.out.println("-----------------------"); /*上下定义相同变量i没有关系，for语句中定义的变量，使用过后就释放了*/
int sum1=0;
for(int i=0;i<=100;i+=2){
sum1=sum1+i;
}
System.out.println("100以内偶数的和="+sum1);
System.out.println("------------------------"); /*上下定义相同变量i没有关系，for语句中定义的变量，使用过后就释放了*/
int sum2=0;
for(int i=1;i<=100;i+=2){
sum2=sum2+i;
}
System.out.println("100以内奇数的和="+sum2);
}
}
注意事项：
上下定义相同变量i没有关系，for语句中定义的变量，使用过后就释放了
练习：
需求1：在控制台输出所有的”水仙花数”
所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
举例：153就是一个水仙花数。
153 = 1×1×1 + 5×5×5 + 3×3×3 = 1 + 125 + 27 = 153
需求2：统计”水仙花数”共有多少个
public class Dome_for1 {
public static void main(String[] args){
int count=0;
for (int num=100;num<1000;num++){
if (num==(num%10)*(num%10)*(num%10)+(num/10%10)*(num/10%10)*(num/10%10)+(num/100)*(num/100)*(num/100)){
count++; //计数器思想，满足条件就自增
System.out.println("第"+count+"个水仙数是"+num);
}
}
}
}
运行结果：
第1个水仙数是153
第2个水仙数是370
第3个水仙数是371
第4个水仙数是407
while语句
while语句的基本格式：
while(判断条件语句) {
循环体语句;
}
完整格式：
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
执行流程：
- 执行初始化语句
- 执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环 - 执行循环体语句;
- 执行控制条件语句
- 回到2继续。
例：控制台输出数据1-10
int x=1;
while(x<=10){
System.out.println("x="+x)
x++;
}
练习：
- 求和思想
求1-100之和 - 统计思想
统计”水仙花数”共有多少个
/*
* A:求和思想
* 求1-100之和
* B:统计思想
* 统计”水仙花数”共有多少个
*/
public class Dome_While {
public static void main(String[] args){
int i=1;
int sum=0;
while (i<=100){
sum+=i;
i++;
}
System.out.println("100以内和为："+sum);
System.out.println("-----------------------");
int count=0;
int num=100;
while (num<=999){
if (num==(num%10)*(num%10)*(num%10)+(num/10%10)*(num/10%10)*(num/10%10)+(num/100)*(num/100)*(num/100)){
count++;
}
num++;
}
System.out.println("水仙花数有"+count+"个");
}
}
注意事项：
- while(条件表达式)不要加分号，否则结果很可能不是你想要的。
- while所控制的语句是一条的时候，也可以省略大括号，但是不建议。
do…while语句
do…while语句的基本格式：
do {
循环体语句;
}while(判断条件语句);
完整格式:
初始化语句;
do {
循环体语句;
控制条件语句;
}while(判断条件语句);
执行流程：
- 执行初始化语句
- 执行循环体语句;
- 执行控制条件语句
- 执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环 - 回到2继续
例:
需求：请在控制台输出数据1-10
int i=1;
do{
System.out.println("i="+i);
i++;
}while(i<=10);
三种循环语句的区别
for , while , do...while
三种循环语句的区别:
while 和do while的区别:
- while后面有分号
- do…while循环至少执行一次循环体。
- 而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句,可能一次都不执行。
public class Dome_difference {
public static void main(String[] args) {
//while 和do while的区别
int i = 11;
do {
System.out.println("i = " + i);
i++;
}
while (i <= 10); //细节 ;
System.out.println("---------------------");
int j = 11;
while (j <= 10) {
System.out.println("j = " + j);
j++;
}
}
}
运行结果如下：
i = 11
---------------------
for和while的区别：
- for语句执行后变量会被释放,不能再使用
- while语句执行后,初始化变量还可以继续使用
public class Dome_difference {
public static void main(String[] args) {
for (int a = 1;a <= 5 ;a++ ) {
System.out.println("a = " + a);
}
//a在这里没有作用,已经消失
System.out.println("a = " + a); //for语句执行后变量会被释放,不能再使用
System.out.println("-------------------");
int b=1;
while (b <= 5) {
System.out.println("b = " + b);
b++;
}
System.out.println("-------------------");
System.out.println("b = " + b); //while语句执行后,初始化变量还可以继续使用
}
}
运行结果如下：
这是因为for语句执行后变量会被释放,不能再使用
注释掉错误代码后，运行结果如下：
a = 1
a = 2
a = 3
a = 4
a = 5
-------------------
b = 1
b = 2
b = 3
b = 4
b = 5
-------------------
b = 6
while循环和for循环是等价的
- 变量的生命周期不一样。一般来说，只在它所属的{}内有效。
- 当你定义的初始化变量只为递增而存在，那么就用for循环，效率较高。
- 当你定义的初始化变量，操作完后，还得继续使用，用while循环。
- 因为变量及早的从内存中消失，可以提高内存的使用效率。
无限循环
两种最简单的死循环格式
while(true){...}//while语句的最简单无限循环格式true
for(;;){...}//for语句的最简单无限循环格式-----条件表达式默认为true
注意：一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
while无限循环
public class Dome_InfiniteLoop { //InfiniteLoop无限循环
public static void main(String[] args){
while (true){
System.out.println("InfiniteLoop");
}
System.out.println("InfiniteLoop"); //因为上面的语句无限循环，所以这一句无法执行
}
}
输出结果：
这是由于上面的语句无限循环，所以这一句无法执行
修改后的结果如下：
for无限循环
public class Dome_InfiniteLoop { //InfiniteLoop无限循环
public static void main(String[] args){
for (;;){
System.out.println("Infinite Loop");
}
}
}
输出结果：
public class Dome_InfiniteLoop { //InfiniteLoop无限循环
public static void main(String[] args){
int x = 1;
for(System.out.println("a");x<3;System.out.println("c")){
System.out.println("d");
}
}
}
输出结果：
输出结果为a d c d c
这里涉及到for语句的执行顺序
循环嵌套
- 外循环执行一次，内循环执行多次。
- 如果是打印形状等，外循环控制行数，内循环控制列数。
//需求：请输出一个4行5列的星星(*)图案
public class Dome_forfor {
public static void main(String[] args){
for (int a=1;a<=4;a++){ //外循环决定行数
for (int b=1;b<=5;b++){ //内循环决定列数
System.out.print("*");
}
System.out.println(); //每打印一行就换行
}
}
}
输出结果：
例：
打印正三角 :
内循环的循环条件表达式变化
内循环的循环条件表达式随着外循环的变化而变化。
- 外:(int x=0;x<5;x++)
- 内:(int y=0;y<=x;y++)
打印倒三角 :
内循环的初始化表达式变化
内循环的初始化表达式随着外循环的变化而变化。
- 外:(int x=0;x<5;x++)
- 内:(int y=x;y<5;y++)
public class Dome_forfor1 {
public static void main(String[] args){
for (int a=1;a<=4;a++){ //外循环决定行数
for (int b=1;b<=a;b++){ //内循环决定列数
System.out.print("*");
}
System.out.println();
}
System.out.println("-----------------");
for (int a=4;a>0;a--){
for (int b=1;b<=a;b++){
System.out.print("*");
}
System.out.println();
}
}
}
输出结果：
乘法表
public class Dome_forfor2 {
public static void main(String[] args) {
for (int a = 1; a <= 9; a++) {
for (int b = 1; b <= a; b++) {
int sum=a*b;
System.out.print(a+"×"+b+"="+sum+'\t');
}
System.out.println();
}
}
}
累加思想与计数器思想
- 通过变量记录每次 变化的结果；通过循环进行累加动作。
- 通过变量记录数据的状态变化，也需通过循环完成。
- 计数器的条件根据实际情况而定
注意：一定要注意哪些语句参与循环，哪些语句不参与循环。
代码优化
注意：
'\x' x表示任意，\是转义符号,这种做法叫转移字符。
'\t' tab键的位置
'\r' 回车
'\n' 换行
'\"' 输出双引号
'\'' 输出单引号
控制跳转语句(break&continue)
break的使用场景：
只能在switch和循环中
continue的使用场景：
只能在循环中
continue和break异同
- 都有自己的应用范围
1. continue用于循环
2. break用于选择结构和循环结构
单独使用：他们单独使用时，无意义，并且下面不可以有语句，因为执行不到。 - break结束当前所在循环，continue结束本次循环，进入下一次循环。
标号可以改变跳出的循环。但是一般不用
标号:标记某个循环对其控制
标号组成规则:其实就是合法的标识符
public class Dome_mark {
public static void main(String[] args){
System.out.println("mark的使用");
http://www.csdn.com
System.out.println("不要被误导了");
}
}
输出结果：
mark的使用
不要被误导了
注意
这里编译器没有报错，因为看似http://www.csdn.com是一个网址；
其实是一个标号为http的语句//后面则是注释。
练习：
for(int x=1; x<=10; x++) {
if(x%3==0) {
//在此处填写代码
}
System.out.println(“Java基础班”);
}
我想在控制台输出2次:“Java基础班“
我想在控制台输出7次:“Java基础班“
我想在控制台输出13次:“Java基础班“
完整代码如下：
public class Text_1 {
public static void main(String[] args){
for(int x=1; x<=10; x++) {
if(x%3==0) {
//break; //在控制台输出2次:“Java基础班“
//continue; //在控制台输出7次:“Java基础班“
System.out.println("Java基础班");
}
System.out.println("Java基础班");
}
}
}
return的作用
- 返回
- 其实它的作用不是结束循环的，而是结束方法的。
return和break以及continue的区别?
- return是结束方法
- break是跳出循环
- continue是终止本次循环继续下次循环
2347
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
