Java基础语法总结（变量的使用、运算符、流程控制、JDK、JRE、JVM之间的关系）

Java基础语法

一、概述

1、Java语言运行机制及运行过程

1.1、Java 语言的特点

• 特点一： 面向对象

  1. 两个基本概念：类、对象
  2. 三大特性：封装、继承、多态

• 特点二： 健壮性

  1. 吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如指针、内存的申请与释放等），提供了一个相对安全的内存管理和访问机制

• 特点三： 跨平台性

  1. 跨平台性：通过Java语言编写的应用程序在不同的系统平台上都可以运行。 “Writeonce , Run Anywhere”
  2. 原理：只要在需要运行 java 应用程序的操作系统上，先安装一个Java虚拟机 (JVM JavaVirtual Machine) 即可。由JVM来负责Java程序在该系统中的运行。

1.2、Java 语言的特点：跨平台性

​ 因为有了JVM，同一个Java 程序在三个不同的操作系统中都可以执行。这样就实现了Java 程序的跨平台性。每个虚拟机中的JVM不一样。

1.3、Java两种核心机制

• Java虚拟机
  • JVM 是一个虚拟的计算机，具有指令集并使用不同的存储区域。负责执行指令，管理数据、内存、寄存器。
  • 对于不同的平台，有不同的虚拟机。
  • 只有某平台提供了对应的java虚拟机，java程序才可在此平台运行
  • Java虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，到处运行”
    
    
• 垃圾回收
  • 不再使用的内存空间应回收—— 垃圾回收。
    • 在C/C++等语言中，由程序员负责回收无用内存。
    • Java 语言消除了程序员回收无用内存空间的责任：它提供一种系统级线程跟踪存储空间的分配情况。并在JVM空闲时，检查并释放那些可被释放的存储空间。
  • 垃圾回收在Java程序运行过程中自动进行，程序员无法精确控制和干预。
  • Java程序还会出现内存泄漏和内存溢出问题吗？Yes!

2、JDK、JRE、JVM之间的关系

2.1、什么是JDK ，JRE

• JDK(Java Development Kit Java 开发工具包)
  • JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。所以安装了JDK，就不用在单独安装JRE了。
    • 其中的开发工具：编译工具(javac.exe) 打包工具(jar.exe)等
• JRE(Java Runtime Environment Java 运行环境)
  • 包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等，如果想要 运行一个开发好的Java程序，计算机中只需要安装JRE即可。

简单而言，使用JDK 的开发工具完成的java 程序，交给JRE 去运行。

• JDK = JRE + 开发工具集（例如Javac编译工具等）
• JRE = JVM + Java SE标准类库

2.2、JDK下载网址

https://www.oracle.com/java/technologies/javase-downloads.html

二、基本语法

• 注释
  • 单行注释：//
  • 多行注释：/* */
  • 文档注释（Java特有）：/** */ 注释内容可以被JDK提供的工具javadoc所解析生成一套以网页文件形式体现的该程序的说明文档

单行注释与多行注释的内容不参与编译

1、关键字与保留字

• 关键字(keyword)的 的 定义和特点

  • 定义：被Java 语言赋予了特殊含义，用做专门用途的字符串（单词）
  • 特点： 关键字中所有字母都为 小写
  • 官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
    

• Java保留字

  • 现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字
    goto 、const

2、标识符与进制

2.1、标识符

• 标识符：
  • Java 对各种 变量、 方法和 类等要素命名时使用的字符序列称为标识符
  • 技巧：凡是自己可以起名字的地方都叫标识符。
• 定义合法标识符规则（不遵守编译不通过）：
  • 由26 个英文字母大小写，0-9 ，_或 $ 组成
  • 数字不可以开头。
  • 不可以使用关键字和保留字，但能包含关键字和保留字。
  • Java 中严格区分大小写，长度无限制。
  • 标识符不能包含空格。
• 名称命名规则
  • Java中的名称命名规范（不遵守不影响使用，但是建议遵守，增加代码可读性）：
    • 包名：多单词组成时所有字母都小写：xxxyyyzzz
    • 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
    • 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
    • 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
  • 注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
  • 注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。

2.2、进制

• 计算机底层都是以二进制的补码形式进行存储的

3、变量的使用（重点）

3.1、概念

• 内存中的一个存储区域

• 该区域的数据可以在同一类型范围内不断变化

• 变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值

• 作用

  • 用于在内存中保存数据

• 注意

  • Java中每个变量必须先声明，后使用
  • 使用变量名来访问这块区域的数据
  • 变量的作用域：其定义所在的一对{ }内
  • 变量只有在其作用域内才有效
  • 同一个作用域内，不能定义重名的变量

• 使用

  • 声明
    • 语法：<数据类型> <变量名称>
    • 例如：int var;
  • 变量的赋值
    • 语法：<变量名称> = <值>
    • 例如：var = 10;
    • 声明和赋值变量
    • 语法： <数据类型> <变量名> = <初始化值>
    • 例如：int var = 10;

3.2、分类

• 按数据类型分类
  • 对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分配了不同大小的内存空间。

• 按声明位置分类
• 在方法体外，类体内声明的变量称为 成员变量 。
• 在方法体内部声明的变量称为 局部变量
  
• 两者在初始化方面异同
• 同：都有生命周期 异：局部变量除形参外，需显式初始化。

3.3、整形（byte 、short 、int 、long）

• Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保
  证java程序的可移植性。
• java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’
• java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long

类 型	占用存储空间	表数范围
byte	1字节=8bit位	-128 ~ 127
short	2字节	-2 15 ~2 15 -1
int	4字节	-2 31 ~ 2 31 -1 (约21亿)
long	8字节	-2 63 ~ 2 63 -1

1MB = 1024KB 1KB= 1024B 1B=1byte 1byte=8bit

3.4、浮点类型（float 、double）

• 与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。
• 浮点型常量有两种表示形式：
• 十进制数形式：如：5.12 512.0f .512 (必须有小数点）
• 科学计数法形式:如：5.12e2 512E2 100E-2
• float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
• double:双精度，精度是float的两倍。通常采用此类型。
• Java 的浮点型常量默认为double型，声明float 型常量，须后加‘f’ 或‘F’ 。

类 型	占用存储空间	表数范围
单精度float	4字节	-3.403E38 ~ 3.403E38
双精度double	8字节	-1.798E308 ~ 1.798E308

3.5、字符类型（char）

• char 型数据用来表示通常意义上“字符”(2字节)
• Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
• 字符型变量的三种表现形式：
  • 字符常量是用单引号(‘ ’)括起来的单个字符。例如：char c1 = ‘a’; char c2= ‘中’; char c3 = ‘9’;
  • Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。
    例如：char c3 = ‘\n’; // '\n’表示换行符
  • 直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示 \n。
• char类型是可以进行运算的。因为它都对应有Unicode码。

3.6、布尔类型（boolean）

• boolean 类型用来判断逻辑条件，一般用于程序流程控制：
  • if条件控制语句；
  • while循环控制语句；
  • do-while循环控制语句；
  • for循环控制语句；
• boolean类型数据只允许取值true和false，无null。
  • 不可以使用0或非 0 的整数替代false和true，这点和C语言不同。
  • Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false用0表示。
• 占用字节
  • boolean类型在Java虚拟机中被编译为int类型，等于是说JVM里占用字节和int完全一样，int是4个字节，于是boolean也是4字节
  • boolean数组在Oracle的JVM中，编码为byte数组，每个boolean元素占用8 bit(位)=1 byte(字节)

3.7、字符串类型（String）

• String不是基本数据类型，属于引用数据类型
• 使用方式与基本数据类型一致。例如：String str = “abcd”;
• 一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：
  str = str + “xyz” ;
  int n = 100;
  str = str + n;

3.8、基本数据类型转换

• 自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：

• 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
• byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
• boolean类型不能与其它数据类型运算。
• 当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型。
• byte,short,char之间做运算时，只能用int接收，即便是同种类型之间运算也之只能用int接收。原因：可能是因为int范围符合正常使用，避免short等小范围类型做运算时出现超出范围的情况。

public static void main(String[] args) {
    byte b = 23;
    byte b1 = 23;
    char c = 'c';
    char c1 = 'c';
    short s = 11;
    short s1 = 11;
    short s2 = s+b;     //编译不通过
    short s3 = s+s1;    //编译不通过，同为short也不能用short接收
    byte b2=b+b1;       //编译不通过，同为byte也不能用byte接收
    char c2 = c+c1;     //编译不通过，同为char也不能用char接收
    int i = s+b;        //编译通过
    int i1 = c+s;       //编译通过
    int i2 = s+s1;      //编译通过
    int i3 = c+c1;      //编译通过
}

3.9、强制类型转换

• 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：()，但可能造成精度降低或溢出,格外要注意。
• 通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。
  • 如： String a = “43”; int i = Integer.parseInt(a);
  • boolean类型不可以转换为其它的数据类型。
• 若long类型初始化时后面值不加L，则默认用int类型接收，即便声明为long。例如：long l = 12313213213132321; 后面不加L会报错，超出int可接收范围。

3.10、ASCII（了解）

• 在计算机内部，所有数据都使用 二进制表示。每一个二进制位（bit）有 0 和 1 两种状态，因此 8 个二进制位就可以组合出 256 种状态，这被称为一个字节（byte）。一个字节一共可以用来表示 256 种不同的状态，每一个状态对应一个符号，就是 256 个符号，从0000000 到 11111111。
• ASCII码：上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个 字符的编码，比如空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。
• 缺点 ：
  • 不能表示所有字符。
  • 相同的编码表示的字符不一样：比如，130在法语编码中代表了é，在希伯来语编码中却代表了字母Gimel (ג)

3.11、Unicode 编码（了解）

• 乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。
• Unicode： 一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一用 无二的编码，使用 Unicode 没有乱码的问题 。
• Unicode 的缺点：Unicode 只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储：无法区别 Unicode 和 ASCII：计算机无法区分三个字节表示一个符号还是分别表示三个符号。另外，我们知道，英文字母只用一个字节表示就够了，如果unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有二到三个字节是0，这对于存储空间来说是极大的浪费。

3.12、UTF-8（了解）

• UTF-8 是在互联网上使用最广的一种 Unicode 的实现方式。
• UTF-8 是一种变长的编码方式。它可以使用 1-6 个字节表示一个符号，根据不同的符号而变化字节长度。
• UTF-8的编码规则：
  • 对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于ASCII码）。
  • 对于多字节的UTF-8编码，如果编码包含 n 个字节，那么第一个字节的前 n 位为1，第一个字节的第 n+1 位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的所有的字节，都是最高两位为"10"，其余6位用来对字符进行编码。

4、运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

4.1、算术运算符

• 注意
  • 如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数则不可忽略，结果的符号与被模数符号一样。此外，取模运算的结果不一定总是整数。
  • 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。 例如：int x=3510;x=x/1000*1000; x的结果是3000
  • “+”除字符串相加功能外，还能把非字符串转换成字符串.例如：
    System.out.println(“5+5=”+5+5); //打印结果是 5+5=55
• 示例

public static void main(String[] args) {
    //输出为*   *		//''单引号为字符char，""双引号为字符串对象String
    System.out.println("*   *");        //*   *
    System.out.println('*'+'\t'+'*');   //93
    System.out.println('*'+"\t"+'*');   //*	*
    System.out.println('*'+'\t'+"*");   //51*
    System.out.println('*'+('\t'+"*")); //*	*
}

4.2、赋值运算符

• 符号：=
  • 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
  • 支持连续赋值。
• 扩展赋值运算符： +=, -=, *=, /=, %=

4.3、比较运算符

• 比较运算符的结果都是boolean型，也就是要么是true，要么是false。
• 比较运算符“==” 不能误写成“=” 。

4.4、逻辑运算符

• 逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
• “&”和“&&”的区别：
  • 单&时，左边无论真假，右边都进行运算；
  • 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
• “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。
• 异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。
  理解：异或，追求的是“异” !

4.5、位运算符

• 位运算是直接对整数的二进制进行的运算

运算方式：

4.6、三元运算符

• 格式:
  • ( 条件表达式)? 表达式1 ：表达式2；
    条件为 true ，运算后的结果是表达式1；
    条件为 false ，运算后的结果是表达式2；
  • 表达式1 和表达式2为 为 同种类型
  • 三元运算符与if-else 的联系与区别：
    • 三元运算符可简化if-else语句
    • 三元运算符要求必须返回一个结果。
    • if后的代码块可有多个语句

4.7、运算符优先级

• 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如上表，上一行运算符总优先于下一行。
• 只有单目运算符、三元运算符、赋值运算符是从右向左运算的。

5、流程控制

• 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
• 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：
  • 顺序结构
    • 程序从上到下逐行地执行，中间没有任何判断和跳转。
  • 分支结构
    • 根据条件，选择性地执行某段代码。
    • 有if…else和switch-case两种分支语句。
  • 循环结构
    • 根据循环条件，重复性的执行某段代码。
    • 有while、do…while、for三种循环语句。
    • 注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

5.1、顺序结构

• 代码由上而下顺序执行
• Java中定义成员变量时采用合法的前向引用

5.2、分支结构

5.2.1、if-else结构

• if语句三种格式：
  • if( 条件表达式){
    执行代码块；
    }
  • if( 条件表达式){
    执行代码块1;
    }
    else{
    执行代码块2;
    }

• if( 条件表达式1){
  执行 代码块1;
  }
  else if ( 条件表达式2){
  执行 代码块2;
  }
  ……
  else{
  执行 代码块n;
  }
  
• 使用说明
  • 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
  • 语句块只有一条执行语句时，一对{}可以省略，但建议保留
  • if-else语句结构，根据需要可以嵌套使用
  • 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
  • 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓当多个条件是“包含”关系时，“小上大下 / 子上父下”

5.2.2、switch-case

• 示例模板：

• switch( 表达式){
  case 常量1:
  语句1;
  // break;
  case 常量2:
  语句2;
  // break;
  … …
  case 常量N:
  语句N;
  // break;
  default:
  语句;
  // break;
  }
  

• 使用说明

  • switch(表达式)中表达式的值 必须是下述几种类型之一：byte ，short，char ，int，枚举 (jdk 5) ，String (jdk 7)；
  • case子句中的值必须是 常量，不能是变量名或不确定的表达式值；
  • 同一个switch语句，所有case子句中的常量值互不相同；
  • break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾
  • default子句是 可任选的。同时，位置也是灵活的。当没有匹配的case时，则执行default

• 底层原理

  • switch的参数底层都是以整数来比较的，底层会根据数的大小自动转化为byte、short、int，参数不支持float、long。
  • 枚举类型也有对应的整数序号ordinal
  • String用于switch参数时也会通过hashCode方法转换为整数String的hashCode值可能冲突，而解决冲突的方式就是跳转之后再通过equals方法判定字符串内容是否相等。

5.2.3、switch 和if 应用场景

• 如果判断的具体数值不多，而且符合byte、short 、char、int、String、枚举等几种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。
• 其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。也就是说，使用switch-case的，都可以改写为if-else。反之不成立。
• 两者效率问题（空间换时间）
  1. （switch底层原理）switch…case会生成一份大小（表项数）为最大case常量＋1的跳表，程序首先判断switch变量是否大于最大case 常量，若大于，则跳到default分支处理；否则取得索引号为switch变量大小的跳表项的地址（即跳表的起始地址＋表项大小＊索引号），程序接着跳到此地址执行，到此完成了分支的跳转。（if-else）根据顺序依次判断，效率较switch低。
  2. 当分支较多时，当时用switch的效率是很高的。因为switch是随机访问的，就是确定了选择值之后直接跳转到那个特定的分支，但是if-else是遍历所以得可能值，知道找到符合条件的分支。如此看来，switch的效率确实比if-else要高的多。
  3. switch…case占用较多的代码空间，因为它要生成跳表，特别是当case常量分布范围很大但实际有效值又比较少的情况，switch…case的空间利用率将变得很低。
  4. switch…case只能处理case为常量的情况，对非常量的情况是无能为力的。例如 if (a > 1 && a < 100)，是无法使用switch…case来处理的。所以，switch只能是在常量选择分支时比if-else效率高，但是if-else能应用于更多的场合，if-else比较灵活

5.3、循环结构

• 循环结构
  • 在某些条件满足的情况下，反复执行特定代码的功能
• 循环语句分类
  • for 循环
  • while 循环
  • do-while 循环
• 循环语句的四个组成部分
  • 初始化部分(init_statement)
  • 循环条件部分(test_exp)
  • 循环体部分(body_statement)
  • 迭代部分(alter_statement)

5.3.1、for循环

• 语法格式
  • for (① 初始化 部分; ② 循环条件部分; ④ 迭代部分)｛ ｛
    ③循环体部分;
    ｝
• 执行顺序
  • ①-②-③-④-②-③-④-②-③-④-…-②
• 说明：
  • ②循环条件部分为boolean类型表达式，当值为false时，退出循环
  • ①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
  • ④可以有多个变量更新，用逗号分隔

5.3.2、while循环

• 语法格式
  ① 初始化部分
  while(②循环条件部分)｛ ｛
  ③循环体部分;
  ④迭代部分;
  }
• 执行过程：
  ①- ②- ③- ④- ②- ③- ④- ②- ③- ④-…-②
• 说明：
  • 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
  • for循环和while循环可以相互转换

5.3.3、do-while循环

• 语法格式
  • ①初始化部分;
    do{
    ③ 循环体部分
    ④ 迭代部分
    }while(②分 循环条件部分);
• 执行过程：
  ①- ③- ④- ②- ③- ④- ②- ③- ④-…②
• 说明：
  do-while 循环至少执行一次循环体

5.3.4、嵌套循环

• 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环或内层循环。
• 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
• 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

5.3.5、关键字：break、continue、return

• 使用方式：

  • break只能用于switch 语句和 循环语句中。
  • continue 只能用于 循环语句中。
  • 二者功能类似，但continue是终止 本次循环，break是终止 本层循环。
  • break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
  • 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
  • 很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它。但使程序容易出错。Java中的break和continue是不同于goto的。

• break 语句

  • break语句用于终止某个语句块的执行
    { ……
    break;
    ……
    }

  • break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块

    l1:while (true){
        l2:for (int j=0;j<9;j++){
            l3:do {
                break l2;	//停止l2循环，进入l1的下一次循环。
            }while (true);
        }
    }
    

  • 示例

    public static void main(String args[]){
        for(int i = 0; i<10; i++){
            if(i==3)
                break;
            System.out.println("i=" + i);
        }
        System.out.println("Game Over!");
    }
    
    //结果
    i=0
    i=1
    i=2
    Game Over!
    

• continue 语句

  • continue只能使用在循环结构中

  • continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环

  • continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环

  • 示例

    public static void main(String args[]){
        l:for(int i = 0; i<5; i++){
            if(i==3){
                //此处用标签l与不用效果一样，
                //因为不用默认为跳过本层循环的本次循环
                //而l指定的也是本层，所以效果一样
                continue l;	
            }
            System.out.println("i=" + i);
        }
        System.out.println("Game Over!");
    }
    //结果
    i=0
    i=1
    i=2
    i=4
    Game Over!
    

• return关键字

  • return：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。
  • 与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内