目录
3.1 程序结构
顺序结构、选择结构和循环结构是结构化程序设计的3种基基本结构，是各种复杂程序的基本构造单元。图31展示了这3种程序结构的基本理念，其中，第一幅高图是顺序结构的流程图，它就是按照书写顺序执行的语句构成的程序段;第二幅图是选择结构的流程程图，它主要根据输入数据和中间结果的不同选择执行不同的语句，选择结构主要由条件语句(也叫判断语句或者分支语句)组成;而第三幅图是循环结构的流程图，它是在一定条件下反复执行某段程序的流程结构，其中，一组被重复执行的语句称为循环体，而决定循环是否终止的判断条件是循环条件，循环结构主要由循环语句组成。
我们之前编写的程序都是顺序结构，比如定义一个int类型的变量并输出，代码如下: int a = 15;
System.out.println(a);
程序3种基本结构流程图
3.2 条件语句
在生活中，用户选择的情况非常多，比如，当一个人走到岔路口时，摆在面前的有两条路，那么应该如何根据需要选择要走的路呢?或者，在一个公司面临重大的战略转型时，领导人和投资人该如何做出正确的选择，这些都需要进行选择。那么在程序中，如果遇到选择的情况怎么办呢?这时条件语句就可以派上用场了。条件适句根据不同的条件来执行不同的语句，在Java中，条件语句主要包括if语句和switch语句两种。
3.2.1 if条件语句
if件语句主要用于告诉程序在某个条件成立的情况下执行某段语句，而在另一种情况下执行另外的语句。
使用if条件语句，可选择是否要执行紧跟在条件之后的那个语句。关键字if之后是作为条件的
“布尔表达式”，如果该表达式返回的结果为 true， 则执行其后的语句;若为 false，则不执行 if 条
件之后的语句。if条件语句可分为简单的 if条件语句、if...else 语句和 if….else if 多分支语句。
1.简单的if 条件语句语法如下:
if(布尔表达式){ 语句; } 布尔表达式:必要参数，它最后返回的结果必须是一个布尔值。它可以是一个单纯的布尔变量或常量，也可以是关系表达式。
语句:可以是一条或多条语句，当布尔表达式的值为 true 时执行这些语句。若语句序列中仅有一条语句，则可以省略条件语句中的“{}”。
代码3_1
public class HelloJava3_1 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
if (true) //让判断条件永远为真
System.out.println("我没有使用大括号"); //没有大括号，直接跟在if语句之后
if(true) //让判断条件永远为真
System.out.println("我使用大括号"); //输出语句在大括号之内
}
}
结果
代码3_2
import java.util.Scanner;//导入java.util.Scanner包
public class HelloJava3_2 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
Scanner in = new Scanner(System.in); //创建Scanner对象，用于进行输入
System.out.println("请输入要拨打的电话号码:");//输出请输入要拨打的电话号码
int phoneNumber = in.nextInt();//创建变量，保存电话号码
if (phoneNumber != 84972266)//判断此电话码是否是84972266
//如果不是84972266号码，则提示号码不存在
System.out.println("对不起，您拨打的号码不存在");//输出对不起，您拨打的号码不存在
}
}
结果
2. if...else语句
else 语句是条件语句中最常用的一种形式，它会针对某种条件有选择地做出处理。通常表现为“如果满足某种条件，就进行某种处理，否则就进行另一种处理”。
语法如下:
if(布尔表达式){
语句1;}else {
语句 2;
如果表达式的值为true，则执行紧跟if语句的复合语句;如果表达式的值为false，则执行else后面的语句。
这种形式的判断语句相当于汉语里的“如果……那么……否则……”，用流程图表示第二种判断语句，
代码3_3
import java.util.Scanner;//导入java.util.Scanner包
public class HelloJava3_3 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
int math = 95; //给math赋值
int english = 56; //给english赋值
if (math > 60) { //判断math是否大于60
System.out.println("数学及格了"); //条件成立时输出数学及格了
} else {//else循环
System.out.println("数学没有及格"); //条件成立时输出数学没有及格
}
if(english > 60) { //判断english是否大于60
System.out.println("英语及格了"); //条件成立时输出英语及格了
} else { //else循环
System.out.println("英语没有及格"); //条件成立时输出英语没有及格
}
}
}结果
3.if..elseif多分支语句
if..elseif多分支语句用于针对某一事件的多种情况进行处理。通常表现为“如果满足某种条件，就进行某种处理;如果满足另一种条件，则进行另一种处理理”。语法如下: if(表达式1){ 语句1 } else if(表达式 2){ 语句2 } else if(表达式n){ 语句n }
表达式1~表达式n:必要参数。可以由多个表达式组成，但最后返回的结果一定要为 boolean类型。
语句 1~语句 n:可以是一条或多条语句，当表达式1的值为true时，执行语句1;当表达式2的值为 true 时，执行语句 2，依此类推。
if..else if多分支语句的执行流程如下图 ：
代码3_4
public class HelloJava3_4 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
int x = 20; //给x赋值
if (x > 30) { //判断x是否大于60
System.out.println("a的值大于30"); //条件成立时输出a的值大于30
} else if (x > 10) {//else循环
System.out.println("a的值大于10,但小于30"); //条件成立时输出a的值大于10,但小于30
} else if (x >0) {//else循环
System.out.println("a的值大于0,但小于10"); //条件成立时输出的值大于0,但小于10
} else {//else循环
System.out.println("a的值小于0"); //条件成立时输出a的值小于0
}
}
}
结果
4.if 语句的嵌套
前面讲过三种形式的条件语句，这三种形式的条件语句都可以嵌套条件语句。例如，在第一种形式的条件语句中嵌套第二种形式的条件语句。形式如下:
if(表达式1)
{
if(表达式 2)
语句1;
else
语句 2;
}在第二种形式的条件语句中嵌套第二种形式的条件语句。形式如下:
if(表达式1){
if(表达式2)
语句1;
else
语句2;
}
else
{
if(表达式2)
语句1;
else
语句2;
}条件语句可以有多种，嵌套方式可以根据具体需要进行设计，但一定要注意逻辑关系的正确处理。使用if语句嵌套时要注意 else关键字字要和if关键字成对出现，并且遵守临近原则，else 关键字和自己最近的if语句构成一对。
代码3_5
import java.util.Scanner;//导入java.util.Scanner包
public class HelloJava3_5 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
int iYear; //定义iYear
Scanner sc = new Scanner(System.in); //创建扫描器
System.out.println("please input number"); //条件成立时输出please input number
iYear = sc.nextInt(); //控制台输入一个数字
if(iYear % 4 == 0) { //如果能被4整除
if(iYear % 100 == 0) { //如果能被100整除
if(iYear % 400 == 0) //如果能被400整除
System.out.println("It is a leap year"); //条件成立时输出It is a leap year
else//else循环
System.out.println("It is not a leap year");//条件成立时输出It is not a leap year
}else//else循环
System.out.println("It is a leap year");//条件成立时输出It is a leap year
}else//else循环
System.out.println("It is not a leap year");//条件成立时输出It is not a leap year
}
}结果
代码3_6
import java.util.Scanner;//导入java.util.Scanner包
public class HelloJava3_6 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
int iyear; //创建整形变量，保存输入的年份
Scanner sc=new Scanner(System.in);//创建扫描器
System.out.println("please input number");
iyear = sc.nextInt();//控制台输入一个数字
//如果iyear可以被4整除并且不能被100整除，或者iyear可以被400整除
if(iyear%4 ==0&&iyear % 100 != 0||iyear%400 == 0)
System.out.println("It is a leap year");//是闰年
else//else语句
System.out.println("It is not a leap year"); //不是闰年
}
}结果
3.2.2 switch 多分支语句
2008 年北会时候，全个国家齐聚北京，每个国家的参赛队都有指定的休息区，
如“美国代表队请到A4-14休息区等候”“法国代表队请到F9-03息区等候”等。本次奥运会共有204个国家参与，如果用计算机来分配休息区，难道要写204个if语句?
这是编程中一个常见的问题，就是检测一个变量是否符合某个条件，如果不符合，再用另一个值来检测，依此类推。比如我们给各个国家一个编号，然后我们判断某个代表队的国家编号是不是美国的?如果不是美国的，那是不是法国的?是不是德国的?是不是新加坡的?当然，这种问题可以使用if条件语句完成。
例如，使用if语句检测变量是否符合某个条件。关键代码如下:
country=001;
if (country=-001)(
System.out.printin("美国代表队请到A4-14休息区等候");
if (country -- 026) 1
System.out.printIn("法国代表队请到F9-03休息区等候");
if (country--103){
System.out.printIn("新加坡代表队请到 S2-08休息区等候");
...... /*此处省略其他201个国家的代表队*/
这个程序显得比较笨重，程序员需要测试不同的值来给出输出语句。在 Java 中，可以用switch语句将动作组织起来，以一个较简单明了的方式来实现“多选一”的选择。
语法如下:
switch(用于判断的参数)(
case 常量表达式1 :语句1;[break;] case.常量表达式2 :语句2;[break;]
..。。
case 常量表达式n:语句n;[break;1 default :语句n+1; [break;]switch 语句中参数必须是整型、字符型、枚举类型或字符串类型，常量值I~n必须是与参数兼容的数据类型。 switch语句首先计算参数的值,如果参数的值和某个 case 后面的常量表达式相同,则执行该case语句后的若干个语句，直到遇到 break 语句为止。此时如果该cas se 语句中没有 break 语句，将继续执行后面 case 中的若干个语句，直到遇到 break 语句为止。若没有任何一个常量表达式与参数的值相同，则执行default后面的语句。
break的作用是跳出整个 switch语句。
default语句是可以不写的，如果它不存在，而且switch语句中表达式的值不与任何case的常量值相同，switch 则不做任何处理。
代码3_7
public class HelloJava3_7 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
int week = 2; //定义int型变量week
switch (week) { //指定switch语句的表达式为变量week
case 1: //定义case语句中的常量为1
System.out.println("Monday");// 输出Monday
break; //结束当前循环
case 2: // 定义case语句中的常量为2
System.out.println("Tuesday");// 输出Tuesday
break; //结束当前循环
case 3: // 定义case语句中的常量为3
System.out.println("Wednesday");// 输出Wednesday
break; //结束当前循环
case 4: // 定义case语句中的常量为4
System.out.println("Thursday");// 输出Thursday
break; //结束当前循环
case 5: //定义case语句中的常量为5
System.out.println("Friday");// 输出Friday
break; //结束当前循环
case 6: // 定义case语句中的常量为6
System.out.println("Saturday");// 输出Saturday
break; //结束当前循环
case 7: // 定义case语句中的常量为7
System.out.println("Sunday");// 输出Sunday
break; 结束当前循环
default: // default语句，如果week不是1~7之间的数字，则执行此行代码
System.out.println("Sorry,I don't Know");// 输出Sorry,I don't Know
}
}
}结果
代码3_8
import java.util.Scanner;//导入java.util.Scanner包
public class HelloJava3_8 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
Scanner sc=new Scanner(System.in);//创建了一个新的对象叫sc
System.out.println("请输入成绩");// 输出请输入成绩
int grade=sc.nextInt();将sc赋值给grade
switch(grade) {//指定switch语句的表达式为变量grade
case 10://定义case语句中的常量为10
case 9: //定义case语句中的常量为9
System.out.println("成绩为优"); // 输出成绩为优
break;//结束当前循环
case 8: //定义case语句中的常量为8
System.out.println("成绩为良"); // 输出成绩为良
break;//结束当前循环
case 7://定义case语句中的常量为7
case 6://定义case语句中的常量为6
System.out.println("成绩为中"); // 输出成绩为中
break;//结束当前循环
case 5://定义case语句中的常量为5
case 4://定义case语句中的常量为4
case 3://定义case语句中的常量为3
case 2://定义case语句中的常量为2
case 1://定义case语句中的常量为1
case 0://定义case语句中的常量为0
System.out.println("成绩为差");// 输出成绩为差
break;//结束当前循环
default:// default语句，如果week不是1~7之间的数字，则执行此行代码
System.out.println("成绩无效"); // 输出成绩无效
break;//结束当前循环
}
}
}结果
如果 switch 语句中没有 break关键字，即使执行完对应的 case的处理语句，switch语句也不会立即停止，而是会继续执行下面所有的case，直至遇见break关键字或者完成执行完所有代码才会停止。这就是 switch的“贯穿”特性。我们可以利用这个“贯穿”的特性，让多个 case 共享同一段处理代码。
代码3_9
public class HelloJava3_9 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
String str="明日科技"; //将str赋值为日科技
switch(str){ //指定switch语句的表达式为变量str
case "明日": //定义case语句中的常量1
System.out.println("明日图书网www.mingribook.com");//输出明日图书网www.mingribook.com
break;//结束当前循环
case"明日科技": //定义case语句中的常量2
System.out.println("吉林省明日科技有限公司"); //输出吉林省明日科技有限公司
break;//结束当前循环
//default 语句
default://结束当前循环
System.out.println("以上条件都不是。"); //输出以上条件都不是。
}
}
}
结果
注意:
(1)同一个switch语句，case的常量值必须互不相同。
(2)在switch语句中，case语句后常量表达式的值可以为整数(除long外)，但绝不可以是实数。例如，下面的代码就是不合法的: case 1.1；
3.3 循环语句
循环语句就是在满足一定条件的情况下反复执行某一个操作。在Java中提供了4种常用的循环语句，分别是while语句、do...while 语句、for 语句和 foreach 语句，其中，foreach 语句是 for 语句的特殊简化版本。
3.3.1 while 循环语句
While语句的循环方式为利用一个条件来控制是否要继续反复执行这个语句，语法如下:
while(条件表达式){
执行语句 }
当条件表达式的返回值为真时，则执行“{}”中的语句，当把执行完“{}”中的语句后，重新判断条件表达式的返回值，直到表达式返回的结果为假时，退出循环。while 循环语句的执行流程如图：
代码3_10
public class HelloJava3_10 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
int x=1; //定义int型变量x，并赋给初值
int sum = 0; //定义变量用于保存相加后的结果
while (x <= 10) {//使用while循环语句
sum = sum + x; // while循环语句，当变量满足条件表达式时执行循环体语句
x++;}//将x++
System.out.println("sum = " + sum);//将变量sum输出
}
}结果
3.3.2 do...while 循环语句
do...while 循环语句与 while 循环语句类似，它们之间的区别是 while 语句为先判断条件是否成立再执行循环体，而 do...while 循环语句则先执行一次循环后，再判断条件是否成立。也就是说 do...while 循环语句中“{}”中的程序段至少要被执行一次。语法如下： do{
执行语句 }
while(条件表达式);
do...while 语句与 while 语句的一个明显区别是 do...while语句在结尾处多了一个分号(;)。根据 do...while 循环语句的语法特点总结出的 do...while 循环语句的执行流程。
代码3_11
public class HelloJava3_11 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
int a = 100;//定义a等于100
while (a == 60)// 指定进入循环语句
{
System.out.println("ok1");//while循环执行语句，输出ok1
a--; //a--
}
int b = 100; //定义b等于100
do {
System.out.println("ok2"); //do...while执行语句循环体，输出ok2
b--; // b--
} while (b == 60); //指定循环结束条件
}
}
结果
3.3.3 while 与 do...while 比较
可以通过设置起始循环条件不成立的循环语句来观察 while 和 do...while 的不同。将变量i初值设置为0，然后循环表达式设置为i>1，显然循环条件不成立。循环体执行的是对变量j的加1这算，通过输出变量j在循环前的值和循环后的值进行比较。
代码3_12
public class HelloJava3_12 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
int i=0, j=0; //给i和j都赋值为0
System.out.println("before do_while j=" + j); do { //输出before do_while j的值
j++; //j+1
} while (i > 1); //while语句
System.out.println("after do while j=" + j); //输出after do while j的值
}
}结果
代码3_13
public class HelloJava3_13 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
int i=0, j=0; //给i和j都赋值为0
System.out.println("before while j=" + j); //输出before do_while j的值
while (i > 1);{ //while语句
j++; //j+1
}
System.out.println("after while j=" + j);//输出after do while j的值
}
}结果
3.3.4 for 循环语句
for循环是Java设计中最有用的循环语句之一，一个for循环可以用来重复执行某条语句，直到某个条件得到满足。for语句语法如下:
for(表达式1;表达式2;表达式3) {
语句 }
*表达式 1:该表达式通常是一个赋值表达式，负责设置循环的起
始值，也就是给控制循环的变量赋初值。
*表达式 2:该表达式通常是一个关系表达式,用控制循环的变量和循环变量允许的范围值进行比较。
*表达式 3:该表达式通常是一个赋值表达式，对控制循环的变量
进行增大或减小。
*语句:语句仍然是复合语句。
for 循环语句的执行流程如下
(1)先执行表达式1.
(2)判断表达式 2，若其值为真，则执行for 语句中指定的内嵌语句，然后执行
(3)若表达式2值为假，则结束循环，转到(5)。
(3)执行表达式3。
(4)返回(2)继续执行。
(5)循环结束，执行 for 语句下面的一个语句。
代码3_14
public class HelloJava3_14 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
int sum = 0; int i; //给sum赋值
for (i = 1; i <= 100; i++){ // for循环语句
sum += i; //sum=sum+1
}
System.out.println("the result :"+ sum);//输出the result 的结果
}
}
结果
3.3.5 foreach 语句
foreach 语句是 for 语句的特殊简化版本，但是 foreach 语句并不能完全取代 for 语句，然而任何
foreach 语句都可以改写为 for 语句版本。foreach 并不是一个关键字，习惯上将这种特殊的 for 语句格式称之为foreach语句。foreach 语句在遍历数组等方面为程序员提供了很大的方便。 语法如下:
for(循环变量x :遍历对象 obj){
引用了x的java 语句;}
遍历对象 obj:依次去读 obj 中元素的值。 循环变量 x:将 obj 遍历读取出的值赋给x。
说明:
遍历，在数据结构中是指沿着某条路线，依次对树中每个节点均做一次且且仅做一次访问。我们可以简单地理解为，对数组或集合中的所有元素，逐一访问，依次读取一遍。数组，就是的集合。
是相同数据类型的元素按一定顺序排列 的集合 foreach 语句中的元素变量x，不必对其进行初始化。下面通过简单的例子来介绍foreach语句是如何遍历一维数组的。
代码3_15
public class HelloJava3_15 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
int arr[]={7,10,1 }; //声明一维数组
System.out.println("一维数组中的元素分别为:"); //输出一维数组中的元素分别为
for (int x:arr){ //foreach语句，intx引用的变量，arr指定要循环遍历的数组最后将x输出
System.out.println(x); //输出X的值
}
}
}
结果
3.3.6循环语句的嵌套
循环有for、while、do...while3 种方式，这3种循环可以相互嵌套。 在 while 循环中套用 for 循环：
for (...)
{
for (..){
...
}
}在 while 循环中套用 while 循环：
while (...)
{
while (...){
{
...
}
}在 while 循环中套用 for 循环：
while(..)
{
for (...)
{
...
}
}
代码3_16
public class HelloJava3_16 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
int i, j; //创建两个整型变量
for (i=1;i<10;i++){ //输出9行
for (j=1;j<i+1;j++){ //输出与行数相等的列
System.out.print(j + "*" + i + "=" + i * j + "\t"); //输出j*i的值，
}
System.out.println(); //换行
}
}
}
结果
3.4 跳转语句
跳转语句包含两方面的内容，一方面是控制循环变量的变化方式，也就是让循环判断中的逻辑关系表达式变成false，从而达到终止循环的效果;一方面是控制循环的跳转。控制循环的跳转需要用到 break 和 continue 两个关键字，这两条跳转语句的跳转效果不同，break 是中断循环，continue是直接执行下一次循环。
3.4.1 break 语句
使用break 语句可以跳出 switch 结构。在循环结构中，同样也可用 break 语句跳出当前循环体从而中断当前循环。
代码3_17
public class HelloJava3_17 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
for (int i =1; i <20; i++) { //在for循环前用标签标记
if (i % 2 == 0) {// 如果i是偶数
System.out.println(i);//输出i的值
break;//跳到下一循环
}
}
System.out.println("---end---"); //输出---end---
}
}结果
代码3_18
public class HelloJava3_18 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
for (int i = 0; i < 3; i++) { //在for循环前用标签标记
for (int j = 0; j < 6; j++) { //在for循环前用标签标记
if(j == 4) { //如果j等于4的时候就结束
break; //跳出循环
}
System.out.println("i=" + i + " j=" + j);// 输出i和j的值
}
}
}
}结果
从这个运行结果我们可以看出:
（1)循环中的 if语句判断:如果j等于4时，执行 break 语句，则中断了内层的循环，输出的 j值最大到3为止。
(2)但是外层的循环没有受任何影响，输出的i值最大到 2，正是 for 循环设定的最大值。如果想要让 break 跳出外层循环，Java 提供了“标签”的功能，语法如下:标签名:循环体{
break 标签名;
标签名:任意标识符。循环体:任意循环语句。
break 标签名:break跳出指定的循环体，此循环体的标签名必须与break的标签名一致。带有标签的 break 可以制定跳出的循环，这个循环可以是内层循环，也可以是外层循环。
代码3_19
public class HelloJava3_19 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
Loop:for(int i=0;i<3;i++){//在for循环前用标签标记
for (int j=0; j<6; j++) {
if(j==4){//如果j等于4的时候就结束外层循环
break Loop;//跳出Loop标签标记的循环体
}
System.out.println("i="+i+" j="+ j);// 输出i和j的值
}
}
}
}结果
3.4.2 continue 语句
continue 语句是针对 break 语句的补充。continue 不是立即跳出循环体，而是跳过本次循环结束前的语句，回到循环的条件测试部分，重新开始执行循环。在 for 循环语句中遇到 continue 语句后，首先执行循环的增量部分，然后进行条件测试。在 while 和 do...while 循环中，continue 语句使控制直接回到条件测试部分。
代码3_20
public class HelloJava3_20 {//创建类
public static void main(String[] args) {//主函数
// TODO 自动生成的方法存根
for (int i = 1; i< 20; i++) { //在for循环前用标签标记
if (i % 2 != 0) { // 如果i不是偶数
continue; // 跳到下一循环
}
System.out.println(i); // 输出i的值
}
}
}
结果
与break语句一样，continue语句也支持标签签功能，语法如下: 标签名 : 循环体{
continue 标签名;
标签名:任意标识符。 循环体:任意循环语句。
continue标签名:continue语句跳出指定的循环体，此循环体的标签名必须与 continue 的标
签名一致。
435
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
