Java编程基础-选择和循环语句

一、选择结构语句

选择结构：也被称为分支结构。选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。

Java语言提供了两种选择结构语句：if语句和switch语句

1、if语句

if语句有三种语法格式。

(1)、if语句第一种语法格式(适合一种判断)

if(条件表达式){

语句体;

}

执行流程：判断条件表达式的结果，当为为true时,{}中的执行语句体才会执行,否则不执行语句体。


注意：

条件表达式的结果必须是布尔类型；if如果控制的语句只有一条，可以不写中括号{},直接跟语句体，但如果跟多条语句，大括号不能省略，建议两种情况下都写。

代码示例演示：

 

[java] view plain copy
  1. //if语句第一种语法格式  
  2.         int i=6;  
  3.         if(i%2==0){  
  4.             System.out.println("if条件为true");  
  5.         }  
  6.         System.out.println("over");  

输出结果为：

if条件为true
over

(2)、if语句第二种语法格式(适合两种判断)

if(条件表达式){

语句体1;

}else{

语句体2;

}

执行流程：同样先判断条件表达式的结果，如果为true，则执行语句体1，为false则执行语句体2.

代码示例演示：

 

[java] view plain copy
  1. //if语句第二种语法格式  
  2.         int j=-2;  
  3.         if(j>0){  
  4.             System.out.println(j+"为正数");  
  5.         }else{  
  6.             System.out.println(j+"为负数");  
  7.         }  
  8.         System.out.println("over");  

输出结果为：

-2为负数
over

(3)、if语句第三种语法格式(适合多种判断)

if(条件表达式1){

语句体1;

}else if(条件表达式2){

语句体2;

}

...

...

else if(条件表达式n){
语句体n;

}else{

语句体n+1;

}

执行流程：首先判断条件表达式1的结果，如果为true，则执行语句体1，为false则继续判断条件表达式2的结果，如果为true，则执行语句体2，为false则继续判断下一个条件表达式的结果，以此类推，如果所有的判断条件都为false，则意味着所有的条件均未得到满足，则执行语句体n+1。


代码示例演示：

 

[java] view plain copy
  1. // if语句第三种语法格式  
  2.         int scores = 88;  
  3.         if (scores >= 90) {  
  4.             System.out.println("您的成绩被评定为A级");  
  5.         } else if (scores >= 80) {  
  6.             System.out.println("您的成绩被评定为B级");  
  7.         } else if (scores >= 70) {  
  8.             System.out.println("您的成绩被评定为C级");  
  9.         } else if (scores >= 60) {  
  10.             System.out.println("您的成绩被评定为D级");  
  11.         } else if (scores >= 0) {  
  12.             System.out.println("您的成绩被评定为E级");  
  13.         } else {  
  14.             System.out.println("成绩输入有误!!!");  
  15.         }  

输出结果为：

您的成绩被评定为B级


2、switch语句

switch语句的语法格式：

switch(表达式){

case 目标值1:

 执行语句1;

 break;

case 目标值2:

 执行语句2;

 break;

......

......

 

case 目标值n:

 执行语句n;

 break;

default:

 执行语句n+1;

 break;

}

执行流程：switch语句将表达式的值与每个case中的目标值进行匹配，如果找到了匹配的值，会执行对应的case后的语句，遇到break就会结束。如果没找到任何匹配的值，就会执行default后的语句，然后程序结束。


注意：

(1)、表达式接收的值类型：在switch语句中的表达式只能是byte、short、char、int类型的值，如果传入其他类型的值，程序就会报错。(JDK5.0引入enum枚举和JDK7.0接收String类型)。

(2)、case后面跟的是要和表达式进行比较的值，语句体部分可以是一条或多条语句，break表示中断，结束的意思，可以结束switch语句，default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。default可以省略，但一般不建议，default可以放在switch语句的任何位置，一般放在最后位置，放在最后位置时紧跟它的break可以省略。

(3)、switch结束的情况：当程序执行过程中遇到了break；当程序执行到了末尾处。

代码示例演示：

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         int month = 12;  
  5.         switch (month) {  
  6.         case 1:  
  7.         case 3:  
  8.         case 5:  
  9.         case 7:  
  10.         case 8:  
  11.         case 10:  
  12.         case 12:  
  13.             System.out.println(month + "月有31天！");  
  14.             break;  
  15.         case 2:  
  16.             System.out.println(month + "月有28天！");//这里暂不考虑闰年情况  
  17.             break;  
  18.         case 4:  
  19.         case 6:  
  20.         case 9:  
  21.         case 11:  
  22.             System.out.println(month + "月有30天！");  
  23.             break;  
  24.         default:  
  25.             System.out.println("不存在该月！");  
  26.             break;  
  27.         }  
  28.     }  
  29. }  

输出结果为：

12月有31天！

附：if和switch语句很像，那么在具体场景下如何合理选择使用哪种语句呢？

(1)、能用switch语句实现的都可以用if语句替换，并且if语句的条件表达式没有任何限制，但是switch语句条件表达式的类型只能是byte、short、int、char这四种类型，以及后加入的枚举和string，并且要注意break的使用。

(2)、 If语句一般用于分支语句比较少的结构，而switch用于分支较多的结构。

(3)、如果判断具体数值不多，而且符合byte、short、int、char这四种类型虽然两个语句都可以使用，但建议使用switch语句，因为效率稍高。其他情况，对区间判断，对结果为boolean型的判断，使用if，if的使用范围更广。

二、循环结构语句

循环结构:循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

1、for循环语句

for循环语句的基本语法格式：

for(初始化表达式;循环条件;操作表达式){

执行语句(循环体)

......
}

执行流程：

for(①;②;③){

           ④

}

第一步，执行①

第二步，执行②，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步。

第三步，执行④

第四步，执行③，然后重复执行第二步。

第五步，退出循环。


代码示例演示：

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         // 求1到100的和  
  5.         int sum = 0;  
  6.         for (int i = 1; i <= 100; i++) {  
  7.             sum += i;  
  8.         }  
  9.         System.out.println(sum);  
  10.     }  
  11. }  

运行结果为：

5050

简单分析：要求1到100的和，首先要对1到100之间进行遍历，还要定义一个变量记住相加的结果。所以，初始化int类型变量i等于1，从1开始遍历，i满足小于等于100，就执行循环体，即和sum相加，并把结果赋值给sum，然后i自增1，直到i大于100不满足条件，就跳出循环，打印结果。

2、while循环语句

while循环语句的基本语法格式：

while(循环条件){
执行语句

}

while语句会反复的进行条件判断，只要条件成立，{}内的执行语句就会被执行，直到条件不成立，while循环结束。

流程图和for循环流程图一样。

代码示例演示：

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         // 求1到100的和  
  5.         int i = 1, sum = 0;  
  6.         while (i <= 100) {  
  7.             sum += i;  
  8.             i++;  
  9.         }  
  10.         System.out.println(sum);  
  11.     }  
  12. }  

运行结果为：

5050

注意：要注意控制循环条件，避免陷入死循环。

无限循环的最简单表达形式:while(true){}


3、do...while循环语句

do...while循环语句的基本语法格式：

do{

执行语句

}

while(循环条件);

关键字do后面{}中的执行语句是循环体。do while循环语句将循环条件放在了循环体的后面。这也就意味着，循环体会无条件执行一次，然后再根据循环条件决定是否继续执行。


代码示例演示：

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         // 求1到100的和  
  5.         int i = 1, sum = 0;  
  6.         do {  
  7.             sum += i;  
  8.             i++;  
  9.         } while (i <= 100);  
  10.         System.out.println(sum);  
  11.     }  
  12. }  

运行结果为：

5050


for循环、while循环和do...while循环的区别？

(1)、while和for首先要判断循环条件，满足条件才执行循环体，否则不执行循环体。do..while先执行循环体，无论条件是否满足，都至少执行一次循环体。(do...while实际中用的较少)

(2)、for循环一般用于循环次数确定的，while,do..while用于循环次数不确定的。

(3)、for循环和while循环再多数情况下可以等价转换，但还是有一点小区别的for循环结束，控制循环的变量会在内存中消失，提高内存的使用效率，而while循环结束，该变量则继续存在，不会被回收。如果循环后面的代码涉及到了该变量的使用，可以考虑使用while循环。


4、循环嵌套

循环嵌套是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do..while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套，如最常见的在for循环中嵌套for循环。语法格式如下：

              for(初始化表达式;循环条件;操作表达式){

                            ……

                            for(初始化表达式;循环条件;操作表达式){

                            执行语句

                            ……

                     }

                     ……

              }

代码示例演示：

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         // 打印如下图形  
  5.         // 使用嵌套循环，通俗的讲就是大圈套小圈。  
  6.         // *  
  7.         // **  
  8.         // ***  
  9.         // ****  
  10.         // *****  
  11.         // 尖朝上，可以改变条件，让条件随着外循环变化。  
  12.         for (int i = 1; i <= 5; i++) {//外循环控制行  
  13.             for (int j = 1; j <= i; j++) {//内循环控制每一行的列(个)数  
  14.                 System.out.print("*");  
  15.             }  
  16.             System.out.println();// 只有一个功能就是换行。  
  17.         }  
  18.   
  19.         // *****  
  20.         // ****  
  21.         // ***  
  22.         // **  
  23.         // *  
  24.         // 尖朝下，可以初始化值，让初始化值随着外循环变化。  
  25.         for (int i = 0; i < 5; i++) {  
  26.             for (int j = i; j < 5; j++) {  
  27.                 System.out.print("*");  
  28.             }  
  29.             System.out.println();// 只有一个功能就是换行。  
  30.         }  
  31.     }  
  32. }  


5、跳转语句

跳转语句用于实现循环执行过程中程序流程的跳转，在java中的跳转语句有break语句和continue语句。

(1)、break语句

在switch条件语句和循环语句中都可以使用break语句。

当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。

当它出现在循环语句中，作用是跳出循环语句，执行后面的代码。

(2)、continue语句

continue语句只能用在循环语句中，它的作用是终止本次循环，执行下一次循环。在while 和 do while语句中continue语句跳转到循环条件处开始继续执行，而在for语句中continue语句跳转到迭代语句处开始继续执行。

注意：

break和continue单独存在时，下面不可以有任何语句，因为执行不到。

这两个语句离开应用范围，存在是没有意义的。

break和continue都只对它所在的那层循环作用。

标签的出现，可以让这两个语句作用于指定范围。

代码示例演示：

 

[java] view plain copy
    1. public class Demo {  
    2.   
    3.     public static void main(String[] args) {  
    4.         // 普通跳出循环  
    5.         for (int i = 1; i <= 10; i++) {  
    6.             if (i == 5) {// 当i=5就跳出循环  
    7.                 break;  
    8.             }  
    9.             System.out.println("i=" + i);  
    10.         }  
    11.         // 输出结果为  
    12.         // i=1  
    13.         // i=2  
    14.         // i=3  
    15.         // i=4  
    16.         // 如果要跳出指定的循环，可以使用语法提供的标签语句来标识循环的位置，然后跳出标签对应的循环。  
    17.         w: for (int x = 0; x < 3; x++)// w表示外层循环标记  
    18.         {  
    19.             for (int y = 0; y < 4; y++) {  
    20.                 System.out.println("x=" + x);  
    21.                 break w;// break跳出当前循环，加w标记表明跳出外循环  
    22.             }  
    23.         }  
    24.         // 输出结果为  
    25.         // x=0  
    26.         // continue演示  
    27.         // 求1到10之间的偶数  
    28.         for (int x = 1; x <= 10; x++) {  
    29.             if (x % 2 == 1) {// 不是偶数  
    30.                 continue;// 结束本次循环，继续下一次循环  
    31.             }  
    32.             System.out.println("x=" + x);// 满足偶数的数该句代码不会执行，直接进入下一次循环  
    33.         }  
    34.         // 输出结果为  
    35.         // x=2  
    36.         // x=4  
    37.         // x=6  
    38.         // x=8  
    39.         // x=10  
    40.   
    41.     }  
    42. } 
posted @ 2017-02-20 10:51  stsinghua  阅读(8423)  评论(0)  编辑  收藏  举报