b代码构成8-控制语句
原创
控制语句
(1) 逻辑结构
顺序结构选择结构循环结构
(2)语句块
语句块(有时叫做复合语句)，是用花括号扩起的任意数量的简单Java语句。块确定了局部变量的作用域。块中的程序代码，作为一个整体，是要被一起执行的。块可以被嵌套在另一个块中，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量，而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块。
示例：
public class Test19 {
public static void main(String[] args) {
int n;
int a;
{
int k;
int n; //编译错误：不能重复定义变量n
} //变量k的作用域到此为止
}
}(3) 选择语句
a. if单选择结构
语法结构：
if(布尔表达式){
语句块
}流程图：
<center>图8-3-1</center>
示例：
public class Test1 {
public static void main(String[] args) {
//通过掷三个骰子看看今天的手气如何？
int i = (int)(6 * Math.random()) + 1;//通过Math.random()产生随机数
int j = (int)(6 * Math.random()) + 1;
int k = (int)(6 * Math.random()) + 1;
int count = i + j + k;
//如果三个骰子之和大于15，则手气不错
if(count > 15) {
System.out.println("今天手气不错");
}
//如果三个骰子之和在10到15之间，则手气一般
if(count >= 10 && count <= 15) { //错误写法：10<=count<=15
System.out.println("今天手气很一般");
}
//如果三个骰子之和小于10，则手气不怎么样
if(count < 10) {
System.out.println("今天手气不怎么样");
}
System.out.println("得了" + count + "分");
}
}- 如果if语句不写{}，则只能作用于后面的第一条语句。
- 强烈建议，任何时候都写上{}，即使里面只有一句话！
- java.lang包中的Math类提供了一些用于数学计算的方法。
- Math.random()该方法用于产生一个0到1区间的double类型的随机数，但是不包括1。 ? int i = (int) (6 * Math.random()); //产生：[0，5]之间的随机整数
b. if-else双选择结构
语法结构：
if(布尔表达式){
语句块1
}else{
语句块2
}流程图：
<center>图8-3-2</center>
示例1：
public class Test2 {
public static void main(String[] args) {
//随机产生一个[0.0, 4.0)区间的半径，并根据半径求圆的面积和周长
double r = 4 * Math.random();
//Math.pow(r, 2)求半径r的平方
double area = Math.PI * Math.pow(r, 2);
double circle = 2 * Math.PI * r;
System.out.println("半径为： " + r);
System.out.println("面积为： " + area);
System.out.println("周长为： " + circle);
//如果面积>=周长，则输出"面积大于等于周长"，否则，输出周长大于面积
if(area >= circle) {
System.out.println("面积大于等于周长");
} else {
System.out.println("周长大于面积");
}
}
}示例2：
public class Test3 {
public static void main(String[] args) {
int a=2;
int b=3;
if (a<b) {
System.out.println(a);
} else {
System.out.println(b);
}
}
}示例3：
public class Test4 {
public static void main(String[] args) {
int a=2;
int b=3;
System.out.println((a<b)?a:b);
}
}c. if-else if-else多选择结构
语法结构：
if(布尔表达式1) {
语句块1;
} else if(布尔表达式2) {
语句块2;
}……
else if(布尔表达式n){
语句块n;
} else {
语句块n+1;
}当布尔表达式1为真时，执行语句块1;否则，判断布尔表达式2，当布尔表达式2为真时，执行语句块2;否则，继续判断布尔表达式3······;如果1~n个布尔表达式均判定为假时，则执行语句块n+1，也就是else部分。流程图如图8-3-3所示：
<center>图8-3-3</center>
示例：
public class Test5 {
public static void main(String[] args) {
int age = (int) (100 * Math.random());
System.out.print("年龄是" + age + "， 属于");
if (age < 15) {
System.out.println("儿童， 喜欢玩！");
} else if (age < 25) {
System.out.println("青年， 要学习！");
} else if (age < 45) {
System.out.println("中年， 要工作！");
} else if (age < 65) {
System.out.println("中老年， 要补钙！");
} else if (age < 85) {
System.out.println("老年， 多运动！");
} else {
System.out.println("老寿星， 古来稀！");
}
}
}d. switch多选择结构
语法结构：
switch (表达式) {
case 值1:
语句序列1;
[break];
case 值2:
语句序列2;
[break];
… … … … …
[default:
默认语句;]
}- switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处或者是switch语句的末尾。如果表达式的值与任一case值不匹配，则进入default语句(如果存在default语句的情况)。
- 根据表达式值的不同可以执行许多不同的操作。switch语句中case标签在JDK1.5之前必须是整数(long类型除外)或者枚举，不能是字符串，在JDK1.7之后允许使用字符串(String)。
- 大家要注意，当布尔表达式是等值判断的情况，可以使用if-else if-else多选择结构或者switch结构，如果布尔表达式区间判断的情况，则只能使用if-else if-else多选择结构。
流程图：
<center>图8-3-4</center>
示例：
public class Test6 {
public static void main(String[] args) {
char c = 'a';
int rand = (int) (26 * Math.random());
char c2 = (char) (c + rand);
System.out.print(c2 + ": ");
switch (c2) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
System.out.println("元音");
break;
case 'y':
case 'w':
System.out.println("半元音");
break;
default:
System.out.println("辅音");
}
}
}(4) 循环语句
循环结构分两大类，一类是当型，一类是直到型。
- 当型：当布尔表达式条件为true时，反复执行某语句，当布尔表达式的值为false时才停止循环，比如：while与for循环。
- 直到型：先执行某语句， 再判断布尔表达式，如果为true，再执行某语句，如此反复，直到布尔表达式条件为false时才停止循环，比如do-while循环。
a. while循环
语法结构：
while (布尔表达式) {
循环体;
}- 在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。
- 语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。
流程图：
<center>图8-4-1</center>
示例：
public class Test7 {
public static void main(String[] args) {
int i = 0;
int sum = 0;
// 1+2+3+…+100=?
while (i <= 100) {
sum += i;//相当于sum = sum+i;
i++;
}
System.out.println("Sum= " + sum);
}
}b. do-while循环
语法结构：
do {
循环体;
} while(布尔表达式) ;- do-while循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while循环的循环体至少执行一次。do-while循环结构流程图如图8-4-2所示：
流程图：
<center>图8-4-2</center>
示例：
public class Test8 {
public static void main(String[] args) {
int i = 0;
int sum = 0;
do {
sum += i; // sum = sum + i
i++;
} while (i <= 100);//此处的；不能省略
System.out.println("Sum= " + sum);
}
}- 从运行效图中可以看出do-while总是保证循环体至少会被执行一次!
c. for循环
语法结构：
for (初始表达式; 布尔表达式; 迭代因子) {
循环体;
}- for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式;随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环;最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。
流程图：
<center>图8-4-3</center>
示例：
public class Test10 {
public static void main(String args[]) {
int sum = 0;
//1.求1-100之间的累加和
for (int i = 0; i <= 100; i++) {
sum += i;
}
System.out.println("Sum= " + sum);
//2.循环输出9-1之间的数
for(int i=9;i>0;i--){
System.out.print(i+"、");
}
System.out.println();
//3.输出90-1之间能被3整除的数
for(int i=90;i>0;i-=3){
System.out.print(i+"、");
}
System.out.println();
}
}- Java里能用到逗号运算符的地方屈指可数，其中一处就是for循环的控制表达式。在控制表达式的初始化和步进控制部分，我们可以使用一系列由逗号分隔的表达式，而且那些表达式均会独立执行。
示例：
public class Test11 {
public static void main(String[] args) {
for(int i = 1, j = i + 10; i < 5; i++, j = i * 2) {
System.out.println("i= " + i + " j= " + j);
}
}
}- 编译器将while(true)与for(;;)看作同一回事，都指的是无限循环。
示例：
public class Test12 {
public static void main(String[] args) {
for ( ; ; ) { // 无限循环: 相当于 while(true)
System.out.println("特殊天气");
}
}
}- 在for语句的初始化部分声明的变量，其作用域为整个for循环体，不能在循环外部使用该变量。
示例：
public class Test12 {
public static void main(String[] args) {
for (int i=1 ;i<10 ;i++ ) {
System.out.println("test"+i);
}
System.out.println("test"+i);// 编译错误，无法使用for循环中的变量
}
}d. 嵌套循环
- 在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while与for循环可以任意嵌套多层。
示例1：
public class Test14 {
public static void main(String args[]) {
for (int i=1; i <=5; i++) {
for(int j=1; j<=5; j++){
System.out.print(i+" ");
}
System.out.println();
}
}
}示例2：
public class Test15 {
public static void main(String args[]) {
for (int i = 1; i < 10; i++) { // i是一个乘数
for (int j = 1; j <= i; j++) { // j是另一个乘数
System.out.print(j + "*" + i + "=" + (i * j < 10 ? (" " + i * j) : i * j) + " ");
}
System.out.println();
}
}
}e. break语句和continue语句
- 在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。
示例：
public class Test16 {
public static void main(String[] args) {
int total = 0;//定义计数器
System.out.println("Begin");
while (true) {
total++;//每循环一次计数器加1
int i = (int) Math.round(100 * Math.random());
//当i等于88时，退出循环
if (i == 88) {
break;
}
}
//输出循环的次数
System.out.println("Game over， used " + total + " times.");
}
}- continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
- continue用在while，do-while中，continue 语句立刻跳到循环首部，越过了当前循环的其余部分。（注意死循环）
- continue用在for循环中，跳到for循环的迭代因子部分。
示例：
public class Test17 {
public static void main(String[] args) {
int count = 0;//定义计数器
for (int i = 100; i < 150; i++) {
//如果是3的倍数，则跳过本次循环，继续进行下一次循环
if (i % 3 == 0){
continue;
}
//否则（不是3的倍数），输出该数
System.out.print(i + "、");
count++;//没输出一个数，计数器加1
//根据计数器判断每行是否已经输出了5个数
if (count % 5 == 0) {
System.out.println();
}
}
}
}- goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字，但并未在Java语言中得到正式使用;Java没有goto语句。然而，在break和continue这两个关键字的身上，我们仍然能看出一些goto的影子---带标签的break和continue。
示例：
public class Test18 {
public static void main(String args[]) {
outer: for (int i = 101; i < 150; i++) {
for (int j = 2; j < i / 2; j++) {
if (i % j == 0){
continue outer;
}
}
System.out.print(i + " ");
}
}
}邀请人:玖叁叁
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
评论
登录后参与评论
推荐阅读
目录