day04--Java流程控制

今天主要学习如下内容
　　1. 顺序结构和选择结构，选择结构有两种实现方式if和switch，
　　2. 循环结构
　　3 .跳转控制语句

JAVA流程控制

• 一个Java程序，通常是由多条符合Java语法规则的语句组成的。
• 一个Java程序的执行，一定意味着多条Java语句的执行。
• 既然是多条Java语句的执行，执行的结果就一定与语句执行的顺序有关，同样的语句，不同的执行顺序，结果可能不同

因此我们需要知道，Java语言如何控制多条语句的执行顺序——通过流程控制(具体来说，是通过3种结构)

 

1.顺序结构

package com.controlflow.sequential;

/** 6  *
 *  顺序结构：描述的是Java语句之间，从上到下(或从左到右)依次执行的执行顺序
 *
 *  顺序结构是程序中最简单最基本的流程控制，没有特定的语法，就是按照代码书写的顺序执行。

    对于顺序结构而言，写在前面的代码先执行，写在后面的代码后执行
 */
public class Demo {

  public static void main(String[] args) {
    int i = 1;
    int b = 2;
  }

}

顺序结构的流程图

 2.选择结构

　　选择结构中的代码顺序和顺序结构中代码的执行顺序有明显的不同：

• 选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断。
• 逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。
• Java中，选择结构有2种实现形式，if语句 和switch语句

if语句实现选择结构有3种格式

回忆一下，之前我们所讲解的三元运算符，和if语句的第二种格式所表达的语义是否很相似呢？

if语句第二种格式和三元运算符既然如此相似，是否它们是完全等价的呢？

• 三元运算符的操作都可以使用if语句改进，反之不成立
• 什么时候不成立呢？

 

 

package com.cskaoyan.controlflow.select;

import java.util.Scanner;

/** 15 
    if实现选择结构：
    1. 单分支的选择结构： 如果..就
    // 判断提条件的结果只能是true or false
    if(判断条件) {
      //语句体
    }
    判断条件是由一个 关系表达式 来表示的

    2. 双分支：如果..就。。，否则。。。
    if (判断条件) {

    } else {

    }

    3. 多分支(各个分支，平行，互斥)
    if(判断条件1) {
        条件1语句体
     } else if (条件2) {
        条件2语句体
     }
     ...
     else if (条件n) {

     } else {
       // 第n + 1种情况
      //当else前都不满足条件的时候，就会执行else中的语句体
     }

     在绝大部分场景下，三目运算符和if双分支选择结构，都可以相互替代，
     但是，如果选择结构执行的仅仅只是一个操作，没有返回值，此时if双分支选择结构不可以和三目运算相互替代
 */
public class Deomo1Select {

  public static void main(String[] args) {

    Scanner scanner = new Scanner(System.in);

    int input = scanner.nextInt();

    //单分支的if 当用户输入的是正数就输出一下，否则什么都不做
    //if (input > 0) {
    //  //如果是正数
    //  System.out.println("亲, 您输入了一个整数" + input);
    //}


    //双分支  当用户输入正数的时候输出一下用户输入的正数，当用户输入了非正数提示一下，请用户输入正数
    //if (input > 0) {
    //  //如果输入的是正数
    //  System.out.println("亲, 您输入了一个整数" + input);
    //} else {
    //  System.out.println("亲，请重新输入一个正数");
    //}

    //多分支 当用户输入正数，0，负数
    //if (input > 0) {
    //  //正数
    //  System.out.println("亲, 您输入了一个整数" + input);
    //} else if (input == 0) {
    //  //0
    //  System.out.println("亲, 您输入了一个0");
    //} else {
    //  //负数
    //  System.out.println("亲，请重新输入一个数字");
    //}

    //关于双分支的if选择结构
    // 实现两数取大
    int a = 3;
    int b = 10;
    int max;
    if (a > b) {
      max = a;
    } else {
      max = b;
    }

    //可以用三目运算符来实现两数取大
    max = a > b ? a : b;

    //我们发现3目运算符的语义和if双支选择结构，语义几乎完全相同，
    // 都是非此即彼，但是至少有一种情况，它们不能相互替代
    if (a > b) {
      System.out.println("大者是" + a);
    } else {
      System.out.println("大者是" + b);
    }

    //三目运算符的结果一定是一个值
    //a > b ? System.out.println("大者是" + a) : System.out.println("大者是" + b);


  }

}

练习：

• 键盘录入x的值，计算出y的并输出。
• 键盘录入月份的值，输出对应的季节。获取三个数据中的最大值

package com.controlflow.select;

import java.util.Scanner;

/** 9  * 练习：
    1.键盘录入x的值，计算出y的并输出。
    x和y的关系满足如下：
    x>=3       y = 2x + 1;
    -1<=x<3      y = 2x;
    x<=-1      y = 2x – 1;

    2.键盘录入月份的值，输出对应的季节。
      12 1 2 冬季
      3  4 5 春季
      6 7 8  夏季
      9 10 11 秋季
    3.获取三个数据中的最大值
 */
public class ExerciseIf {

  public static void main(String[] args) {
    //1.键盘录入x的值，计算出y的并输出。
    //Scanner scanner = new Scanner(System.in);
    //int x = scanner.nextInt();
    //int y;
    //if ( x >= 3) {
    //  y = 2 * x + 1;
    //} else if (x >= -1 && x < 3) {
    //  y = 2 * x;
    //} else {
    //  // x <= -1
    //  y = 2 * x - 1;
    //}
    //System.out.println("x = " + x + "---- y = " + y);


    //2.键盘录入月份的值，输出对应的季节。
    //if (x == 12 || x == 1 || x == 2) {
    //  //冬季
    //  System.out.println("冬季");
    //} else if ( x >= 3 && x <= 5) {
    //  //春季
    //  System.out.println("春季");
    //} else if ( x >= 6 && x <= 8 ) {
    //  //夏季
    //  System.out.println("夏季");
    //} else if ( x >= 9 && x <= 11) {
    //  //秋季
    //  System.out.println("秋季");
    //} else {
    //  //应对用户错误的输入
    //  System.out.println("亲，您输入了错误的月份");
    //}

    //3.获取三个数据中的最大值
    int a = 10;
    int b = 20;
    int c = 15;

    //if的嵌套来实现
    //if (a > b) {
    //  // a大
    //  if(a > c) {
    //    // a 最大
    //    System.out.println("最大值是： " + a);
    //  } else {
    //    // c最大
    //    System.out.println("最大值是 " + c);
    //  }
    //} else {
    //  // b大
    //  if (b > c) {
    //    System.out.println("最大值是： " + b);
    //  } else {
    //    System.out.println("最大值是： " + c);
    //  }
    //}

    //非嵌套方式
    int tmp;
    if ( a > b) {
      tmp = a;
    } else {
      tmp = b;
    }

    if (tmp > c) {
      System.out.println(tmp);
    } else {
      System.out.println(c);
    }

  }

}

switch语句格式：

switch(表达式) {

case 值1：

语句体1;

break;

case 值2：

语句体2;

break;

…

default：

语句体n+1;

break;

}

 

格式解释：

• switch关键字：表示这是一个switch语句
• switch后的表达式：表示选择条件
• case语句：每个case 语句表示一个分支
• beak语句：表示结束switch语句
• default语句：表示当所有其他的case的分支，都不能匹配
• switch后表达式的值的时候，此时就会执行default分支。

注意事项：

• switch语句后，表达式结果的取值范围？
• case 后的常量取值？
• break可以省略吗？
• default可以省略吗？
• switch语句的结束条件

package com.controlflow.select;

import java.util.Scanner;

/** 8  *
 * switch语句格式： switch(表达式) { case 值1： //这个值，代表的一个特定分支 语句体1; //满足条件的分支执行的语句体 break; case 值2： 语句体2;
 * break; … default： 语句体n+1; break; }
 *
 * 格式解释： switch关键字：表示这是一个switch语句 switch后的表达式：表示选择条件 表达式
 *
 * case语句：每个case 语句表示一个分支  类比于if所表示的一个分支 beak语句：表示结束 switch语句 default语句：表示当所有其他的case的分支，都不能匹配switch后表达式的值的时候，
 * 此时就会执行default分支。 有点类似于 if-else多分支中最后的else
 *
 * 注意事项：
 * 1. switch 表达式的结果类型 表达式的取值：byte, short, int, char JDK7以后可以是：String 字符串
 * 2. case 后的常量取值？case后面的值，不能相同，值必须得是常量值，必须和表达式值的类型相同
 *
 * 3. break可以省略吗？语法上可以省略，省略之后，switch实现的就不再是我们所期望的多分支选择结构了，会发生一个现象case穿越
 *    所谓的case穿越是指：当匹配到switch语句的某个分支，当该分支中不包含break语句，swtich语句不会自动结束，
 *                      紧接着执行，紧邻的下一个case的语句体，最终要么遇到别的分支中的break；结束，
 *                      要么匹配到最后一个case，结束switch语句
 * 4. default可以省略吗？
 *    语法上可以，一把建议不要省略，我们根据实际开发需要来决定
 *
 * 5. default分支，必须只能放在最后吗？
 * 语法上没有问题，default分支可以放在switch的任意位置，注意default分支，
 * 如果不在最后，如果不加break，仍然会发生case穿越现象
 *
 * 6.switch语句的结束条件
 */
public class Demo2Switch {

  public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);

    int i = sc.nextInt();

    switch (i) {

      default:
        System.out.println("您输入了非 0，1,2的值");
      case 0:
        System.out.println("您输入了0");
        break;
      case 1:
        System.out.println("您输入了1");
        break;
      case 2:
        System.out.println("您输入了2");
        break;


    }

  }


}

练习：

• 模拟做单项选择题，根据你的选择，给出对应的答案。(表达式是字符的情况)
• 键盘录入字符串，根据给定的字符串，来输出你选择的字符串是什么?(表达式是字符串的情况)
• 用switch语句实现键盘录入月份，输出对应的季节 看程序写结果

package com.controlflow.select;

import java.util.Scanner;

/**  8  *
 * 1.模拟做单项选择题，根据你的选择，给出对应的答案。(表达式是字符的情况) 2.键盘录入字符串，根据给定的字符串，来输出你选择的字符串是什么?(表达式是字符串的情况)
 * 3.用switch语句实现键盘录入月份，输出对应的季节 4.看程序写结果
 */
public class ExerciseSwitch {

  public static void main(String[] args) {

    //1.模拟做单项选择题，根据你的选择，给出对应的答案。
    //System.out.println("你的女神是？");
    //System.out.println("A.高圆圆");
    //System.out.println("B.云姐");
    //System.out.println("C.沈佳宜");
    //System.out.println("D.石原里美");

    Scanner sc = new Scanner(System.in);
    //String s = sc.nextLine();
    //char c = s.charAt(0);
    //
    //switch (c) {
    //  case 'A' :
    //    System.out.println("您的女神是：高圆圆");
    //    break;
    //  case 'B' :
    //    System.out.println("您的女神是：云姐");
    //    break;
    //  case 'C' :
    //    System.out.println("您的女神是：沈佳宜");
    //    break;
    //  case 'D' :
    //    System.out.println("您的女神是：石原里美");
    //    break;
    //}

    //2.键盘录入字符串，根据给定的字符串，来输出你选择的字符串是什么?(表达式是字符串的情况)

    //switch (s) {
    //  case "A" :
    //    System.out.println("您的女神是：高圆圆");
    //    break;
    //  case "B" :
    //    System.out.println("您的女神是：云姐");
    //    break;
    //  case "C" :
    //    System.out.println("您的女神是：沈佳宜");
    //    break;
    //  case "D" :
    //    System.out.println("您的女神是：石原里美");
    //    break;
    //}

    //3.用switch语句实现键盘录入月份，输出对应的季节 合理利用case穿越
    //int month = sc.nextInt();
    //switch (month) {
    //  case 12:
    //  case 1:
    //  case 2:
    //    System.out.println("冬季");
    //    break;
    //  case 3:
    //  case 4:
    //  case 5:
    //    System.out.println("春季");
    //    break;
    //  case 6:
    //  case 7:
    //  case 8:
    //    System.out.println("夏季");
    //    break;
    //  case 9:
    //  case 10:
    //  case 11:
    //    System.out.println("秋季");
    //    break;
    //  default:
    //    System.out.println("您输入了错误的月份");
    //}

    //4. 看代码，写结果
/*    int x = 2;
    int y = 3;
    switch(x){
      default:
        y++;
        break;
      case 3:
        y++;
      case 4:
        y++;
    }
    System.out.println("y="+y);*/


    int x = 2;
    int y = 3;
    switch(x){
      default:
        y++;
      case 3:
        y++;
      case 4:
        y++;
    }
    System.out.println("y="+y);


  }

}

　　选择结构有两种实现方式，这两种实现方式，各自适用于什么样的使用场景呢？

if的使用场景

• 针对结果是boolean类型的判断
• 分支对应多个表达式的多个取值

switch的使用场景

• 针对结果是固定类型的判断
• 表达式的取值范围只是固定的离散值集合，分支对应表达式的某一种取值

public class compare {

  public static void main(String[] args) {

    //分支对应多个表达式的多个取值
    int x = 0;
    int y = 100;

    if (x > 0) {
      // x > 0
    } else if (y < 10) {
      //  0=< y < 10 不对哈这里是我写错了哈
      // 应该是  x <=0 && y < 10哈，讲课的时候主要想着区别，疏忽了具体代码哈
    }

    switch (x) {
      case 0: //一个值对应一个分支
      break;

    }


  }

}

3.循环结构

在学习循环结构之前，我们首先来简单回顾顺序结构，选择结构中，Java语句的执行特点。

与顺序结构和选择结构不同，循环结构的主要功能是控制Java语句能够重复执行。

如何控制呢？

循环结构，从语法上来讲，有3种实现形式：

• • for语句
  • while语句
  • do while语句

但是，不管哪种实现形式，都由4部分组成：

• • 初始化语句
  • 条件判断语句
  • 循环体语句
  • 循环控制语句

　　接下来我们首先来分析下，循环结构如何通过，这4个组成部分，完成控制Java语句重复执行的功能。

 for 循环语句：

for(初始化语句;判断条件语句;控制条件语句) {

　　循环体语句;

}

执行流程：

注意事项：

• 判断条件语句的结果的数据类型
• 循环体语句

public class Demo1 {

  public static void main(String[] args) {

    int j;
    //hello 你好 输出10次
    //1.设定一个计数值：记录你喊了多少次 hello 你好, 而且该计数值的初值为0(初始化语句)
    //2. 开始重复喊 hello 你好(循环体语句)， 每喊一次 计数值会 + 1(循环体语句，改变循环变量，循环变量就是指喊的次数)
    //3. 喊hello 你好的计数值(喊的次数) 和 10 比较一下，当 计数值 > 10 结束(结束条件判断)
    System.out.println("hello 你好");
    System.out.println("hello 你好");
    System.out.println("hello 你好");
    System.out.println("hello 你好");
    System.out.println("hello 你好");
    System.out.println("hello 你好");
    System.out.println("hello 你好");
    System.out.println("hello 你好");
    System.out.println("hello 你好");
    System.out.println("hello 你好");

    // for 循环实现
    //for(初始化语句;判断条件语句;控制条件语句) {
    //  循环体语句;
    //}
    for(int i = 1; i <= 10; ++i) {
      System.out.println("hello 你好 --- " + i);
    }


    //在for循环中定义了变量i，它的作用域，仅仅只在for循环中
    //System.out.println(i);

  }

}

练习：

• 请在控制台输出数据1-10
• 请在控制台输出数据10-1
• 求出1-10之间数据之和
• 求出1-100之间偶数和
• 求5的阶乘 在控制台输出所有的”水仙花数”，统计”水仙花数”共有多少个

public class Exercise {

  public static void main(String[] args) {
    //请在控制台输出数据1-10   第一个数1  最后一个数10
    for (int i = 1; i <= 10 ; i++) {
      // print 和 println 的区别仅仅在于：println输出之后自动换行
      //System.out.print(i + " ");
    }

    //请在控制台输出数据10-1   第一个数10  最后一个数1
    for (int i = 10; i >= 1 ; --i) {
      //System.out.print(i + " ");
    }

    //求出1-10之间数据之和
    // 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
    // （1 + 2) + 3 +...
    //  （(（1 + 2） + 3) + 4) + 5
    // (（（0 + 1） + 2) + 3 + ... ）+10

    //初始和(累和变量)
    int acc = 0;
    for (int i = 1; i <= 10; i++) {
       acc += i;
    }
    //System.out.println(acc);

    //求出1-100之间偶数和
    acc = 0;
    for (int i = 1; i <= 100 ; i++) {
      if(i % 2 == 0) {
        //是偶数
        acc += i;
      }
    }
   // System.out.println(acc);

    //求5的阶乘
    // 1 5 * 4 * 3 * 2 * 1
    int multi = 1; //累积变量，初值为1
    for (int i = 5; i >= 1 ; i--) {
      multi *= i;
    }
   // System.out.println(multi);

    //在控制台输出所有的”水仙花数”
    // 1. 这样一个三位数[100 999]： 各位上的数字的立方和的值等于该数字本身
    int count = 0;
    for (int i = 100; i < 1000; i++) {
      //判断一个数字i，是否是水仙花数

      //数位拆解得到各位的数字
      //个位数字
      int m = i % 10;
      //十位数字
      int n = i / 10 % 10;
      //百位数字
      int b = i / 100;

      if (m * m * m + n * n * n + b * b * b == i) {
        //是水仙花数
        //System.out.println(i);
        count++;
      }
    }
    System.out.println(count);



  }

}

while循环语句格式：

　　 初始化语句；

　　 while (条件判断语句) {

　　　　循环体语句；

　　 }

执行流程： 

　　和for循环一模一样

• for循环和while循环的联系

for循环和while循环几乎可以在任何场景下，作等价替换

• for循环和while循环的区别

直观来说，for循环适合针对一个范围判断进行操作(循环次 数比较明确），for循环适合针对一个范围判断进行操作 (循环次数比较明确）

public class WhileDemo {

  public static void main(String[] args) {

    // 我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。
    // 请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?

    //初始化语句 纸张的初始化高度
    double height = 0.01;
    int count = 0;
    while (height < 8848) {
      height *= 2;
      count++;
    }
    System.out.println("次数是：" + count + "---- height " + height);


  }

}

do …while循环语句格式

初始化语句;

do {

　　循环体语句;

} while (条件判断)

执行流程： do while 循环结构与while循环结构比，略有不同

1. 执行初始化语句
2. 不管是否满足循环条件，都首先执行一次循环体中的代码
3. 之后的执行流程就和for while

public class DoWhileDemo {

  public static void main(String[] args) {

    //先执行循环体，在判断
    int i = 10;
    do {
      System.out.println(i);
      i++;
    } while (i > 11);

    //对比while循环，先判断在执行循环体
    i = 10;
    while ( i > 11) {
      System.out.println(i);
      i++;
    }


  }

}

3种循环结构的综合比较：

3种循环中，for循环和while循环等价

do … while循环与其他两种循环结构相比，略有不同，因为do…while结构可保证循环体至少执行一次

注意事项：

1. 实际使用时，只要达到预期的效果，用哪个都可以
2. 如非特殊情况，要注意不要规避死循环问题，如： for(;;) 或 while(true)，
3. 死循环并非不能使用(学习多线程时解释)

public class Compare {

  public static void main(String[] args) {

    for (;;){
      System.out.println("你好 dead loop");
    }

    //while(true)

  }

}

• 请输出一个4行5列的星星(*)图案。
• 请输出如下图形
• *
• **
• ***
• ****
• *****
• 在控制台输出九九乘法表。

package com.controlflow.recycle;

/**
 *
 *  1.请输出一个4行5列的星星(*)图案。
 *    *****
 *    *****
 *    *****
 *    *****
    2.请输出如下图形
     *
     **
     ***
     ****
     *****
    3.在控制台输出九九乘法表。

 */
public class Exercise {

  public static void main(String[] args) {
    //1.请输出一个4行5列的星星(*)图案。
    //重复输出5行*
    //for(int i = 0; i < 4; i++) {
    //
    //  //重复输出每一行的*
    //  for (int j = 0; j < 5; j++) {
    //    System.out.print("*");
    //  }
    //  //换行输出下一行
    //  System.out.println();
    //}
    //
    ////输出三角形的*
    //for (int i = 1; i <= 5; i++) {
    //
    //  //控制输出每一行的*
    //  for (int j = 1; j <= i; j++) {
    //    System.out.print("*");
    //  }
    //  System.out.println();
    //}

    //在控制台输出9x9乘法表
    // 1*1=1
    // 1*2=2  2*2=4
    // 1*3=3  2*3=6  3*3=9

    for (int i = 1; i <= 9 ; i++) {

      //控制每一行输出的表达式
      for (int j = 1; j <= i ; j++) {
        //内存循环中的每一次执行，输出的是一个表达式
        System.out.print(j + "x" + i + "=" + j * i + "  ");
      }
      //换行
      System.out.println();

    }
  }

}

补充：

package com.controlflow.recycle;

/**
 *
 * 有一种循环的写法, 针对数组的遍历： Colletcion
 * for(数据类型 变量名(标识符) : 数组名) {
 *
 * }
 *
 */
public class Supplement {

  public static void main(String[] args) {
    // 定义一个数组
    int[] array = {1, 2, 3, 4};

    //普通遍历
    for (int i = 0; i < 4; i++) {
      System.out.println(array[i]);
    }

    // 增强形式for循环
    //
    // 1, 2, 3, 4
    for (int element : array) {
      System.out.println(element);
    }

  }

}

4.跳转控制语句

　　通过学习循环控制语句，我们已经可以完成控制循环体中的Java代码，重复执行。

　　但是，循环结构的控制粒度是整个循环语句体，我们可不可以对循环体中的循环体语句，作更加精细的控制呢？ 比如，自己控制循环的结束等。

　　为了实现对循环结构更加细粒度的控制，我们得通过跳转控制

• • break 中断
  • continue 继续
  • return 返回

• break的使用场景：

1. 在选择结构的switch语句中
2. 在循环语句中（离开使用场景的存在是没有意义的）

• break的作用：

跳出（终止）单层循环（如果有多层循环，只跳出内层）

结束switch语句

• 带标签的跳出(多重循环)

格式：标签名: 循环语句

标签名要符合Java的命名规则

public class BreakDemo {

  public static void main(String[] args) {

    //break的基本功能，结束单重循环
    //for (int i = 1; i <= 10; i++) {
    //  // 输出到5
    //  System.out.println(i);
    //  if(i == 5) {
    //    break;
    //  }
    //}

    //离开使用场景的break
    //for (int i = 0; i < 10; i++) {
    //  System.out.println(i);
    //  break;
    //}

    for (int i = 0; i < 3; i++) {

      for (int j = 0; j < 3; j++) {
        if( j == 2) {
          break;
        }
        System.out.println("i = " + i + " -- " + "j = " + j);
      }
    }
    System.out.println("---------------------------------------");
    // 终止外层循环
    outer: //给外层循环定义了个标签(标识符)
    for (int i = 0; i < 3; i++) {
      for (int j = 0; j < 3; j++) {
        if( j == 2) {
          break outer;
        }
        System.out.println("i = " + i + " -- " + "j = " + j);
      }
    }
  }

}

• continue的使用场景：

1. 在循环语句中
2. 离开使用场景的存在是没有意义的，必须和if连用

• continue的作用：

退出循环的一次迭代过程

也可以使用标签

public class ContinueDemo {

  public static void main(String[] args) {

    for (int i = 1; i <= 10; i++) {
      if(i == 5) {
        //终止，单重循环的一次循环过程
        continue;
      }
      System.out.println(i);
    }

    //for (int i = 1; i <= 10; i++) {
    //  //continue 必须和if配合使用
    //  continue;
    //  System.out.println(i);
    //}

    //i = 0 -- j = 0
    //i = 0 -- j = 2
    //i = 1 -- j = 0
    //i = 1 -- j = 2
    //i = 2 -- j = 0
    //i = 2 -- j = 2

    //i = 0 -- j = 0
    //i = 1 -- j = 0
    //i = 2 -- j = 0

    outer:
    for (int i = 0; i < 3; i++) {

      for (int j = 0; j < 3; j++) {
        if( j == 1) {
          continue outer;
          //break;
        }
        System.out.println("i = " + i + " -- " + "j = " + j);
      }

    }


  }

}

　　return关键字不是为了跳转出循环体 ，更常用的功能是结束一个方法（函数），也就是退出一个方法。 跳转到上层调用的方法。这个在方法的使用那里会在详细的讲解。

演示案例： 结束循环其实是结束了main方法

public class ReturnDemo {

  public static void main(String[] args) {

    //return 终止单重循环
    //for (int i = 1; i <= 10; i++) {
    //  System.out.println(i);
    //  if(i == 5) {
    //    return;
    //  }
    //}

   //return 终止多重循环
    for (int i = 0; i < 3; i++) {
      for (int j = 0; j < 3; j++) {
        if( j == 2) {
          return;
        }
        System.out.println("i = " + i + " -- " + "j = " + j);
      }
    }

    System.out.println(" hello return");
  }

}