第三章流程控制

Slikc

已于 2022-05-30 10:47:16 修改

阅读量789

点赞数

文章标签： java eclipse

于 2022-03-12 00:38:10 首次发布

本文链接：https://blog.csdn.net/Slikc/article/details/123420688

版权

3.3.3 while与do…while比较

3.1 程序结构

顺序结构、选择结构和循环结构是结构化程序设计的3种基本结构，是各种复杂程序的基本构造单元。以下图展示了这3种程序结构的基本理念，其中，第一幅图是顺序结构的流程图，它就是按照书写顺序执行的语句构成的程序段;第二幅图是选择结构的流程图，它主要根据输入数据和中间结果的不同选择执行不同的语句，选择结构主要由条件语句(也叫判断语句或者分支语句)组成;而第三幅图是循环结构的流程图，它是在一定条件下反复执行某段程序的流程结构，其中，一组被重复执行的语句称为循环体，而决定循环是否终止的判断条件是循环条件，循环结构主要由循环语句组成。

3.2 条件语句

在生活中，用户选择的情况非常多，比如，当一个人走到岔路口时，摆在面前的有两条路，那么应该如何根据需要选择要走的路呢?或者，在一个公司面临重大的战略转型时，领导人和投资人该如何做出正确的选择，这些都需要进行选择。那么在程序中，如果遇到选择的情况怎么办呢?这时条件语句就可以派上用场了。条件适句根据不同的条件来执行不同的语句，在Java中，条件语句主要包括if语句和switch语句两种。

3.2.1 if条件语句

1.if条件语句主要用于告诉程序在某个条件成立的情况下执行某段语句，而在另一种情况下执行另外的语句。
2.使用if条件语句，可选择是否要执行紧跟在条件之后的那个语句。关键字if之后是作为条件的“布尔表达式”，如果该表达式返回的结果为true,则执行其后的语句;若为false, 则不执行if条件之后的语句。if 条件语句可分为简单的if条件语句、if..else 语句和f..else if多分支语句。

1.简单的if条件语句

 if(布尔表达式){                                                                                   语句;                                                                           
}

布尔表达式:必要参数，它最后返回的结果必须是一个布尔值。它可以是一个单纯的布尔变量或常量，也可以是关系表达式。
语句: 可以是一条或多条语句，当布尔表达式的值为true时执行这些语句。若语句序列中仅有一条语句，则可以省略条件语句中的“{ }”。

public class IFTest {//创建IFTest类
		public static void main (String[] args) {//主方法
			 if (true) //让判断条件永远为真
			  System.out.println("我没有使用大括号");//没有大括号，直接跟在if语句后面
			 if(true) {//让条件永远为真
			  System.out.println("我使用大括号");//输出语句在大括号之内
			 }
	}

}

import java.util.Scanner;//导入输出函数需要用到的包
public class Takephone {//创建Takephone类
	public static void main(String[] args) {//主方法
	Scanner in =new Scanner (System.in);//创建Scanner对象，用于进行输入
	System.out.println("请输入要拨打的电话号码:");//输出请输入要拨打的电话号码
	int phoneNumber=in.nextInt();//创建变量，保存电话号码
	if(phoneNumber!=84972266)//判断电话号码是否是84972266
		System.out.println("对不起，您拨打的号码不存在!");//如果不是84972266号码，则提示号码不存在
	}

}

2. if..else语句

1. if..else语句是条件语句中最常用的一种形式，它会针对某种条件有选择地做出处理。通常表现为“如果满足某种条件，就进行某种处理，否则就进行另一种处理”。
2.如果表达式的值为true,则执行紧跟if语句的复合语句;如果表达式的值为false, 则执行else后面的语句。
3. 这种形式的判断语句相当于汉语里的“如...那么......用流程图表示第二种判断语句，如图所示。

注意：else不能单独使用，必须和关键词if一起出现。else(a>b)max=a是不合法的。

public class Getifelse {//创建Getifelse类
	public static void main(String[] args) {//主方法
		int math =95;//声明int型局部变量，并赋给初值95
		   int english=56;//声明int型局部变量，并赋给初值56
		   if (math>60) {//使用if语句判断math是否大于60
		    System.out.println("数学及格了");//条件成立时输出的信息
		   }else {//else语句
		    System.out.println("数学没有及格");//条件不成立时输出的信息
		   }
		   if(english>60) {//判断英语成绩是否大于60
		    System.out.println("英语及格了");//条件成立时输出的信息
		   }else {//else语句
		    System.out.println("英语没有及格");//条件不成立时输出的信息
		   }
	}

}

3.if..elseif多分支语句

if..elseif多分支语句用于针对某一事件的多种情况进行处理。通常表现为“如果满足某种条件，就进行某种处理;如果满足另一种条件，则进行另一种处理”。 if…else if多分支语句的执行流程如图

public class GetTerm {//创建GetTerm类
	public static void main(String[] args) {//主方法
		int x=20;//声明int型局部变量
		if(x>30) {//判断变量x是否大于30
			System.out.println("a的值大于30");//条件成立的输出信息
		} else if (x>10) {//判断变量x是否大于10
			System.out.println("a的值大于10,但小于30");//条件成立的输出信息
		}else if (x>0) {//判断变量x是否大于0
			System.out.println("a的值大于0,但小于10");//条件成立的输出信息
		}else {//当以上条件都不成立时，执行的语句块
			System.out.println("a的值小于等于0");//输出信息
		}
	}

}

4.if 语句的嵌套

条件语句可以有多种，嵌套方式可以根据具体需要进行设计，但一定要注意逻辑关系的正确处理。使用if语句嵌套时要注意 else关键字字要和if关键字成对出现，并且遵守临近原则，else 关键字和自己最近的if语句构成一对。

import java.util.Scanner;//导入输出函数需要用到的包
public class JudgeLeapYear {//创建JudgeLeapYear类
	public static void main(String[] args) {//主方法
		int iYear;//创建整型变量，保存输入的年份
		Scanner sc=new Scanner (System.in);//创建扫描器
		System.out.println("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 a leap year");  //是闰年
		   else//else语句
		    System.out.println("It is not a leap year");  //不是闰年
		  }  else//else语句
		   System.out.println("It is a leap year");   //是闰年
		 }else//else语句
		  System.out.println("It is ont a leap year");   //不是闰年
	}

}

import java.util.Scanner;//导入输出函数需要用到的包
public class JudgeLeapYear2 {//创建JudgeLeapYear2类
	public static void main(String[] args) {//主方法
		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)//如果iyear可以被4整除并且不能被100整除，或者iyear可以被400整除
		   System.out.println("It is a leap year");  //是闰年
		  else//else语句
		   System.out.println("It is not a leap year");  //不是闰年
	}

}

3.2.2 switch多分支语句

1.switch 语句中参数必须是整型、字符型、枚举类型或字符串类型，常量值1~n必须是与参数兼容的数据类型。
2.switch语句首先计算参数的值，如果参数的值和某个case后面的常量表达式相同，则执行该case语句后的若千个语句，直到遇到break语句为止。此时如果该case 语句中没有break语句，将继续执行后面case中的若干个语句，直到遇到break语句为止。若没有任何一个常量表达式与参数的值相同，则执行default后面的语句。
3.break的作用是跳出整个switch语句。
4.default语句是可以不写的，如果它不存在，而且switch语句中表达式的值不与任何case的常量值相同，switch 则不做任何处理。

public class GetSwitch {//创建GetSwitch类
	public static void main(String[] args) {//主方法
		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
		  }

	}

}

import java.util.Scanner;//导入输出函数需要用到的包
public class Grade {//创建类
	public static void main(String[] args) {//主方法
		   Scanner sc=new Scanner(System.in);//创建System对象，用于进行输入
		   System.out.println("请输入成绩");// 输出信息 break;
		   int grade=sc.nextInt();//将sc赋值给grade
		   switch(grade) {//指定switch语句的表达式为变量grade
		   case 10://定义case语句中的常量为10
		   case 9: System.out.println("成绩为优"); break;// 定义case9语句中的常量为优
		   case 8:  System.out.println("成绩为良"); break;// 定义case8语句中的常量为良
		   case 7://定义case7语句中的常量为
		   case 6:System.out.println("成绩为中"); break;// 定义case6语句中的常量为中
		   case 5:// 定义case5语句中的常量
		   case 4://定义case4语句中的常量为
		   case 3://定义case3语句中的常量为
		   case 2://定义case2语句中的常量为
		   case 1://定义case1语句中的常量为
		   case 0:System.out.println("成绩为差"); break;// 定义case0语句中的常量为差
		   default:System.out.println("成绩无效"); break;//反之成绩无效
		   }
	}

}

如果 switch 语句中没有 break关键字，即使执行完对应的 case的处理语句，switch语句也不会立即停止，而是会继续执行下面所有的case，直至遇见break关键字或者完成执行完所有代码才会停止。这就是 switch的“贯穿”特性。我们可以利用这个“贯穿”的特性，让多个 case 共享同一段处理代码。

public class SwitchInString {//创建SwitchInString类
	public static void main(String[] args) {//主方法
		String str="明日科技"; //将str赋值为日科技
		 switch(str){ //指定switch语句的表达式为变量str
		  case "明日": //定义case语句中的常量1 
		  System.out.println("明日图书网www.mingribook.com");//输出信息
          break;//结束当前循环
		  case"明日科技": //定义case语句中的常量2 
		   System.out.println("吉林省明日科技有限公司"); //输出信息 
		  break;//结束当前循环
		  default: //default 语句
		  System.out.println("以上条件都不是。"); //输出信息
		 }

	}

}

注意：(1 )同一个switch语句，case的常量值必须互不相同。
(2)在switch 语句中，case语句后常量表达式的值可以为整数(除long外)，但绝不可以是实数。

3.3 循环语句

循环语句就是在满足一定条件的情况下反复执行某一个操作。在Java语句是语句，分别是while语句、do...while 语句、for 语句和foreach语句，其中，foreach语句for语句的特殊简化版本。

3.3.1 while循环语句

while语句的循环方式为利用一个条件来控制是否要继续反复执行这个语句。

当条件表达式的返回值为真时，则执行“{ }”中的语句，当执行完“{ }”中的语句后，重新判断条件表达式的返回值，直到表达式返回的结果为假时，退出循环。

public class GetSum {//创建GetSum类
	public static void main(String[] args) {//主方法
		int x=1;// 定义int型变量x，并赋给初值 
		  int sum= 0;// 定义变量用于保存相加后的结果 
		  while (x <= 10) {//x大于等于10
		  sum =sum+x;// while循环语句，当变量满足条件表达式时执行循环体
		  x++;//先使用后计算
		  }
		  System.out.println("sum="+sum);//将变量sum输出
	}

}

注意：初学者经常犯的一个错误就是在while表达式的括号后加“;”。如:
while(x == 5) ;
System.out.println("x的值为5");
这时程序会认为要执行一条空语句，而进入无限循环，Java编译器又不会报错。这可能会浪费很多时间去调试，应注意这个问题。

3.3.2 do…while循环语句

do... while循环语句与while循环语句类似，它们之间的区别是while语句为先判断条件是否成立再执行循环体，而do...while 循环语句则先执行一次循环后，再判断条件是否成立。也就是说do...while循环语句中“{ }”中的程序段至少要被执行一次。

do..while语句与while语句的- 个明显区别是do...while语句在结尾处多了一个分号(;)。根据do..while循环语句的语法特点总结出的do...while循环语句的执行流程，如图所示。

public class Cycle {//创建Cycle类
	public static void main(String[] args) {//主方法
		int a=100;//声明Int型变量a并赋初值100
		  while (a==60)//指定进入循环体条件
		  {
		    System.out.println("ok1");//while语句循环体
		    a--;//先使用后计算
		  }
		  int b=100;//声明int型变量b并赋初值100
		  do {//do...while语句循环体
		    System.out.println("ok2");//条件不成立时输出的信息
		   b--;//先使用后计算
		  } while(b==60);//指定循环结束条件
	}

}

3.3.3 while与do…while比较

可以通过设置起始循环条件不成立的循环语向来观察while和do...while的不同。将变量i初始值设置为0,然后循环表达式设置为i>1,显然循环条件不成立。循环体执行的是对变量j的加1运算，通过输出变量j在循环前的值和循环后的值进行比较。

public class DoWhileTest {//创建DoWhileTest类
	public static void main(String[] args) {//主方法
	int i=0,j=0;//定义i,j的值为0
	System.out.println("before do_while j="+j); //输出before do_while j的值
	do {//do语句
		j++;//先使用后计算
	}while (i>1);//条件表达式i>1
	System.out.println("after do_while j="+j);//输出after do while j的值
	}

}

public class WhlieTest {//创建WhlieTest类
	public static void main(String[] args) {//主方法
		int i=0,j=0;//定义int型变量 i=0,而j=0
		System.out.println("before while j="+j);//输出before while j的值
		while(i>1){//条件表达式i>1，while语句
			j++;//先使用后计算
		}
		System.out.println("after while j="+j);//输出after while j的值
	}
}

3.3.4 for循环语句

for循环是Java程序设计中最有用的循环语句之一。一个 for循环可以用来重复执行某条语句，直到某个条件得到满足。 for(表达式1;表达式2;表达式3) {
语句 }
表达式 1:该表达式通常是一个赋值表达式，负责设置循环的起
始值，也就是给控制循环的变量赋初值。
表达式 2:该表达式通常是一个关系表达式,用控制循环的变量和循环变量允许的范围值进行比较。
表达式 3:该表达式通常是一个赋值表达式，对控制循环的变量
进行增大或减小。
语句:语句仍然是复合语句。

for循环语句的执行流程如下:
(1)先执行表达式1。
(2)判断表达式2,若其值为真，则执行for语句中指定的内嵌语句，
然后执行(3)。若表达式2值为假，则结束循环，转到(5)。
(3)执行表达式3。
(4)返回(2)继续执行。
(5)循环结束，执行for语句下面的一个语句。

public class AdditiveFor {//创建AdditiveFor类
	public static void main(String[] args) {//主方法
		 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 语句在遍历数组等方面为程序员提供了很大的方便。

public class Repetition {//创建Repetition类
	public static void main(String[] args) {//主方法
		int arr[] = { 7,10, 1 }; //声明一维数组 
		  System.out.println("一维数组中的元素分别为:"); //输出信息
		  for (int x :arr){ //foreach语句，intx引用的变量arr指定要循环遍历的数组
		  System.out.println(x);//最后将x输出
		  }

	}

}

3.3.6 循环语句的嵌套

循环有for、while、 do...while 3种方式，这3种循环可以相互嵌套。

public class Multiplication {//创建Multiplication类
	public static void main(String[] args) {//主方法
	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");//输出i，j的值
		}
		System.out.println();//换行
	    }
	}
}

3.4 跳转语句

跳转语句包含两方面的内容，一方面是控制循环变量的变化方式，也就是让循环判断中的逻辑关系表达式变成false,从而达到终止循环的效果:一方面是控制循环的跳转。控制循环的跳转需要用到break和continue两个关键字，这两条跳转语句的跳转效果不同，break 是中断循环，continue是直接执行下一次循环。

3.4.1 break语句

使用break语句可以跳出switch结构。在循环结构中，同样也可用break语句跳出当前循环体，从而中断当前循环。

public class BreakTest {//创建BreakTest类
	public static void main(String[] args) {//主方法
		for(int i=1;i<20;i++) {//输出19行，赋值i
			if(i%2==0) {//如果i是偶数
				System.out.println(i);//输出i的值
				break;//跳到下一循环
			}
	}
		System.out.println("---end---");//输出---end---

   }
}

注意:如果遇到循环嵌套的情况，break语句将只会使流程跳出包含它的最内层的循环结构，只跳出一层循环。

public class BreakInsideNested {//创建BreakInsideNested类
	public static void main(String[] args) {//主方法
		for (int i = 0; i < 3; i++) { //在for循环前用标签标记
		    for (int j = 0; j < 6; j++) {//定义j的值，判断条件
		     if(j == 4) { //如果j等于4的时候就结束
		      break;//跳出循环
		      }
		   System.out.println("i=" + i + "j=" + j);// 输出i和j的值
		   }
		  }
	}

}

public class BreakOutsideNested {//创建BreakOutsideNested类
	public static void main(String[] args) {//主方法
		Loop:for(int i=0;i<3;i++){//在for循环前用标签标记
			   for (int j=0; j<6; j++) {//定义j的初值，判断条件
			   if(j==4){//如果j等于4的时候就结束外层循环
			    break Loop;//跳出Loop标签标记的循环体
			   }
			   System.out.println("i="+i+"j="+ j);// 输出i和j的值
			   }
			  }
	}

}

3.4.2 countinue语句

continue语句是针对break语句的补充。continue不是立即跳出循环体，而是跳过本次循环结束前的语句，回到循环的条件测试部分，重新开始执行循环。在for 循环语句中遇到continue语句后，首先执行循环的增量部分，然后进行条件测试。在while和do.... while循环中continue 语句使控制直接回到条件测试部分。

public class ContinueTest {//创建ContinueTest类
	public static void main(String[] args) {//主方法
		for (int i = 1; i< 20; i++) {//在for循环前用标签标记
			   if (i % 2 != 0) {  // 如果i不是偶数
			    continue;   // 跳到下一循环
			   }
			   System.out.println(i);  // 输出i的值
			  }
	}

}

注意：continue 语句和break语句的区别是: continue 语句只结束本次循环，而不是终止整个循环。而break语句是结束整个循环过程，开始执行循环之后的语句。

Slikc

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
第三章流程控制

目录3.1 程序结构3.2 条件语句3.2.1 if条件语句3.2.2 switch多分支语句3.3 循环语句3.3.1 while循环语句3.3.2 do…while循环语句3.3.3 while与do…while比较3.3.4 for循环语句3.3.5 foreach语句3.3.6 循环语句的嵌套3.4 挑战语句3.4.1 break语句3.4.2 countinue语句3.1 程序结构3.2 条件语句3.2.1 if条件语句3.2
复制链接

扫一扫