判断与循环语句

本章目标
掌握程序的三种结构
掌握选择语句的使用
掌握循环语句的使用
掌握break、continue关键字的使用

 

程序的结构
一般来说程序的结构包含有下面三种：
1、顺序结构
2、选择结构
3、循环结构

 

顺序结构
程序至上而下逐行执行，一条语句执行完之后继续执行下一条语句，一直到程序的末尾

 

选择结构
选择结构是根据条件的成立与否，再决定要执行哪些语句的一种结构

 

验证选择结构

public class IfDemo {
	public static void main(String[] args) {
		int x = 3;//定义整型变量 x
		int y = 10;//定义整型变量 y
		System.out.println("====== 比较开始 ======");//输出信息
		if(x>y){//判断 x 是否比 y 大
			System.out.println("x 比 y 大！");//输出信息
		}
		if(x<y){//判断 x 是否比 y 小
			System.out.println("x 比 y 小！");//输出信息
		}
		System.out.println("====== 比较结束 ======");//输出信息
	}
/*结果：
 * ====== 比较开始 ======
 * x 比 y 小！
 * ====== 比较结束 ======
 * */
}

 

循环结构
循环结构则是根据判断条件的成立与否，决定程序段落的执行次数，而这个程序段落就称为循环主体。

 

if语句
在前面简单地介绍了if的用法。要根据判断的结构来执行不同的语句时，使用if 语句就是一个很好的选择，它会准确地检测判断条件成立与否，再决定是否要执行后面的语句。
if (判断条件){
  语句1 ；
  …
  语句2 ；
  }

 

if...else语句
当程序中存在含有分支的判断语句时，就可以用if...else语句处理。当判断条件成立，即执行if语句主体；判断条件不成立时，则会执行else后面的语句主体。if…else语句的格式如下：
if (判断条件){
  语句主体1 ；
  }else{
  语句主体2；
  }

 

通过if..else语句，判断一个数字是奇数还是偶数

public class IfElseDemo {
	public static void main(String[] args) {
		int x=3;//定义整型变量 x
		if(x % 2 ==1){//判断余数是否为 1 
			System.out.println("x 是奇数！");//如果余数为 1 表示奇数
		}else{
			System.out.println("y 是偶数！");//如果余数为 0 表示偶数
		}
	}
/*结果：
 * x 是奇数！
 * */
}

 

三目运算符

 

使用三目运算符求出两个数字中的最大值

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 (条件判断1){
  语句主体1 ；
  }else if (条件判断2){
  语句主体 2 ；
  }
  …  // 多个else if()语句
  else{
  语句主体3 ；
  }

 

使用语句

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！
 * */
}

 

switch语句
要在许多的选择条件中找到并执行其中一个符合判断条件的语句时，除了可以使用if..else不断地判断之外，也可以使用另一种更方便的方式即多重选择——switch语句，语法格式：
switch (表达式){
  case 选择值1 ：  语句主体 1 ；          break ；
  case 选择值2 ：  语句主体 2 ；                   break ；
  …….
  case 选择值n ：  语句主体 n ；                  break ；  default：    语句主体 ；
  }

执行流程

 

while循环
while是循环语句，也是条件判断语句。当事先不知道循环该执行多少次的时，就要用到while循环。while循环的格式如下：
while (循环条件判断){
  语句1 ;
  语句2 ;
  …
  语句n ;
  循环条件更改 ;
  }

 

使用while循环，进行累加操作

public class WhileDemo {
	public static void main(String[] args) {
		int x=1;//定义整型变量 x
		int sum = 0;//定义整型变量 sum,保存累加结果
		while(x <= 10){//判断循环条件
			sum += x;//执行累加操作
			x++;//修改循环条件
		}
		System.out.println("1 --> 10 累加结果为："+sum);//输出结果
	}
/*结果：
 * 1 --> 10 累加结果为：55
 * */
}

 

do…while循环
do…while循环也是用于未知循环执行次数的时候，而while循环及do…while循环最大不同就是进入while循环前，while语句会先测试判断条件的真假，再决定是否执行循环主体，而do…while循环则是“先做再说”，每次都是先执行一次循环主体，然后再测试判断条件的真假，所以无论循环成立的条件是什么，使用do…while循环时，至少都会执行一次循环主体，语句格式：
do{
  语句1 ;
  语句2 ;
  ….
  语句n ;
  循环条件改变 ;
  }while (循环条件判断);

 

使用do…while循环完成之前的累加操作

public class DoWhileDemo {
	public static void main(String[] args) {
		int x=1;//定义整型变量 x
		int sum = 0;//定义整型变量 sum,保存累加结果
		do{//do .... while 至少先执行一次
			sum += x;//执行累加操作
			x++;//修改循环条件
		}while(x <= 10);//判断循环
		System.out.println("1 --> 10 累加结果为："+sum);//输出结果
	}
/*结果：
 * 1 --> 10 累加结果为：55
 * */
}

 

for循环
对于while和do…while两种循环来讲，操作时并不一定非要明确的知道循环的次数，而如果开发者已经明确的知道了循环次数的话，那么就可以使用另外一种循环语句——for循环。 格式如下：
for (赋值初值；判断条件；赋值增减量){
  语句1 ；
  ….
  语句n ；
  }

 

使用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
 * */
}

 

循环的嵌套

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");
		}
	}
/*结果：
 * 1*1=1	
 * 2*1=2	2*2=4	
 * 3*1=3	3*2=6	3*3=9	
 * 4*1=4	4*2=8	4*3=12	4*4=16	
 * 5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
 * 6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36	
 * 7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49	
 * 8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64	
 * 9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81	
 * */
}

 

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
 * */
}

 

continue语句
continue语句可以强迫程序跳到循环的起始处，当程序运行到continue语句时，即会停止运行剩余的循环主体，而是回到循环的开始处继续运行。以下图的for循环为例，在循环主体中有continue语句，当程序执行到continue，即会回到循环的起点，继续执行循环主体的部分语句。

 

continue语句格式
for (初值赋值；判断条件；设增减量)
{
  语句1 ；
  语句2 ；
  …
  continue
  …  // 若执行continue语句，则此处将不会被执行
  语句n；
}
  ….

 

将之前的程序修改为continue，观察运行结果

public 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 = 0
 * i = 1
 * i = 2
 * i = 4
 * i = 5
 * i = 6
 * i = 7
 * i = 8
 * i = 9
 * */
}