本文深入探讨了Java程序的三种基本结构：顺序结构、选择结构（if, if-else, switch）和循环结构（for, while, do...while），并结合实例详细解析了每种结构的执行流程和应用场景。此外，文章还介绍了条件运算符和循环的中断（break, continue）以及一些编程练习，帮助读者巩固理解。"
134740831,7814769,深度解析：自然语言处理中的序列标注技术,"['自然语言处理', '序列标注', '深度学习', '神经网络', 'NLP']
如果想处理二选一或者多选一的操作，那么判断就是很好的选择，如果想处理重复的工作时，“ 循环”就是一个很好的选择，它可以运行相同的程序片段，还可以使程序结构化。
一般来说程序的结构有顺序结构、选择结构和循环结构3种，这3种不同的结构有一个共同点，就是它们都只有一个入口，也只有一个出口。这些单一入、出口可以让程序易读、好维护，也可以减少调试的时间。下面以流程图的方式让读者了解这3种结构的不同。
1.顺序结构
顺序结构，程序至上而下逐行执行，一条语句执行完之后继续执行下一条语句，一直到程序的末尾。其流程图如图所示：
2.选择结构
其是根据条件的成立与否决定要执行哪些语句的一种结构，其流程图如图所示：
if语句
生活中很多事情都是在满足一定条件下发生的，同样程序中的“某操作语句”也是在满足一定逻辑条件下才执行的，这种语句称作条件语句，或称为“if 语句”。使用 if 关键字，该“某操作语句”称为“if 体”或“条件语句体”。 
if 语句的执行流程：首先判断关键词 if 后括号内条件表达式的值，如果该表达式的值为逻辑真（非 0），则执行 if 体，接着执行 if 体后的其他语句；否则，若该表达式的值为逻辑假（0），则不执行该 if 体，直接执行 if 体后的其他语句。
if 分支结构通常用在：在数据有默认值或事件有默认操作的前提下，对特殊情况进行特殊处理的场景。
if语句的执行流程图如下：
if-else语句
if-else 语句的执行流程：首先判断关键词if后括号内条件表达式的值，如果该表达式的值为逻辑真（非 0），则执行 if 体（语句 A），而不执行 else 体（语句 B），然后继续执行 if-else 之后的其他语句；否则，若该表达式的值为逻辑假（0），则不执行该 if 体（语句 A），而执行 else 体（语句 B），然后继续执行 if-else 之后的其他语句。
由于表达式的值在逻辑上只有真和假，故 if 和 else 在执行流程上是互斥的，执行且只能执行两者中的一个。
[if-else语句的格式]
if (判断条件) {
语句主体1;
}else {
语句主体2;
}
有一种运算符可以代替if…else语句，即三目运算符：
使用三目运算符时，操作数有3个，其格式如下：
变量 = 条件判断? 表达式1: 表达式2
将上面的格式以if语句解释，就是当条件成立时执行表达式1，否则执行表达式2，通常会将这两个表达式之一的运算结果指定给某个变量，也就相当于下面的if…else 语句：
if (条件判断)
变量x = 表达式1;
else
变量x = 表达式2;
例:使用三目运算符求出两个数字中的最大值
public class MaxDemo {
public static void main (String[] args) {
int max = 0; //定义变量保存最大值
int x = 3; //定义整型变量x
int y = 10; //定义整型变量y
max = x>y ? x : y; //通过三目运算符求最大值
System.out.println("最大值为: " + max); // 输出求出的最大值
程序运行结果：
最大值为：10
可以发现，使用条件运算符编写程序时较为简洁，它用一个语句就可以替代一长串的if-else语句，所以条件运算符的执行速度也较高。
if-else 语句的执行流程图如下：
if…else if…else语句
如果需要在if…else中判断多个条件时，就需要if…else if…else语句了，其格式如下:
if (条件判断1) {
语句主体1;
}else if (条件判断2) {
语句主体2;
}
//...多个else if ()语句
else{
语句主体3;
}
例:使用if...else if...else语句
public class MoreIfElseDemo {
public static void main(String[] args) {
int x=3; //定义整型变量x
if(x==1) { //判断x的值是否为1
System.out.println("x的值是1! "); //输出信息
}else if(x==2){ //判断x的值是否为2
System.out.println("x的值是2! "); //输出信息
}else if(x==3){ //判断x的值是否为3
System.out.println("x的值是3! ") ;//输出信息
}else { //其他值
System.out.println("x的值不是1、2、3中的一个! ");
程序运行结果:
x的值是3!
4.switch case语句
switch语句可以将多选一的情况简化，使程序简洁易懂。case常量表达式只是起语句标号作用，并不是该处进行条件判断。在执行switch语句时，根据switch的表达式，找到与之匹配的case语句，就从此case子句执行下去，不再进行判断，直到碰到break或函数结束为止。使用switch语句直接处理多个分支(当然包括两个分支)。其一般形式为：
switch (表达式) {
case选择值1: 语句主体1;
break;
case选择值2: 语句主体2;
break;
......
case选择值n: 语句主体n;
break;
default : 语句主体;
break;
}
//要特别注意的是，在switch语句中选择值只能是字符或常量。
switch语句的执行流程是: 首先计算switch后面表达式的值，然后用此值依次与各个case的常量表达式比较，若表达式的值与某个case后面的常量表达式的值相等，就执行此case后面的语句，执行后遇break语句就退出switch语句；若表达式的值与所有case后面的常量表达式都不等，则执行default后面的语句，然后退出switch语句，程序流程转向开关语句的下一个语句。
例：
public class SwitchDemo{
public static void main(String[] args) {
int x=3; //声明整型变量x
int y=6; //声明整型变量y
char oper = '+' ; //声明字符变量
switch (oper) { //将字符作为switch的判断条件
case '+': { //判断字符内容是否是“+”
System.out.println("x+y=" + (x+y));
break; //退出switch
}
case '-': { //判断字符内容是否是“-”
System.out.println("x-y=" + (x-y));
break; //退出switch
}
case '*': { //判断字符内容是否是“*”
System.out.println("x*y=" + (x*y));
break; //退出switch
}
case '/': { //判断字符内容是否是 “/”
System.out.print1n("x/y=" + (x/y));
break; //退出switch
}
default: { //其他字符
System.out.println("未知的操作! ");
break; //退出switch
}
}
}
}
程序运行结果:
x+y=9
从以上程序可以发现，在每一个case语句之后都加上了一个break语句，如果不加入此语句，则switch语句会从第一个满足条件的case开始依次执行操作。
如果上面程序没有break，则程序运行结果:
x+y= 9
x-y= -3
x*y= 18
x/y= 0
未知的操作!
3.循环结构
循环结构是根据判断条件的成立与否决定程序段落的执行次数，而这个程序段落就称为循环主体。循环结构的流程图如图所示：
（1）for循环
for循环适用于知道范围的情况（或知道循环次数的情况）。
for 循环语句格式
for (变量初始化; 判断条件;变量值变化) {
语句1;
...
语句n;
}
若是在循环主体中要处理的语句只有一个，可以将大括号省去。
for循环的流程:
(1)第一次进入for循环时，要为循环控制变量赋起始值。
(2)根据判断条件的内容检查是否要继续执行循环，当判断条件值为真(true)时，继续执行循环主体内的语句；判断条件值为假(false) 时，则会跳出循环，执行其他语句。
(3)执行完循环主体内的语句后，循环控制变量会根据增减量的要求更改循环控制变量的值，然后再回到步骤(2)重新判断是否继续执行循环。
for循环流程图：
例:使用for 循环完成累加操作
public class ForDemo {
public static void main(String[] args) {
int sum = 0; //定义变量保存累加结果
for(int x=1; x<=10; x++){ //使用for循环
sum += x; //执行累加操作
}
System.out.println("1-->10累加结果为:" + sum);//输出累加结果
}
}
程序运行结果:
1-->10累加结果为: 55
（2）while循环
while是循环语句，也是条件判断语句。当事先不知道循环该执行多少次时，就要用到while循环。
while 循环的格式
while (循环条件判断) {
语句1 ;
语句2 ;
...
语句n ;
循环条件更改;
}
当while循环主体有且只有一个语句时，可以将大括号省去。在while循环语句中只有一个判断条件，它可以是任何表达式。当判断条件的值为真，循环就会执行一次，再重复，测试判断条件，执行循环主体，直到判断条件的值为假，才会跳离while循环。
下面列出了while循环执行的流程:
(1)第1次进入while循环前，必须先为循环控制变量(或表达式)赋起始值。.
(2)根据判断条件的内容决定是否要继续执行循环，如果条件判断值为真(true)，继续执行循环主体；若条件判断值为假(false) ，则跳出循环执行其他语句。
(3)执行完循环主体内的语句后，重新为循环控制变量(或表达式)赋值(增加或减少)，由于while循环不会自动更改循环控制变量(或表达式)的内容，所以在while循环中为循环控制变量赋值的工作要由设计者自己来做，完成后再回到步骤(2)重新判断是否继续执行循环。
例:使用while循环进行累加操作
public class WhileDemo {
public static void main(String[] args) {
int x=1; //定义整型变量x
int sum = 0; //定义整型变量，保存累加结果
while (x <= 10) { //判断循环条件
sum += x; //执行累加操作
x++ ; //修改循环条件
System.out. println("1-->10累加结果为:" + sum); //输出结果
}
}
程序运行结果:
1-->10累加结果为: 55
从以上程序可以发现在while语句执行之前先进行循环条件的判断(x<=10)，在while语句之后对循环条件进行修改(x++) ，如果程序中没有修改循环条件，那么程序就将出现"死循环"的情况。
（3）do…while 循环
do…while循环也是用于未知循环执行次数的情况，而while循环及do…while循环最大的不同就是进入while循环前，while语句会先测试判断条件的真假，再决定是否执行循环主体，如果不满足条件，则不能进入循环；而do…while循环则是每次都是先执行一次循环主体，然后再测试判断条件的真假，所以无论循环成立的条件是什么，使用do…while循环时,至少都会执行一次循环主体。
do...while循环的格式如下:
do{
语句1 ;
语句2 ;
...
语句n ;
循环条件改变;
}while (循环条件判断) ;
do…while循环执行的流程:
(1)进入do…while 循环前，要先为循环控制变量(或表达式)赋起始值。
(2)直接执行循环主体，循环主体执行完毕，才开始根据判断条件的内容决定是否继续执行循环，条件判断值为真(true) 时，继续执行循环主体；条件判断值为假(false) 时，则跳出循环，执行其他语句。
(3)执行完循环主体内的语句后，重新为循环控制变量(或表达式)赋值(增加或减少)，由于do…while循环和while循环一样，不会自动更改循环控制变量(或表达式)的内容,所以在do…while循环中赋值循环控制变量的工作要由自己来做,然后再回到步骤(2)重新判断是否继续执行循环。
do…while循环流程图：
例:使用do..while循环完成累加操作
public class DoWhileDemo {
public static void main(String[] args) {
int x=1; //定义整型变量x
int sum=0; //定义整型变量,保存累加结果
do { // do...while至少先执行一次
sum += x; //执行累加操作
x++ ; //修改循环条件
}while(x<=10); //判断循环
System.out.println("1-->10累加结果为: " + sum); //输出累加结果
}
}
程序运行结果:
1-->10累加结果为: 55
从程序的运行结果可以发现while和do…while的操作结果是一样的。但do…while与while循环不同的是do…while操作中就算条件不满足，也会至少执行一次。而while如果条件不满足，则一次也不会被执行。
（4）循环的嵌套：
多个循环语句是可以嵌套操作的，如果现在要打印一个九九乘法表，则肯定要使用两层循环完成。
例:打印九九乘法表
public class ForNestedDemo {
public static void main(String[] args) {
for(int i=1; i<=9; i++){ //第一层循环
for(int j=1; j<=i; j++){ //第二层循环
System.out.print(i + "*" + j + "="+ (i * j) + "\t") ;
}
System.out.print ("\n") ; //换行
}
}
}
程序运行结果:
（5）循环的中断
在Java语言中，可以使用如break、continue等中断语句。站在结构化程序设计的角度上，并不鼓励用户使用中断语句，因为这些中断语句会增加调试及阅读的困难。因此建议读者尽量不要使用中断语句。
break语句
break语句可以强迫程序中断循环，当程序执行到break语句时，即会离开循环，继续执行循环外的下一个语句，如果break语句出现在嵌套循环中的内层循环，则break语句只会跳出当前层的循环。
以下面的for 循环为例，在循环主体中有break语句时，当程序执行到break时，会离开循环主体，而继续执行循环外层的语句。
break语句格式
for (初值赋值; 判断条件;设增减量) {
语句1;
语句2;
...
break; //若执行break语句，则此块内的语句将不会被执行
...
语句n;
}
...
例:使用break
public class BreakDemo {
public static void main(String[] args) {
for(int i=0; i<10; i++){ //使用for循环
if(i==3){ //如果i的值为3，则退出整个循环
break; // 退出整个循环
}
System.out.println("i = " + i); //打印信息
}
}
}
程序运行结果:
i= 0
i= 1
i = 2
从程序的运行结果中可以发现，当i的值为3时，判断语句满足，则执行break语句退出整个循环。
continue 语句
continue语句可以强迫程序跳到循环的起始处，当程序运行到continue语句时，会停止运行剩余的循环主体，而是回到循环的开始处继续运行。
在下面的for 循环中，在循环主体中有continue语句，当程序执行到continue时，就会回到循环的起点，继续执行循环主体的部分语句。
continue语句格式
for (初值赋值; 判断条件;设增减量)
语句1 ;
语句2;
...
continue //若执行continue语句，则此处将不会被执行
...
语句n;
}
...
例:将前面for循环的程序修改为continue 循环，观察运行结果
pub1ic class ContinueDemo {
public static void main(String[] args) {
for(int i=0; i<10; i++){ //使用for循环
if(i==3){ //如果i的值为3，则退出整个循环
continue; // 退出一次循环
}
System.out.println("i = " + i); //打印信息
}
}
}
程序运行结果:
从程序的运行结果中可以发现，当i的值为3时，程序并没有向下执行输出语句，而是退回到了循环判断处继续向下执行，所以continue只是中断了一次的循环操作。
练习
1.打印出所有的“水仙花数”，所谓“水仙花数”是指一个3位数，其各位数字立方和等于该数本身。例如，153 是一个“水仙花数”，因为153= (1 的三次方+5的三次方+3的三次方)。
public class test1 {
public static void main(String args[]){
for (int a = 0; a <= 9; a++) { // 水仙花的百位
for (int b = 0; b <= 9; b++) { // 水仙花的十位
for (int c = 0; c <= 9; c++) { // 水仙花的个位
int num = a * a * a + b * b * b + c * c * c;
int num1 = a * 100 + b * 10 + c;
if (num == num1 && num > 99) {
System.out.println(num);
}
}
}
}
}
}
程序运行结果如下：
2.通过代码完成两个整数内容的交换。
public class test2{
public static void main(String[] args) {
int a=1314,b=521;
int temp; //中间变量
System.out.println("交换内容前:a="+a+"\t"+"b="+b); //"\t"是制表符
temp=b;
b=a;
a=temp;
System.out.println("交换内容后:a="+a+"\t"+"b="+b);
}
}
程序运行结果如下：
3.给定3个数字，求出这3个数字中的最大值，并将最大值输出。
public class test3 {
public static void main(String[] args) {
int x=30, y=80, z=50, max=x; //x,y,z为给定的三个数字，暂时把第一个数字x赋给最大值max
if (y>x) { //x,y,z一对一对的比，谁大谁赋值给最大值max
max=y;
}
if (z>x) {
max=z;
}
if (y>z) {
max=y;
}
System.out.println("x="+x+" y="+y+ " z="+z+ " 最大值为: "+max);
}
}
程序运行结果如下：
4.判断某数能否被3、7、5同时整除。
import java.util.Scanner;
public class test4 {
public static void main(String[] args) {
Scanner s=new Scanner(System.in); //实例化
System.out.println("请输入数字：");
int x = s.nextInt();
if(x%3==0 && x%5==0 && x%7==0){
System.out.println("该数能被3、5、7同时整除");
}else{
System.out.println("该数不能被3、5、7同时整除");
}
}
}
程序运行结果如下：
5.求1~ 1000之间可以同时被3、5、7整除的数字。
public class test5 {
public static void main(String[] args) {
for (int i=1; i<1000; i++ ){
if(i%3==0 && i%5==0 && i%7==0){
System.out.println("i=" + i);
}
}
}
}
程序运行结果如下：
6.编写Java程序，求13-23+33-43+……+973-983+993-1003的值。
public class test6 {
public static void main(String[] args) {
int i, j = 1, sum = 0, k=0;
for(i = 13;i <= 1003; i = i + 10) {
k = (j) * i;
sum = sum + k;
j = -j;
}
System.out.println(sum);
}
}
程序运行结果如下：
-500
7.编程求1+2+3+…100的值。
public class test7{
public static void main(String[] args) {
int sum=0;
for(int i=1;i<=100;i++) {
sum+=i;
}
System.out.println("1+2+3+...+100="+sum);
}
}
程序运行结果如下：
8. 一个数如果恰好等于它的因子之和，这个数就称为完数。编写程序输出1000以内的所有完数。
public class test8 {
public static void main(String[] args) {
int i, j, sum;
for(i=0;i<=1000;i++){
if(i==1) continue;
sum=1;
for(j=2;j<i;j++)
if(i%j==0) sum+=j;
if(sum == i){
System.out.println(i);
}
}
}
}
程序运行结果如下：
9.编程求1！+2！+3！+…+20!。
public class test9 {
public static void main(String[] args) {
int i, j ;
long sum = 0, k=1;
for(i = 1;i <= 20;i++) {
k = 1;
for(j = 1;j <= i;j++) {
k = k * j;
}
sum += k;
}
System.out.println(sum);
}
}
程序运行结果如下：
10.使用for循环打印下面的图形：
*
* *
* * *
* * * *
* * * * *
public class test10 {
public static void main(String[] args) {
int i, j, x = 4, k, l = 4;
for(i = 0;i < 5;i++) {
for(j = x;j > 0;j--) {
System.out.print(" ");
}
x = x -1;
for(k = l;k < 5;k++) {
System.out.print("* ");
}
System.out.print("\n");
l--;
}
}
}
程序运行结果如下：
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
