本帖最后由 ufof 于 2015-12-8 05:53 编辑



3.1 if和else


3.1.1 分支语句概述

一般来说，再编程当中，有三种基本结构：分别为顺序结构、分支结构，以及循环结构。顺序结构最容易理解的：先执行第一句话，然后执行下一句话。



这一章，我们会介绍分支结构和循环结构。分支结构最基本的控制方法就是if和else语句。

3.1.2 语法

单个if的用法如下所示：

  1. if(布尔类型){
  2.      //需要执行的语句
  3. }
复制代码

流程图如下：



if和else共同使用的用法如下所示：

  1. if(布尔类型){
  2.     //需要执行的语句
  3. }
  4. else{
  5.     //不然执行的语句
  6. }
复制代码

流程图如下：


if、else if的用法如下所示：
  1. if(布尔类型){
  2.     //需要执行的语句
  3. }
  4. else if(布尔类型){
  5.     //需要执行的语句
  6. }
  7. else if(布尔类型){
  8.     //需要执行的语句
  9. }
  10. ....若干个else if
  11. else{
  12.     //如果上面的布尔都不满足，执行这里面的语句
  13. }
复制代码

最后的else可有可不有。

流程图：


3.1.3 实例

写一个程序，需求判断一个数字是否为正数：

  1. class IfDemo{
  2.     public static void main(String[] args){
  3.         int num = 10;
  4.         if(num>0){
  5.             System.out.println("该数字为正数");
  6.         }
  7.         else{
  8.             System.out.println("该数字为负数或0");
  9.         }
  10.     }
  11. }
复制代码
结果：



在这个小程序中，使用了if和else判断语句，对int类型变量num判断num是否>10。由于比较运算符返回的是一个布尔，所以其可以直接放在if后面的括号中。

再写一个程序，要求判断成绩的等级：

  1. class IfDemo{
  2.     public static void main(String[] agrs){
  3.         int score = 85;
  4.         if(score==100){
  5.             System.out.println("A+");
  6.         }
  7.         else if(score>90){
  8.             System.out.println("A");
  9.         }
  10.         else if(score>80){
  11.             System.out.println("B");
  12.         }
  13.         else if(score>70){
  14.             System.out.println("C");
  15.         }
  16.         else if(score>60){
  17.             System.out.println("D");
  18.         }
  19.         else{
  20.             System.out.println("不及格");
  21.         }
  22.     }
  23. }
复制代码
结果：



这个程序使用了大量的else if语句。这个程序显得有一些臃肿和笨重。因此Java为我们提供了一种更好的分支结构语句，switch。我们下一章会讲到。

本章小结
  • 编程一共有三个结构：顺序结构、分支结构和循环结构
  • if可以单独使用，可以和else配合，也可以和else if配合使用




3.2 switch多分支语句


3.2.1 switch概述

在上一章的最后一个例子当中，我们用了大量的else if语句来对值得大小进行判断来进行输出。这种写法过得去，但是显得臃肿。因此，Java 7的更新当中，推出了一种新的多分支语句，叫做switch。

3.2.2 switch语法

switch的语法如下所示：
  1. switch (需要判断的变量){
  2.     case 值:
  3.         //执行语句
  4.         break;
  5.     case 值:
  6.         //执行语句
  7.         break;
  8.     //....若干个case
  9.     default:
  10.         //如果哪个值都不是执行的语句
  11. }
复制代码
switch中的值只可以是任意整数类型、char、字符串、以及枚举类型。
程序需求：输入数字，判断是一个星期里的哪天：

  1. class SwitchDemo{
  2.     public static void main(String[] args){
  3.         int week = 6;
  4.         
  5.         switch (week){
  6.             case 7:
  7.                 System.out.println("星期天");
  8.                 break;
  9.             case 1:
  10.                 System.out.println("星期一");
  11.                 break;
  12.             case 2:
  13.                 System.out.println("星期二");
  14.                 break;
  15.             case 3:
  16.                 System.out.println("星期三");
  17.                 break;
  18.             case 4:
  19.                 System.out.println("星期四");
  20.                 break;
  21.             case 5:
  22.                 System.out.println("星期五");
  23.                 break;
  24.             case 6:
  25.                 System.out.println("星期六");
  26.                 break;
  27.             default:
  28.                 System.out.println("请输入1~7之间的数字");
  29.         }
  30.     }
  31. }
复制代码
结果：



ps：break这个关键字是指从判断语句中跳出。

本章小结
  • switch是Java 7中新推出的一个多分支语句
  • switch用于对一个变量的不同的值执行不同的语句
  • 如果所有case都不满足，执行default下的语句





3.3 三目运算符


3.3.1 三目运算符概述

三目运算符是唯一一个有三个操作数的运算符。三目运算符用于先判断一个逻辑表达式是否为真，如果为真返回一个值；如果为假返回另外一个值。

三目运算符是一个运算符，所以一般需要赋给另外一个变量。

3.3.2 语法和应用

三目运算符语法如下：
  1. 逻辑表达式?若为真返回的值:若为假返回的值;
复制代码
流程图如下：

若为真返回的值以及若为假返回的值可以是一个字面量，也可以是一个运算。
编写一个程序，要求输入两个数，要用大的数减去小的数。

  1. class TernaryOperator{
  2.     public static void main(String[] args){
  3.         int num1 = 4;
  4.         int num2 = 7;
  5.         
  6.         int result = num1>num2?num1-num2:num2-num1;
  7.         /*
  8.         这个三目运算符的意义：
  9.         如果num1大于num2，返回num1-num2。
  10.         如果num1不大于num2，返回num2-num1（相反）。
  11.         */
  12.         System.out.println("result="+result);
  13.     }
  14. }
复制代码
结果：



在这个程序中的第六行，通过三目运算符先判断num1是否大于num2。在这个例子当中num1>num2为假，所以返回第二个值，也就是num2-num1。

本章小结
  • 三目运算符是Java中唯一使用三个操作数的运算符
  • 三目运算符先判断问号前的逻辑表达式，如果为真，返回第一个值；若为假返回第二个值
  • 两个值必须为字面量或一个运算




3.4 while和do while


3.4.1 循环结构概述

我们已经学习了顺序结构和分支结构。现在我们再来学最后一种结构：循环结构。
顾名思义，循环结构就是不断重复某一个动作，直到某一个条件被满足。Java为我们提供了while、for这两个循环语句。我们就先来学习while吧。

3.4.2 语法

while的语法如下：
  1. while(逻辑表达式){
  2.     //循环的语句
  3. }
复制代码

do while的语句如下：
  1. do{
  2.     //循环的语句
  3. }
  4. while(逻辑表达式);
复制代码

while的流程图如下：



简单来说，就是先判断是否满足逻辑表达式，然后执行语句。执行完之后再次来判断，直到不满足为止。

do while的流程图：



while和do while最大的区别就在于先判断还是先执行。while是先判断；而do while是先执行。

3.4.3 应用

编写一个程序，要求对这个数字自增十次，每自增一次打印一次自己的值。

  1. class WhileDemo{
  2.     public static void main(String[] agrs){
  3.         int count = 0;
  4.         while(count<10){
  5.             count++;
  6.             System.out.println("count="+count);
  7.         }
  8.     }
  9. }
复制代码
结果：



在这个小程序中，首先定义了一个叫做count的int，赋值0。在其小于10的情况下，一直自增并打印，所以就有了现在的结果。

不过大家一定要注意，一定要使循环可以结束，也就是说一定要对while后面的逻辑表达式中涉及到的变量进行改动。如果永远都能满足外面的表达式，那么就是一个死循环。

本章小结：
  • while和do while是一个循环语句
  • while先判断、do while先执行
  • 一定要让循环可以跳出



3.5 for


3.5.1 for循环概述

for循环是Java中最常用、最有用的循环。在上一章我们学习while循环的时候，对变量的初始化以及自增/自减都是手动完成的。for可以把初始化、循环判断、对变量的操作融为一体。所以说for循环更加简洁明了。

3.5.2 for语法

for的语法如下所示：
  1. for(表达式1;表达式2表达式3){
  2.     //循环执行的语句
  3. }
复制代码

表达式1用于声明一个变量并且赋值；表达式2是判断语句，是是否继续循环的依据，一般是在表达式1中声明的变量的比较运算；表达式3一般是对变量进行自增或自减的运算。

流程图如下：



我们引用上一章讲while的程序。就是初始化一个变量并赋值为0，在其小于10的情况下一直自增并打印。

  1. class ForDemo{
  2.     public static void main(String[] agrs){
  3.         for(int count = 0;count<=10;count++){
  4.             System.out.println("count="+count);
  5.         }
  6.     }
  7. }
复制代码
结果：



对于变量的声明和赋值、自增都已经在for中定义好了。这样的循环很容易使人明白。所以说for为什么如此常见。

本章小结
  • for是Java中最常用的循环语句
  • for中有三个表达式
  • 第一个表达式负责变量的初始化；第二个表达式负责循环的条件；第三个表达式负责对变量进行运算



3.6 break和continue


3.6.1 break、continue概述

假如说吃饭是一个循环结构，循环体是往嘴里放东西，判断条件是还有没有饭。不过现在我们遇到一个问题，我在饭吃完之前就已经饱了，如果再继续吃的话会吐。这里就涉及到在循环结束之前终止循环的问题。Java为我们提供break来强制跳出循环。

break是跳出整个循环。continue用于跳过本次循环，直接进入下一次循环。相信这不难理解。

3.6.2 具体实现方法

break和continue十分容易用。就是直接“break;”或者“continue;”。要注意这两个关键字一定要在循环体中使用。

  1. class BreakDemo{
  2.     public static void main(String[] args){
  3.         for(int num = 0;num<10;num++){    //循环
  4.             System.out.println("num="+num);
  5.             if(num==7){                                //如果num等于7
  6.                 break;                                     //跳出整个循环
  7.             }
  8.         }
  9.     }
  10. }
复制代码
结果：



在这个for循环当中，我嵌套了一个判断语句。如果num==7的话，跳出循环。从结果可以看出来，的确num为7时循环已经结束。

学生提问：我在循环体中嵌套了另一个循环体。在内部的循环体中break，会跳出两个循环体还是内部的循环体？

答：仅跳出内部循环体。

学生提问：那么我想要跳过特定的循环体怎么办？

答：可以对外部的循环体取一个标签，标签必须是一个标识符。break后面要紧跟着标签名。

  1. class LoopLabelDemo{
  2.     public static void main(String[] agrs){
  3.         outer: //定义标签
  4.         for(int x = 0;x<10;x++){
  5.             for(int y = 0;y<10;y++){
  6.                 if(y==5){
  7.                     break outer; //在break之后紧跟着标签名
  8.                 }
  9.                 System.out.println("Inner.."+y);
  10.             }
  11.         }
  12.     }
  13. }
复制代码
结果：



在这个程序中，仅打印了5次便终止了。这是因为在内部循环体循环5次之前，还没有满足y==5,。满足了之后，把外部的循环给终止了，所以仅仅打印了5次。

再来演示一下continue：

  1. class ContinueDemo{
  2.     public static void main(String[] agrs){
  3.         for(int num = 0;num<10;num++){
  4.             if(num%2==0){
  5.                 continue;
  6.             }
  7.             System.out.println("num="+num);
  8.         }
  9.     }
  10. }
复制代码
结果：



可以发现，打印的数字都是奇数。这是因为我在循环体中加入了一个判断语句，如果num取2的余数为0，也就是如果num为偶数，continue跳过本次循环。所以打印出来的数都是奇数。

本章小结：
  • break用于跳出整个循环；continue用于跳出本次循环
  • 可以对循环体加上标签，通过break (标签名);跳出对应标签的循环




3.7  无限循环


3.7.1  无限循环概述

Java并没有为我们提供专门的无限循环的循环结构。但是我们可以通过对之前的while和for进行一些小小的改动来实现无限循环。

无限循环照样可以被break和continue。

3.7.2 通过while实现

while是否接着循环取决于是否满足他的逻辑表达式。如果我们就给他写一个字面量true，每一次循环都可以满足这个条件，自然就是无限循环。

  1. class InfiniteLoopDemo{
  2.     public static void main(String[] args){
  3.         while(true){
  4.             //一些语句
  5.         }
  6.     }
  7. }
复制代码
每一次循环来判断是否满足条件，都是true，自然就是无限循环的。

3.7.3 通过for来实现

for中的第二个表达式就是是否接着循环的判据。可以像上面一样，也写一个字面量true，也可以实现无限循环。
还有另一种方法，第二个表达式可以什么都不写（但是分号得要有）：

  1. class InfiniteLoopDemo{
  2.     public static void main(String[] args){
  3.         for(int x=0;;x++){
  4.             //一些语句
  5.         }
  6.     }
  7. }
复制代码

甚至另外两个表达式也可以什么都不写：

  1. class InfiniteLoopDemo{
  2.     public static void main(String[] args){
  3.         for(;;){
  4.             //一些语句
  5.         }
  6.     }
  7. }
复制代码

都可以实现无限循环。

本章小结：
  • Java没有为我们提供专门的无限循环循环结构，但是可以通过对while和for的小小的变动来实现
  • 无限循环照样可以被break和continue
  • while后面的表达式若为字面量true，无限循环
  • for第二个表达式若为true，或什么都没有，无限循环

[groupid=546]Command Block Logic[/groupid]