文章目录
流程控制语句
- 什么是流程控制语句
在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。
也就是说程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。
而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能 - 流程控制语句的分类
顺序结构
选择结构
循环结构
顺序结构语句
- 顺序结构
是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
总的来说：写在前面的先执行，写在后面的后执行 - 执行流程：
从上往下，依次执行。
选择结构语句
- 概述：也被称为分支结构。
选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，
逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。 - 选择结构的分类
if语句
switch语句
选择结构if语句
- if语句有几种格式
格式1
格式2
格式3
if语句的格式1
if(比较表达式或者是boolean类型的值) {
语句体;
}
- 执行流程：
先计算比较表达式的值，看其返回值是true还是false。
如果是true，就执行语句体；
如果是false，就不执行语句体； - 比较表达式无论简单还是复杂，结果必须是boolean类型
if语句控制的语句体如果是一条语句，大括号可以省略；如果是多条语句，就不能省略。建议永远不要省略。
一般来说：有左大括号就没有分号，有分号就没有左大括号
package org.westos.demo;
public class IFDemo {
public static void main(String[] args) {
//选择语句
// if(结果为布尔类型的表达式，或者是布尔类的值){ 要执行的语句体}
System.out.println("第一行代码执行");
System.out.println("第二行代码执行");
int a=3;
int b=4;
if(a<b){ //(表达式)括号里面的结果是false {}大括号里面的代码就不执行
System.out.println("这条语句执行了");
}
System.out.println("下面的代码继续执行");
System.out.println("下面的代码继续执行");
}
}
if语句的格式2
if(比较表达式) {
语句体1;
}else {
语句体2;
}
- 注意事项：else后面是没有比较表达式的，只有if后面有。
- 执行流程：
首先计算比较表达式的值，看其返回值是true还是false。
如果是true，就执行语句体1；
如果是false，就执行语句体2；
/* 案例演示:
获取三个数据中的最大值
*/
package org.westos.demo;
import java.util.Scanner;
public class MyDemo {
public static void main(String[] args) {
//scanner 对象名
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个整数");
int num1 = scanner.nextInt();
System.out.println("请输入第二个整数");
int num2 = scanner.nextInt();
System.out.println("请输入第三个整数");
int num3 = scanner.nextInt();
//使用if else 求出三个数的最大值
int max = 0;
if (num1 > num2) {
max = num1;
} else {
max = num2;
}
int max1 = 0;
if (num3 > max) {
max1 = num3;
} else {
max1 = max;
}
System.out.println("最大值是" + max1);
}
/* 案例演示:
获取三个数据中的最大值
*/
package org.westos.demo;
import java.util.Scanner;
public class MyDemo {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个整数");
int num1 = scanner.nextInt();
System.out.println("请输入第二个整数");
int num2 = scanner.nextInt();
System.out.println("请输入第三个整数");
int num3 = scanner.nextInt();
int max=num1;
if(max<num2){
max=num2;
}
if(max<num3){
max=num3;
}
System.out.println("最大值是："+max);
}
}
- if语句的格式2和三元的相互转换问题
三元运算符（(关系表达式) ？ 表达式1 ： 表达式2 ）实现的，都可以采用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。
-
注意事项： 当只要有一个条件满足时，if语句结束。else是可以省略，但是不建议省略。
/* 案例演示:
获取三个数据中的最大值
*/
package org.westos.demo;
import java.util.Scanner;
public class MyDemo {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个整数");
int num1 = scanner.nextInt();
System.out.println("请输入第二个整数");
int num2 = scanner.nextInt();
System.out.println("请输入第三个整数");
int num3 = scanner.nextInt();
int max;
if(num1>num2&&num1>num3){
max=num1;
}else if(num2>num1&&num2>num3){
max = num2;
}else{
max=num3;
}
System.out.println("最大值是"+max);
}
}
/* 案例演示:
需求：键盘录入一个成绩，判断并输出成绩的等级。
90-100 优秀
80-89 良
70-79 中
60-69 及格
0-59 差
*/
package org.westos.demo;
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
//多重条件选择
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的成绩 百分制");
double socre = scanner.nextDouble();
//对成绩进行范围的判断
if (socre < 60 && socre >= 0) {
System.out.println("成绩不及格");
} else if (socre >= 60 && socre < 75) {
System.out.println("差");
} else if (socre >= 75 && socre < 85) {
System.out.println("中");
} else if (socre >= 85 && socre < 95) {
System.out.println("良好");
} else if (socre >= 95 && socre < 100) {
System.out.println("优秀");
} else if (socre == 100) {
System.out.println("满分");
} else {
System.out.println("成绩不合法");
}
}
}
/* 案例演示:
需求：键盘录入x的值，计算出y的并输出。
x>=3， y = 2x + 1;
-1<=x<3，y = 2x;
x<-1， y = 2x – 1;
*/
package org.westos.demo;
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int x = sc.nextInt();
double y = 0.0;
if (x >= 3) {
y = 2 * x + 1;
} else if (-1 <= x && x < 3) {
y = 2 * x;
} else if (x < -1) {
y = 2 * x-1;
}
System.out.println("y的值是"+y);
}
}
- 选择结构if语句的嵌套使用
if语句的嵌套使用。
可以三元实现，也可以if嵌套实现。
//需求：获取三个数据中的最大值
package org.westos.demo;
import java.util.Scanner;
public class MyDemo {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个整数");
int num1 = scanner.nextInt();
System.out.println("请输入第二个整数");
int num2 = scanner.nextInt();
System.out.println("请输入第三个整数");
int num3 = scanner.nextInt();
// if 语句的嵌套
int max;
if(num1>num2){
if(num1>num3){
max=num1;
}else{
max=num3;
}
}else{
if(num2>num3){
max=num2;
}else{
max=num3;
}
}
System.out.println("最大值是："+max);
}
}
选择结构switch语句
switch(表达式){
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
case 值3:
语句体3;
break;
....
default：
语句体n+1;
break;
}
- switch语句的格式解释
(1):switch表示这是switch语句
表达式的取值：byte,short,int,char
JDK5以后可以是枚举(什么是枚举，以后再讲)
JDK7以后可以是String
(2):case后面跟的是要和表达式进行比较的值
(3):语句体部分可以是一条或多条语句
(4):break表示中断，结束的意思，可以结束switch语句
(5):default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似 - 面试题
byte可以作为switch的表达式吗? 可以
long可以作为switch的表达式吗? 不可以
String可以作为switch的表达式吗? JDK1.7后可以 - 执行流程
先计算表达式的值
然后和case后面的匹配，如果匹配成功就执行对应的语句，遇到break就会结束,否则执行default控制的语句 - 选择结构switch语句的注意事项
a:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
b:default可以省略吗?
可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
c:break可以省略吗?
可以省略，但是结果可能不是我们想要的。
会出现一个现象：case穿透。
最终我们建议不要省略
d:default一定要在最后吗?
不是，可以在任意位置。但是建议在最后。
e:switch语句的结束条件
a:遇到break就结束了
b:执行到末尾就结束了
package org.westos.demo;
public class SwitchDemo {
public static void main(String[] args) {
//switch 语句的语法注意事项
//switch (num) 小括号里面都支持哪些数据类型：
// byte short int char //例如long num的long类型就不支持的
//JDK1.5之后支持枚举类型
//JDK1.7之后支持字符串类型 ""
//case 的值只能是常量
//多个case项的数据类型要一致
//break 结束: switch 语句 可以不要，不要会发生一种现象，这种现象叫做case穿透
//default:项 可以写，也可以不要 位置前后没有关系
short num = 10;
switch (num) {
case 10:
System.out.println("10这个项匹配上了");
break;
case 20:
System.out.println("20这个项匹配上了");
break;
case 30:
System.out.println("30这个项匹配上了");
break;
case 40:
System.out.println("40这个项匹配上了");
break;
case 50:
System.out.println("50这个项匹配上了");
break;
case 100:
System.out.println("100这个项匹配上了");
break;
default:
System.out.println("当所有的case项都没有匹配上时，就会执行默认项");
break;
}
System.out.println("下面的程序继续执行");
}
}
- 选择结构switch语句练习
看程序写结果：
package org.westos.demo;
public class SwitchDemo {
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
*/
int x = 2;
int y = 3;
switch (x) {
default:
y++;//没有break穿透 所以y++执行三次
case 3:
y++;
case 4:
y++;
}
System.out.println("y=" + y); //y=6
}
}
选择结构if语句和switch语句的区别
/* 案例演示
分别用switch语句和if语句实现下列需求：
键盘录入月份，输出对应的季节
*/
package org.westos.demo;
import java.util.Scanner;
public class SwitchDemo {
public static void main(String[] args) {
// 3 4 5 春节 6 7 8 夏季 9 10 11 秋季 12 1 2 冬季
Scanner scanner = new Scanner(System.in);
System.out.println("请输入月份");
int month = scanner.nextInt();
/* if(month>=3&&month<=5){
System.out.println("春季");
}else if(month==7||month==8||month==6){
System.out.println("夏季");
}else if(month>=9&&month<=11){
System.out.println("秋季");
}else if(month==1 || month == 12||month==2){
System.out.println("冬季");
}else{
System.out.println("输入不合法");
}
*/
switch (month) {
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 1:
case 2:
case 12:
System.out.println("冬季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
default:
System.out.println("输入不合法");
break;
}
// if 和 switch 语句的区别
//switch 一般用于对某些个常量进行选择
//if 不但可以对常量进行选择，也可以对范围进行选择
}
}
- 在做判断的时候，我们有两种选择，if语句和switch语句，那么，我们到底该如何选择使用那种语句呢?
if语句使用场景：针对结果是boolean类型的判断;针对一个范围的判断; 针对几个常量值的判断.
switch语句使用场景：针对几个常量值的判断.
循环结构语句
- 什么是循环结构
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，
需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环 - 循环结构的分类
for循环
while循环
for循环
for(初始化表达式语句;判断条件语句;控制条件语句) {
循环体语句;
}
- 执行流程：
a:执行初始化表达式语句
b:执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
c:执行循环体语句;
d:执行控制条件语句
e:回到B继续。 - 注意事项:
初始化表达式语句只执行一次
package org.westos.demo;
public class ForDemo {
public static void main(String[] args) {
//输出十行 helloworld
//对应重复的代码，我们应该使用循环来改进
//for 循环
// int i=0 循环的初始值 从0开始循环
// i<10 循环的条件 为true 时 循环继续，为false 时循环结束
// i++ 控制循环的语句 没循环一次 i自增一下
//语句的执行流程
/*
* 1. 执行 int i=0 给i赋值初始值 ，此语句只执行一次
* 2. 判断 i<10 如果为true 执行{} 里面的循环体
* 3. 执行 i++
* 然后返回2 继续执行 直到 i<10 为false时循环终止
*/
for(int i=0;i<10;i++){
System.out.println("helloworld");// 循环体
}
}
}
循环结构for语句的练习之获取数据
/* 案例演示
需求：请在控制台输出数据1-10
需求：请在控制台输出数据10-1
*/
package org.westos.demo;
public class ForDemo {
public static void main(String[] args) {
// 需求：请控制台输出数据1 - 10
for(int i=1;i<=10;i++) {
System.out.println(i);
}
System.out.println("------------------------------------");
// 需求：请在控制台输出数据10 - 1
for(int i=10;i>=1;i--){
System.out.println(i);
}
}
}
- 注意事项
判断条件语句无论简单还是复杂结果是boolean类型。
循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
一般来说：有左大括号就没有分号，有分号就没有左大括号
循环结构for语句的练习之求和思想
//案例演示: 需求：求出1-10之间数据之和
package org.westos.demo;
public class ForDemo {
public static void main(String[] args) {
/* A:
案例演示:
需求：求出1 - 10 之间数据之和*/
// int sum=1+2+3+4+5+6+7+8+9+10;
//定义一个变量。来接收结果
int sum = 0;
for (int i = 1; i <= 10; i++) {
sum = sum + i; //sum+=i;
}
System.out.println("和是" + sum);
}
}
/* 案例演示:
需求：求出1-100之间偶数和
需求：求出1-100之间奇数和
*/
package org.westos.demo;
public class ForDemo {
public static void main(String[] args) {
// 需求：求出1 - 100 之间偶数和
// 需求：求出1 - 100 之间奇数和
int ou=0;
int ji=0;
for(int i=1;i<=100;i++){
if(i%2==0){
ou+=i;
}else{
ji+=i;
}
}
System.out.println("奇数和是"+ji);
System.out.println("偶数和是" + ou);
}
}
循环结构for语句的练习之水仙花及统计思想
/* 案例演示
需求：在控制台输出所有的”水仙花数”
所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
举例：153就是一个水仙花数。
153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
*/
// 需求：统计”水仙花数”共有多少个
package org.westos.demo;
public class ForDemo {
public static void main(String[] args) {
//分析：1.确定循环的范围 100----999
// 2. 100 你要获取这个数的每一个位上的数字
// 获取到每个位上的数字 后，然后把每个位上数字的立方 相加 看等不等于这个数，如果相等就是水仙花数
/* int num=153;
//取个位上的3
int ge= num/1%10;
int shi=num/10%10;
int bai=num/100%10;
System.out.println(ge);
System.out.println(shi);
System.out.println(bai);*/
// 定义一个统计变量
int count=0;
for (int i = 100; i <= 999; i++) {
int ge = i / 1 % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10;
int flowerNumber=ge*ge*ge+shi*shi*shi+bai*bai*bai;
if(flowerNumber==i){
System.out.println("水仙花数是: "+i);
count++;
}
}
System.out.println("水仙花数有"+count+"个");
}
}
while循环
while语句
while(判断条件语句) {
循环体语句;
}
//完整格式
初始化条件语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
- 执行流程：
a:执行初始化条件语句;
b:执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
c:执行循环体语句;
d:执行控制条件语句
e:回到b继续。
/* 案例演示
需求：在控制台输出10次"helloworld"
需求：请在控制台输出数据1-10
*/
package org.westos.demo;
public class WhileDemo {
public static void main(String[] args) {
int i=1; //循环的初始值
while (i<=10){ //条件为true 循环继续，为false 循环结束
System.out.println("helloworld");
i++; //控制循环的语句不要忘了
}
System.out.println("----------------------------");
int j=1;
while (j<=10){
System.out.println(j);
j++;
}
}
}
/* 循环结构while语句的练习
统计思想: 统计”水仙花数”共有多少个
*/
package org.westos.demo;
public class WhileDemo {
public static void main(String[] args) {
int h=100;
int count = 0;
while (h<1000){
int ge = h / 1 % 10;
int shi = h / 10 % 10;
int bai = h / 100 % 10;
int flowerNumber = ge * ge * ge + shi * shi * shi + bai * bai * bai;
if (flowerNumber == h) {
System.out.println("水仙花数是: " + h);
count++;
}
h++;
}
System.out.println("水仙花数有" + count + "个");
}
}
do…while语句
do {
循环体语句;
}while(判断条件语句);
//完整格式
初始化条件语句;
do {
循环体语句;
控制条件语句;
}while(判断条件语句);
- 执行流程：
a:执行初始化条件语句;
b:执行循环体语句;
c:执行控制条件语句;
d:执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
e:回到b继续。
package org.westos.demo;
public class WhileDemo {
public static void main(String[] args) {
//先执行do里面的代码一次，后去判断循环条件是否成立，如果成立，继续循环，不成立循环终止
int i=1;
do{
System.out.println("先执行一次");
i++;
}while (i<=10);
}
}
其他
循环结构三种循环语句的区别
- do…while循环至少执行一次循环体。
而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。 - :如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用for循环。
因为变量及早的从内存中消失，可以提高内存的使用效率。
建议优先考虑for循环，然后是while循环 ，最后是do…while循环
// for while do while
//如果你知道了循环次数，一般选用 for循环
//如果你不知道要循环多少次一般选用while循环 但是你要知道循环的结束条件
//do while先执行一次，后判断条件
循环结构注意事项之死循环
- 一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
- 两种最简单的死循环格式
while ( true ){…}
for (；；){…}
package org.westos.demo;
public class ForDemo {
public static void main(String[] args) {
//死循环 //无法结束的循环
/* for(;;){ //for的死循环
System.out.println("死循环");
int i=0; //会报错 是一行废代码 前面是死循环 不会执行这行代码
}
*/
int i = 1;
while (true) { //while的死循环 //while (true)这个条件永远是true就一直执行 死循环
System.out.println(i);
i++;
if (i > 10) {
break; //加个条件 把while的死循环终止掉
}
}
}
}
循环结构循环嵌套输出4行5列的星星
- 案例演示
需求：请输出一个4行5列的星星(*)图案。
如图：
*****
*****
*****
*****
注意：
System.out.println(" “);和System.out.print(” ");的区别
System.out.print输出结果不换行;System.out.println 输出结果换行
package org.westos.demo;
public class ForDemo {
public static void main(String[] args) {
/*
for (int i = 0; i < 4; i++) {
System.out.println("*****");
}
*/
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 5; j++) {
System.out.print("*"); //print打印不换行 //println打印并换行
}
System.out.println(); //()里面什么都不输出 //这行语句仅仅只输出一个换行符
}
//另一种换行方法 在里面加一个for循环
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 5; j++) {
System.out.print("*"); //print打印不换行 //println打印并换行
if(j==4){ // 换行方法
System.out.println();
}
}
}
}
}
// 结论：外循环控制行数，内循环控制列数
循环结构循环嵌套输出正三角形
案例演示
需求：请输出下列的形状
*
**
***
****
*****
package org.westos.demo;
public class ForDemo {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
System.out.println(); //仅仅只输出一个换行符
}
}
}
- 代码优化
注意：
‘\x’ x表示任意，这种做法叫转义字符。
‘\t’ tab键的位置
‘\n’ 换行
//转义字符
System.out.print("aaaaaaaaaaaaaaa\n"); // \n 换行符
System.out.print("bbbb\tbbbbbbbbbbbbbb"); // \t 空一个table
循环结构九九乘法表
- 案例演示
需求：在控制台输出九九乘法表。
package org.westos.demo;
public class ForDemo {
public static void main(String[] args) {
// (把前面学的 输出三角形星星 代码中 System.out.print("*")中的 * 换成 表达式)
/*
* 1*1=1
* 1*2=2 2*2=4
* 1*3=3 2*3=6 3*3=9
* 1*4=4 2*4=8 3*4=12 4*4=16
* */
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <=i; j++) { //每循环一次增加一列 所以j <=i
System.out.print(j+"*"+i+"="+(j*i)+"\t\t"); // j*i每一行的i不变 内循环j自加
}
System.out.println();
}
}
}
321
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
