Java基础语法-第五节-流程控制
作者：互联网
程序控制结构
- 定义：程序控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑块
- 其流程控制方式采用结构化程序设计中的三种基本流程结构，即
- 顺序结构：程序从上到下逐行执行，中间没有任何判断和跳转
- 分支结构：
- 根据条件，选择性的执行某段代码
- 有if...else和switch-case两种分支语句
- 循环结构
- 根据循环条件，重复性的执行某段代码
- 有while,do....while,for三种循环语句
- 注：JDK1.5提供了foreach循环，方便的遍历集合，数组元素
顺序结构
- Java中定义成员变量时采用合法的前向引用。如：
public class Test{
int num1 = 12;
int num2 = num1 + 2;
}
错误形式：
public class Test{
int num2 = num1 + 2；
int num1 = 12;
}
分支结构
if-else结构
//举例1
int heartBeats=79;
if(heartBeats <60||heartBeats>100){
System.out.println("你需要做进一步检查");
}
System.out.println("检查结束");
//举例2
int age = 23;
if(age<18){
System.out.println("你还可以看动画片");
}else{
System.out.println("你可以看电影了");
}
//举例3
if(age<0){
System.out.println("你输入的数据非法");
}else if(age<18){
System.out.println("青少年时期");
}else if(age<35){
System.out.println("青壮年时期");
}else if(age<60){
System.out.println("中年时期");
}else if(age<120){
System.out.println("老年时期");
}else {
System.out.println("你已经成仙了");
}
- 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
- 语句块只有一条执行语句时，一对{}可以省略，但建议保留
- if-else语句结构，根据需要可以嵌套使用
- 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
- 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓
- 当多个条件是“包含”关系时，“小上大下 / 子上父下”
switch-case结构
- switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，
char，int，枚举 (jdk 5.0)，String (jdk 7.0)； - case子句中的值必须是常量，不能是变量名或不确定的表达式值；
- 同一个switch语句，所有case子句中的常量值互不相同；
- break语句用来在执行完一个case分支后使程序跳出switch语句块；如
果没有break，程序会顺序执行到switch结尾 - default子句是可任选的。同时，位置也是灵活的。当没有匹配的case时，
执行default
int number = 2;
switch(number){
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
case 3:
System.out.println("three");
break;
default:
System.out.println("other");
}
//**********编译错误的情况***********
//举例1：③的反例
boolean isHandsome = true;
switch(isHandsome){
case true:
System.out.println("true");
break;
case false:
System.out.println("false");
break;
default:
System.out.println("error");
}
//举例2：④的反例
int age = 10;
switch(age){
case age>18:
System.out.println("成年了");
break;
default:
System.out.println("未成年");
}
循环结构
- 循环结构:在某些条件满足的情况下，反复执行特定代码的功能
- 循环语句分类
- for 循环
- while 循环
- do-while 循环
- 循环语句的四个组成部分
- 初始化部分(init_statement)
- 循环条件部分(test_exp)
- 循环体部分(body_statement)
- 迭代部分(alter_statement)
for 循环
-
语法格式
for (①初始化部分; ②循环条件部分; ④迭代部分)｛ ③循环体部分; ｝ -
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ...-②
-
说明
-
循环条件部分为boolean类型表达式，当值为false时，退出循环
-
初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
-
迭代部分可以有多个变量更新，用逗号分隔
for(int i = 1;i <= 5;i++){
System.out.println("Hello World!");
}
//练习
int num = 1;
for(System.out.print("a");num<=3;System.out.print("c"),num++){
System.out.print("b");
}
//输出abcbcbc
//例题：遍历100以内的偶数，输出所有偶数的和和偶数的个数
int sum = 0;//记录所有偶数的和
int count = 0;//记录偶数的个数
for(int i = 1;i <= 100;i++){
if(i%2==0){
System.out.println(i);
sum += i;
count++;
}
}
System.out.println("所有偶数的和："+sum);
System.out.println("偶数的个数："+count);
while循环
- 语法格式
①初始化部分
while(②循环条件部分)｛
③循环体部分;
④迭代部分;
}
- 执行过程：①-②-③-④-②-③-④-②-③-④-...-②
- 说明：
- 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
- for循环和while循环可以相互转换
//遍历100以内的偶数
int i = 1;
while(i <= 100){
if(i % 2 == 0){
System.out.println(i);
}
i++;
}
//出了while循环以后，仍可以调用
System.out.println(i);//101
do-while 循环
- 语法格式
①初始化部分;
do{
③循环体部分
④迭代部分
}while(②循环条件部分);
- 执行过程：①-③-④-②-③-④-②-③-④-...②
- 说明：
- do-while循环至少执行一次循环体
//遍历100以内的偶数,并计算所有偶数的和即偶数的个数
int sum = 0;//记录所有偶数的和
int count = 0;//记录偶数的个数
int num = 1;
do{
if(num%2==0){
System.out.println(num);
sum += num;
count++;
}
num++;
}while(num <= 100);
System.out.println("所有偶数的和："+sum);
System.out.println("偶数的个数："+count);
嵌套循环
- 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环或内层循环。
- 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
- 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。
//打印******
//System.out.println("******");
for(int i = 1;i <= 6;i++){
System.out.print('*');//也可以写成"*"
}
System.out.println();
/*
打印******
******
******
******
******
*/
for(int i = 1;i <= 5;i++){
for(int j = 1;j <= 6;j++){
System.out.print('*');
}
System.out.println();
}
/* i(行号) j(*的个数)
打印* 1 1
** 2 2
*** 3 3
**** 4 4
***** 5 5
*/
for(int i = 1;i <= 5;i++){ //控制行数
for(int j = 1;j <= i;j++){ //控制列数
System.out.print('*');
}
System.out.println();
}
/* i(行号) j(*的个数) 规律：i + j = 5 换句话说：j = 5 - i
打印***** 5 5
**** 4 4
*** 3 3
** 2 2
* 1 1
*/
for(int i = 1;i <= 5;i++){ //控制行数
for(int j = 0;j <= 5-i;j++){ //控制列数
System.out.print('*');
}
System.out.println();
}
//输出100000以内的质数
boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
//获取当前时间距1970-01-01 00:00:00 的毫秒数
long start = System.currentTimeMillis();
for(int i = 2;i <= 100000;i++){
for(int j = 2;j <= Math.sqrt(i);j++){//优化二：对本身质数的自然数是有效的
if(i % j == 0){
isFlag = false;
break;//优化1：只对本身非质数的自然数是有效的
}
}
if(isFlag){
System.out.println(i);
}
//重置isFlag
isFlag = true;
}
//获取当前时间距1970-01-01 00:00:00 的毫秒数
long end = System.currentTimeMillis();
//输出运算的时间
System.out.println(end-start);
/*
优化前：15232
优化1后: 1965
优化1和2后: 660
*/
特殊关键字的使用：break、continue
-
break语句
- break语句用于终止某个语句块的执行
{ …… break; …… }- break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
label1: { …… label2: { …… label3: { …… break label2; …… } } } -
continue 语句
- continue只能使用在循环结构中
- continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
- continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
- continue语句用法举例
for (int i = 0; i < 100; i++) { if (i%10==0) continue; System.out.println(i); }
label:for(int i = 0;i <= 4;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
//break;//默认跳出包裹此关键字最近的一层循环
//continue;
//break label;//结束指定标识的一层循环结构
continue label;//结束指定标识的一层循环结构当此循环
}
System.out.print(j);
}
}
附加：特殊流程控制语句3
Scanner输入
-
从键盘或控制台获取输入的变量
-
具体实现步骤
-
导包：import java.util.Scanner
-
Scanner的实例化：Scanner scan = new Scanner(System.in);
-
调用Scanner类的相关方法(next()/nextXxx())，来获取指定类型的变量
- 注意：需要根据相应的方法来输入指定类型的数据。如果输入的数据类型跟要求的类型不匹配时会报异常：InputMismatchException 导致程序终止
-
import java.util.Scanner;
class Test{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入你的姓名：");
String name = scan.next();
System.out.println(name);
System.out.println("请输入你的芳龄：");
int age = scan.nextInt();
System.out.println(age);
System.out.println("请输入你的体重：");
double weight = scan.nextDouble();
System.out.println(weight);
System.out.println("你是否相中了我呢？(true/false)");
boolean isLove = scan.nextBoolean();
System.out.println(isLove);
//对于char类型的获取，Scanner没有提供相关的方法。只能获取一个字符串
System.out.println("请输入你的性别：(男/女)");
String gender = scan.next();//"男”
char genderChar = gender.charAt(0);//获取字符串索引为0位置上的字符
System.out.println(genderChar);
}
}
总结
*一，分支结构中的if-else（条件判断结构）
* 三种形式
* 第一种：
* if(条件表达式){
* }
* 第二种：二选一
* if(条件表达式){
* 执行语句1
* }else{
* 执行语句2
* }
* 第三种：多选一
* if(条件表达式1){
* 执行语句1
* }else if(条件表达式2){
* 执行语句2
* }else if(条件表达式3){
* 执行语句3
* }else if(条件表达式3){
* 执行语句3
* }.....else{
* 执行语句n
* }
*
*二，分支结构中的switch-case
* 1.格式
* switch(表达式){
* case 常量1：
* 执行语句1；
* //break;
* case 常量2：
* 执行语句2；
* //break;
* ...
* default：
* 执行语句n；
* //break;
* }
* 2.说明
* ①根据switch表达式中的值，依次匹配各个case中的常量。
* 一旦匹配成功，则进入相应的case结构中。调用其执行语句。
* 当调用完执行语句后，则仍然继续向下执行其他case结构中的执行语句，
* 直到遇到break关键字或此switch-case结构末尾为止结束
* ②break关键字可以使用在switch-case中，表示一但执行到此关键字，
* 就跳出switch-case结构
* ③switch-case结构中的表达式，只能是如下的6种数据类型之一：
* byte,short,char,int,枚举类型(JDK5.0新增)，String类型(JDK7.0新增)
* ④case之后只能声明常量，不能声明范围
* ⑤break关键字是可选的
* ⑥default:相当于if-else的else.也是可选的。而且位置是灵活的
* ⑦凡是可以使用switch-case的结构，都可以转换成if-else.反之不成立
* ⑧我们在写分支语句时，当发现既可以使用switch-case的结构(同时，
* switch中表达式的取值情况不太多)，又可以使用if-else时，我们会优先使用switch-case。
* 原因：switch-case的执行效率比if-else稍高
*三，循环结构
* 循环语句的四个要素
* ①初始化部分
* ②循环条件部分 -->是boolean类型
* ③循环体部分
* ④迭代部分
* 1:for循环结构
* for(①;②;④){
* ③
* }
* 执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ...-②
* break:在循环中，一旦遇到break,则跳出循环
* 2:while循环结构
* ①
* while(②){
* ③;
* ④;
* }
* 执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ...-②
* 注意：
* 1.写while循环时千万不要丢了迭代条件。一旦丢了，就可能导致死循环！
* 2.我们写程序，要避免死循环
* 3.for循环和while循环是可以相互转换的！
* 区别：for循环和while循环的初始化条件的作用范围不同
*
* 算法：局限性
* 3:do-while循环结构
* ①
* do{
* ③;
* ④;
* }while(②);
* 执行过程：① - ③ - ④ - ② - ③ - ④ - ...-②
* 说明：
* 1.do-while循环至少会执行一次循环
* 2.开发中，使用for和while会更多一些，较少使用do-while
* 补充：
* 1.不在循环条件部分限制次数的结构：for(;;)或while(true)
* 2.结束循环有几种方式？
* 方式一：循环条件部分返回false
* 方式二：在循环体中，执行break;
*四，嵌套循环
* 1.嵌套循环：将一个循环结构A声明在另一个循环结构B中，就构成了嵌套循环
* 2.外层循环：循环结构A
* 内层循环：循环结构B
* 3.说明：
* ①内层循环结构遍历一遍，只是相当于外层循环循环体执行了一次
* ②假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体共执行了m * n次
* 4.技巧：外层循环控制行数，内层循环控制列数
*五，break和continue关键字的使用
* 使用范围 循环中使用的作用(不同点) 相同点
*break switch-case 结束当前循环 关键字后面不能声明执行语句
* 循环结构中
*
*continue 循环结构中 结束当次循环 关键字后面不能声明执行语句
*
*
*如何从键盘获取不同类型的变量：需要使用Scanner类
*具体实现步骤：
* 1.导包：import java.util.Scanner
* 2.Scanner的实例化：Scanner scan = new Scanner(System.in);
* 3.调用Scanner类的相关方法(next()/nextXxx())，来获取指定类型的变量
* 注意：
* 需要根据相应的方法来输入指定类型的数据。如果输入的数据类型跟要求的类型不匹配时
* 会报异常：InputMismatchException 导致程序终止
*
*
//练习：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序
Scanner scan = new Scanner(System.in);
int positiveNumber = 0;//记录正数的个数
int negativeNumber = 0;//记录负数的个数
while(true){
int number = scan.nextInt();
//判断number的正负情况
if(number > 0){
positiveNumber++;
}else if(number < 0){
negativeNumber++;
}else{
//一旦执行break,跳出循环
break;
}
}
System.out.println("输入的正数的个数为："+positiveNumber);
System.out.println("输入的负数的个数为："+negativeNumber);
标签：语句,case,Java,System,语法,第五节,循环,break,println 来源： https://www.cnblogs.com/mzchuan/p/13885832.html