第三章·程序流程控制
分类
- 顺序结构：程序按照代码的顺序执行,即从上到下依次执行
- 选择结构（分支结构）:if-else，switch
- 循环结构（迭代结构）：while,do-while,for
- 转跳结构（转移语句）:break,continue,return
分支结构（结果只能是boolean类型）
if语句
如果判断条件为真，则会执行语句块，否则，结束当前分支结构
语法
if(条件)｛
语句块；
｝
例子
public static void main(String[] args) {
//诉求：判断当前分数是否高于95分，如果高于，则输出真不错，奖励一个苹果13
/* if(条件){
语句块；
}*/
int score=95;
if ( score>95 ){
System.out.println("真不错，奖励一个苹果13");
}
System.out.println("这是if之后的代码");
if-else语句
如果条件为真(true),则执行if{}中语句块，如果条件为假（false）,则执行else{}中语句块（注意：if {}和else{}中的代码只会执行其中一个，不可能同时执行两个！）
语法
if(条件){
语句块1；
}else{
语句块2；
}
例子
public static void main(String[] args) {
// 诉求：从控制台输入一个分数(整数），判断是否高于95分，如果高于，则输出“真不错，奖励一个苹果13”，否则，输出“奖励一个你最爱的大嘴巴子”
Scanner sc=new Scanner(System.in);
int score=sc.nextInt();
if(score>95){
System.out.println("真不错，奖励苹果13");
}else{
System.out.println("奖励你最爱的大嘴巴子");
}
System.out.println("这是if-else之后的内容");
}
package day03.h02;
import java.util.Scanner;
public class 结构if_else {
public static void main(String[] args) {
/*语法：
if(条件){
语句块1
}else{
语句块2
}*/
int b;
Scanner l=new Scanner(System.in);
System.out.println("请输入你的金额：");
int a=l.nextInt();
if (a>=6000){
System.out.println("买个5000元电脑");
b=a-5000;
System.out.println("剩下："+b+"元");
}else {
System.out.println("不买了，存够了再买");
System.out.println("剩下"+a);
}
/*语法：
* if(条件){
* 语句块1}
* else if(条件){
* 语句块2}
* else{
* 语句块3}
*/
if(a>2000){
System.out.println("买个手机");
}else if (a<2000&&a>=1000){
System.out.println("买个电饭锅");
}else if (a<1000&&a>100){
System.out.println("简单吃个饭吧");
}
else {
System.out.println("早点回家，洗洗睡吧");
/*执行过程:
判断boolean的值:
若为true，则执行语句块1(整个结束)
若为false，则执行语句块2(整个结束)*/
}
}
}
if-else嵌套使用
语法
if(条件)｛
if（条件）｛
语句块1.1；
｝else{
语句块1.2；
}
｝else{
if（条件）｛
语句块2.1；
｝else{
语句块2.2；
}
}
例子
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//如果输入负数，则会提示错误信息， 将控制台输入操作也进行一个判断，如果输入的是负数，则提示输入错误，否则才会去判断是否成年
int age = scanner.nextInt();
if (age < 0) {
System.out.println("输入错误");
} else {
//判断是否成年
if (age >= 18) {
System.out.println("恭喜你，可以遭受社会毒打了");
} else {
System.out.println("未成年，再养你几年");
}
}
}
switch…case语句
一个switch语句有一个控制表达式和一个由case标记表述的语句块组成
语法
switch(条件块)｛
case v1:
语句块1；
break;
case v2:
语句块2；
break;
case v3:
语句块3；
break;
... ... (可以有很多个case)
default:
默认语句；
｝
代码
package day04;
//
public class switch_case {
public static void main(String[] args) {
int a=5;
switch(a){
case 1:
System.out.println("hhh");
break;
case 2:
System.out.println("lll");
break;
case 5:
System.out.println("ppp");
break;
default:
System.out.println("kkk");
}
}
}
switch分支结构条件构成
- switch（）中的语句块==case后面的值
- 如果条件为真，则执行当前case中的语句块
- 如果条件为假，则不执行当前语句块，进入到下一个case中
break
终止当前分支结构（一旦执行，那接下来所有case均不执行），如果没有break，当条件为真时则往后的每个case的语句块都会开始执行
default
默认语句（当所有case均不满足时执行）
switch中数据的类型
byte,short,int,char,String,枚举
迭代结构（循环结构）
循环三要素
- 循环变量的初始化
- 循环的条件(以循环变量为基础)
- 循环变量的改变
while循环语句
语法
while(条件)｛
语句块；
｝
例子
public static void main(String[] args) {
/*在控制台输出3行：“一会儿下课之后记得去吃个老坛，有条件的记得加根双汇火腿肠“*/
int count=0;
while (count<3) {
System.out.println("一会儿下课之后记得去吃个老坛，有条件的记得加根双汇火腿肠");
count++;
}
}
public static void main(String[] args) {
/*在控制台输出1+2+3+4+...+100的和（只要最后一个结果：5050）*/
/*循环变量： i (1.2.3...100这些数)
初始化：int i=1 完成
条件：i<=100 完成
改变：i++ 完成
*/
int i=1;
int sum=0;
while (i<=100){
sum=sum+i;//sum专门用来存放计算的和
i++;
}
System.out.println( sum );
}
package day04;
import java.util.Scanner;
//while三要素：初始变量，条件，变量变化规律
public class While循环 {
public static void main(String[] args) {
//输入5次"行动是成功的阶梯"
int a=0;//循环变量的初始化
while (a<5){//循环条件
System.out.println("行动是成功的阶梯");
a++;//循环变量的改变
}
/*循环变量：因数 （乘号前面的数） i
初始化： int i=1 完成
条件： i<=9 完成
改变： i++ 完成*/
int b=1;
while (b<=9){ System.out.println(b+"*9="+b*9);
b++;
}
/*执行过程：
* b=1
* true 输出 b=2
* ......
* ......
* true 输出 b=9
* false while循环结束
* 继续网下执行代码*/
int c=250;
Scanner c1=new Scanner(System.in);
System.out.println("一共300个数字，猜我手里有几个数：");
int c2= c1.nextInt();
while (c2!=c){
if(c2<c){
System.out.println("太小了");
System.out.println("请往大的猜一个数：");
}else if (c2>c){
System.out.println("太大了");
System.out.println("请往小的猜一个数：");
}
c2= c1.nextInt();
}
System.out.println("恭喜您猜对了！");
}
}
注意：
一旦进入while循环，首先会进行条件判断，如果条件为真（true）,则执行语句块，执行完之后再次返回条件，进行判断，直到条件为假（false）,则跳出当前循环。
do-while循环
先执行一次语句块，再进行条件判断，如果条件为真（true）,返回到do{}执行语句块，直到条件为假（false）,则跳出当前循环，代码会接着往下执行
语法
do｛
语句块；
｝while(条件);
代码
package day04;
import java.util.Scanner;
//先执行语句块，再进行条件判断
public class While_do {
public static void main(String[] args) {
Scanner a=new Scanner(System.in);
int b;
int c=500;
do {
System.out.println("请输入一个数：");
b=a.nextInt();
if (b<c){
System.out.println("太小了重新输入：");
b=a.nextInt();
}else if (b>c){
System.out.println("太大了重新输入：");
b=a.nextInt();
}
}while (b!=c);
System.out.println("恭喜你输入正确！");
}
}
while和do-while的区别
- while：先判断条件，后执行语句块，如果一开始的时候条件就为假的话，语句块不会执行
- do-while:先执行语句块，在进行条件判断，如果一开始的时候条件就为假的话，语句块会至少会执行一次
for循环
应用率最高，适合与次数相关的
语法
for(初始化;条件;改变){
语句块;
}
执行流程
for循环开始之后，首先进行的是初始化操作，然后进行条件判断，如果条件为真，则执行语句块，并且完成循环变量改变操作，然后再重新回到条件，再次进行判断，直到条件为假，跳出当前循环，代码会接着往下走。
例子
public static void main(String[] args) {/*从控制台输出3行“明天接着上我晚自习*/
// 诉求：从控制台输出3行“明天记得上晚自习” 完成
/*循环变量： 输出的行数 i
*初始化： int i=0 完成
* 条件： i<3 完成
* 改变： i++ 完成
* */
for (int i=0; i<3; i++) {
System.out.println("明天记得上晚自习");
}
}
public static void main(String[] args) {/*在控制台输出1+2+3+4....+200的结果*/
int sum=0;
for(int i=1;i<=200;i++){
sum=sum+i;
}System.out.println(sum);
}
public static void main(String[] args) {/*九九乘法表*/
for (int num=1;num<=9;num++){
for(int i=1;i<=num;i++){
System.out.print(i+ "*"+ num +"=" + i*num +"\t");
}
System.out.println();
}
}
package day04;
//for结构的演示
public class for循环 {
public static void main(String[] args) {
//for中的循环变量num的作用域，仅在当前for中--------特殊记忆
for(int num=1;num<=9;num++){ //1到9
System.out.println(num+"*9="+num*9);
}
//System.out.println(num); //编译错误，超出num作用域了
for(int num=1;num<=9;num+=2){ //1/3/5/7/9
System.out.println(num+"*9="+num*9);
}
for(int num=9;num>=1;num--){ //9到1的
System.out.println(num+"*9="+num*9);
}
for(int times=0;times<5;times++){
System.out.println("行动是成功的阶梯");
}
System.out.println("继续执行...");
/*
执行过程:-----------带数
times=0 true 输出
times=1 true 输出
times=2 true 输出
times=3 true 输出
times=4 true 输出
times=5 false for循环结束
输出继续执行...
*/
}
}
/*
补充:
1.变量的作用域/范围:
从变量的声明开始，到包含它最近的大括号结束
2.变量的重名问题:
作用域重叠时，变量不能同名
*/
三种循环结构的选择
- 先看循环是否与次数有关：
- 若有关--------------------------------------直接上for
- 若无关，再看第1要素与第3要素的代码是否相同：
- 若相同--------------------------------直接上do…while
- 若不同--------------------------------直接上while
转移语句
作用
主要用于控制整个代码的执行走向
分类
return：return之后的代码均不执行，结束当前程序
break：跳出当前循环/分支结构，代码会接着往下走
continue:跳出本次循环，会接着执行下一次循环
扫一扫
3609
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
