JAVA 流程控制

本页面更新日期: 2016年06月16日

顺序结构

如果程序中没有流程控制, 就是自上而下的运行, 直到结束. 对吧? 嗯, 解释完毕.

分支结构

这个就有点意思了.
JAVA提供两种分支控制结构, if 和 switch 语句.

if 语句使用 布尔表达式 或 布尔值 作为分支条件来进行分支控制.
switch 语句用于对多个整型值进行匹配, 从而实现分支控制.

if 条件语句

if语句有如下三种形式
第一种:

if (logic expression)
{
    statement...
}

第二种:

if (logic expression)
{
    statement...
}
else
{
    statement...
}

第三种:

if (logic expression)
{
    statement...
}
else if (logic expression)
{
    statement...
}
...// 之后还可以根据需要 加多个 else if 进行判断
else //结尾的 else 根据情况 可加 可不加 如果判断一定要有结果的话 就加.
{
    statement...
}

在上面的 if 的三种形式中, if 之后的括号里 只能是一个逻辑表达式, 即这个表达式的返回值 只能是 true 或 false.

在上面的代码中, if (logic expression) else if (logic expression) 和 else 后, 花括号 {} 括起来的多行代码被称为 代码块.
一个代码块通常被当作一个整体来执行 (除非运行过程中遇到 return , break, continue 等关键字, 或者遇到了异常), 因此这个代码块也被称为条件执行体.
例如下面代码

public class IfTest
{
  public static void main(String[] args)
  {
    int age = 30;
    if (age > 20)  //只有当 age > 20时, 下面花括号 括起来的代码块才会执行
    {
      System.out.println("年龄已经大于20岁了");
      System.out.println("哎...光阴这把杀猪刀, 惨惨惨....");
    }
  }
}

switch 分支语句

switch 语句由 一个控制表达式 和 多个 case 标签组成, 和 if 语句不同的是 , switch 的控制表达式里的数据类型不能是 布尔类型. 可以是 byte,short,char,int 整数类型和枚举类型和String类型.
switch 语句往往需要在 case 标签后紧跟一个代码块, case 标签作为这个代码块的标识. 语法格式如下:

switch (expression)
{
    case condition1:
        statement...
        break;
    case condition2:
        statement...
        break;
    ... //可以通过上面的例子 联想后面
        //最后的最后
    default:
        statement...;
}

switch 分支语句执行顺序是, 先对 expression 求值, 然后依次匹配 condition1 , condition2 ….. 等值, 遇到匹配的值即执行对应的代码块; 如果所有 case 标签后的值 都不与 expression 表达式的值相等, 则执行 default 标签后的代码块.

下面我们写个代码试试看

public class SwitchTest
{
  public static void main(String[] args)
  {
    //声明变量 score , 并为其赋值 'C'
    char score = 'C';
    //执行 switch 分支语句
    switch (score)
    {
      case 'A':
        System.out.println("优秀");
        break;
      case 'B':
        System.out.println("良好");
        break;
      case 'C':
        System.out.println("差");
        break;
      default:
        System.out.println("成绩输入错误");
    }
  }
}

运行结果符合逻辑, 不知道你注意没, 在 case 标签后的每个代码块的最后都有一条 break; 这个 break; 语句非常重要. 为什么这么说? 你试试把上面例子里的 break; 语句都去掉, 保存后重新编译 运行试试看. 肯定逻辑就不通了.

break 的中文意思就是 中断. 让我们想想, 也就是找到了符合条件的, 执行完里面的代码块就可以中断了. 想想也是对吧? 这样才符合逻辑嘛 嘿嘿嘿.

循环结构

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

while 循环语句

while 循环的语法格式如下:

[init_statement]
while(test_expression)
{
    statement;
    [iteration_statement]
}

while 循环每次执行循环体之前, 先对 test_expression 循环条件求值, 如果循环条件为 true, 则运行循环体部分. 如果 test_expression 一开始就为 false . 则 花括号内的{} 循环体一次也不会执行.

让我们写个简单的 while 循环案例.

public class WhileTest
{
  public static void main(String[] args)
  {
    //循环的初始化条件
    int count = 0;
    //当 count 小于 10 时, 执行循环体
    while (count < 10)
    {
      System.out.println(count);
      //迭代语句
      count++;
    }
    System.out.println("循环结束!");
  }
}

其中 迭代语句 很重要, 如果没有它, count < 10 的条件将永远为 true . 那就是死循环. 就逗逼了.

do while 循环语句

do while 循环与 while 循环的区别在于:
while 循环是先判断循环条件, 如果条件为真则执行循环体.
do while 循环则是先执行循环体, 然后才判断循环条件, 如果循环条件为真, 则执行下一次循环, 否则终止循环.
你看, 它俩还是有区别的, 存在即合理 对吧. 以后面对不同的场景, 肯定有它的意义.

do while 循环的语法格式如下:

[init_statement]
do
{
    statement;
    [iteration_statement]
}while (test_expression);

让我们试试写一个例子

public class DoWhileTest
{
  public static void main(String[] args)
  {
    //定义变量 count
    int count = 20;
    //执行 do while 循环
    do
    {

        System.out.println(count);
        //迭代语句
        count++;

    } while (count < 10);
    System.out.println("循环结束!");
  }
}

从上面的例子就可以看出, 即使 test_expression 循环条件一开始就是 false .
do while 也会执行循环体一次. 屌不屌 -,-

for循环

for 循环是更加简洁的循环语句.
大部分情况下, for 循环可以代替 while 循环, do while 循环.
for 循环的语法格式:

for ([init_statement]; [test_expression]; [iteration_statement])
{
    statement;
}

for 循环时, 先执行 循环的初始化语句 init_statement, 初始化语句只执行一次.
在执行循环体之前, 计算 test_expression 循环条件的值, 如果循环条件返回 true , 则开始执行循环体.
循环体执行结束后 执行循环迭代语句 iteration_statement .

写个例子试试看

public class ForTest
{
  public static void main(String[] args)
  {
    //循环的初始化条件 / 循环条件 / 循环迭代语句 都在下面一行
    for (int count = 0; count < 10; count++)
    {
      System.out.println(count);
    }
    System.out.println("循环结束!");
  }
}

在上面的例子中, for 循环初始化语句只有一个, 循环条件也只有一个.
实际上 for 循环允许同时指定多个初始化语句, 循环条件也可以是一个 包含逻辑运算符 的表达式.

写个例子试试.

public class ForTest2
{
  public static void main(String[] args)
  {
    //同时定义 三个 初始化变量, 使用 && 来组合多个表达式
    for (int b = 0, s = 0, p = 0;
         b < 10 && s < 4 && p < 10;
         p++)
         {
           System.out.println(b++);
           System.out.println(++s + p);
         }
  }
}

这个例子并不复杂, 对于输出的结果你可能刚开始有点懵逼. 但是你要静下心来, 用脑子想想这里面到底发生了什么. 给你个提示 ++ 在前和在后是有区别的.

上面代码中初始化变量有3个, 但是只能有一个声明语句. (b, s, p 都是int 对吧?)
因此, 如果在初始化表达式中声明多个变量, 那么这些变量都具有相同的数据类型.

控制循环结构

有时候你可能需要循环在得到自己想要的结果后就结束.
或者跳过自己不想要的循环结果.
java 提供给你 continue 和 break 来做这种事情.
还有一个 return 更牛逼一点, 它可以结束整个方法. 自然方法内的循环也会被结束.

使用 break 结束循环

让我们直接举栗说明

public class BreakTest
{
  public static void main(String[] args)
  {
    //写一个简单的 for 循环
    for (int i = 0; i < 10; i++)
    {
      System.out.println("i 的值是:" + i);
      if (i == 2)
      {
        //如果满足 i == 2 结束循环
        break;
      }
    }
  }
}

在上面的例子中, 当 i 等于 2 时, 循环体内执行了 break 语句, 该循环结束.

使用 continue 忽略本次循环, 开始下一次

continue 并不会像 break 那样终止循环, 而是跳过一次, 接着干.
举栗说明

public class ContinueTest
{
  public static void main(String[] args)
  {
    //一个简单的 for 循环
    for (int i = 0; i < 3; i++)
    {
      System.out.println("i 的值是:" + i);
      if(i == 1)
      {
        //忽略本次循环 !剩下语句!
        continue;
      }
      System.out.println("我是一个小尾巴");
    }
  }
}

从上面程序的结果来看, 当 i 等于1 时. 没有输出那个小尾巴.
因为程序执行到 continue 时, 忽略了当次循环中 continue 后面的代码.

可能你对于这个家伙的用法还不太熟, 不过没关系, 经常用用就熟了.

使用 return 结束方法

return 关键字并不是专门用于结束循环的.
return 的功能是结束一个方法.
循环在方法内, 自然也被一起干掉.
举栗说明

public class ReturnTest
{
  public static void main(String[] args)
  {
    //一个简单的 for 循环
    for (int i = 0; i < 3; i++)
    {
      System.out.println("i的值是:" + i);
      if(i == 1)
      {
        return;
      }
      System.out.println("我是小尾巴");
    }
  }
}

当程序运行到 return 时, 方法就被结束了. 自然尾巴啥的都没有了.

结尾

如果你想学习更多JAVA知识, 可以 点我进入目录页