# :-: Java基本语法
[TOC]
Java基本语法，包括：
注释； 关键字；标识符；常量；变量；运算符；流程控制语句；函数；数组；
# 1.关键字
关键字：被Java语言赋予了特定含义的一些字符！关键字中所有字母都为小写。好比汉字中的专有名词，例如：中国、北京、陕西等。一般我们不能将这些词用在其他地方，改变其含义。
不用刻意去记每个关键字的用法和意义，后面学习中，陆陆续续都会接触到，自然而然就记住了。
# 2.标识符
可简单理解为在Java程序中为了增强阅读性自定义的名称。比如：类名，方法名，变量名等。
（就是程序员给自己定义的东西起的名字）
标识符组成：
(1) 标识符由字母、数字、下划线、$组成，不能以数字开头，注意：此处的字母还可以是中文，日文等；
(2) 标识符大小写敏感；A a
(3) 标识符不得使用java中的关键字和保留字；
(4) 别用Java API里面的类名作为自己的类名。
注意：在起名字的时，只要标识符不是关键字就可以了，但为了提高阅读性，经常用有意义的英文单词作为标识符。
标识符书写规范：
包名：多单词组成时所有字母都小写。xxxyyyzzz
类名接口名：每一个单词的首字母都要大写，其他字母小写；
变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接。XXX_YYY_ZZZ
# 3.常量
在日常生活中，经常使用数据表示事物的某些特性。比如：年龄，身高，日期等等，这些数据都是具体的数值。那么在Java中像这样的数据如何描述呢？像这样数值确定的数据，Java中用常量来描述。
## 3.1.常量概念
常量：程序中固定不变化的值。
3.2.常量分类：
1）整数常量。所有整数 三类 正整数 零 负整数
2）浮点数常量（小数常量）。所有带小数点的数
3）布尔(boolean)型常量。较为特有，只有两个数值。true false。
4）字符常量。在Java中指的是使用英文的单引号括起来的一个字符；
5）字符串常量。在Java中指的是使用英文的双引号括起来的不限制数量的字符（可以一个都没有，也可以是一个，也可以是多个）；
6）null常量。只有一个数值就是:null.
## 3.2.进制（了解）
二进制的由来：
日常生活中，经常使用十进制运算数据，但是也接触过七进制、十二进制等。那么怎么把生活中的这些数据存放在计算机中，计算机又是如何表示这些数据呢？
任何数据在计算机中都是以二进制的形式存在的。二进制早起由电信号开关演变而来。用开表示某一个数，用关表示某一个数，然后使用不同的开和关组合起来，就可以表示数据了。
一个整数在内存中一样也是二进制的。
二进制：每一个二进制数位用0，1 ；满2进1。 0B101 二进制数
八进制：每一个八进制数位用0，1，2，3，4，5，6，7 ；满8进1。用0开头表示。 0123 八进制
十进制：每一个十进制数位用0，1，2，3，4，5，6，7 ，8，9 ；满10进1。 满10进1。 123
十六进制：每一个十六进制数位用0，1，2，3，4，5，6，7 ，8，9，A，B，C，D，E，F ；满16进1。 满16进1.。用0x开头表示。 0xAF 十六进制
### 3.2.1进制转换（了解）
既然知道计算机中存储的都是二进制数据，那么如何将生活中的十进制数据转换成计算机能够识别的二进制数数据呢？
十进制转二进制：十进制转成二进制--->除以2倒取余数
图例说明：把一个十进制数转成二进制数，使用短除法，不停的除以2，直到商值为0，停止，然后倒着把余数写出来，这个数就是十进制数转后的二进制数。
二进制数转十进制数：二进制转成十进制--->按2的幂数展开并累加
图例说明：将一个二进制数转成十进制数，使用按权展开，并求累加和。具体说：对于一个二进制数，从最右侧开始，使用当前二进制数位上的数据乘以2的n-1次幂(n为当前这个二进制数从右侧开始的第几位。)，并这将这些数据展开后加起来求和即可得到相应的十进制数。
### 3.2.1.进制规律
计算机中是以二进制数据的形式表示所有数据，并且在计算机中把8个二进制数位当做一组，并用“字节”来表示。即：8bit = 1Byte （八个二进制数位为一个字节）。那么一个字节能表示的数据是多大呢？也就是当八个二进制数位上全部是1时能表达多大一个数据呢？
即当1个字节上全部存放的是1时，这个数据即就是255，0-255之间的任何一个正数都可以在用一个字节表示。
小技巧：对于任意一个十进制数，当要转成二进制时，也可以从上图中的128、64、32、16、8、4、2、1这些数据加起来。当有某一个数时，就说明这个二进制数位上一定存放的是1，若没有这个数，就说明这个二进制数位上一定存放的是0.
# 4.变量
## 4.1.变量的概念
在Java中，变量指的就是内存中的一块可以重复使用的空间，可以用来存放同一类型的不同常量数据。
理解：变量就如同数学中的未知数，程序中凡是未知的数据，和可以变化的数据，都要使用变量来表示。
## 4.2.变量的数据类型（Java的数据类型）
在生活中，使用的数据有大有小，有整数，也有小数，同时也会使用字母，或者汉字表示特定含义。在Java中根据数据的不同特点，数据也分为不同的类型。
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。
字符串不是基本类型，使用标识符String表示；
## 4.3.变量的声明
### 4.3.1.变量的格式
标准形式：
数据类型 变量名；//声明一个变量，没有分配内存空间；
变量名 = 数据值；//分配内存空间，同时将数据值存放到变量空间中；
简写形式：
数据类型 变量名 = 数据值；//编译后，字节码里面还是和标准形式一样，分为两步；
注意：
Java语言的整型常量默认是int型，声明long型变量后加上‘l’或‘L’
Java浮点型常量默认是double，则要声明一个常量为float型，则需在常量后加上f 或 F,；
### 4.3.2.变量的起名
语法规则：
变量名是标识符，命名规则和标识符的语法规则相同：
1、只能是大小写英文字母、数字、美元符号（$）和下划线组成；
2、不能用数字开头；
3、不能是关键字；
4、严格区分大小写；
书写规范：
在驼峰法的命名规范中，变量名和方法名一样，应该遵守以下规范：
1、一个单词，全部都是小写；
2、多个单词，从第二个单词开始每个单词的首字母大写；
推荐原则：
见名知意。
例如：String name ；使用name表示这个空间名字，即说明这个空间存放的姓名
## 4.4.变量的特点
变量必须先声明在使用：
都需要先赋值才能使用；
都有使用范围；
都有数据类型，一般不能向不同类型的变量赋值；
## 4.5.Java的类型转换
### 4.5.1.隐式类型转换：
在Java中，向数值类型和字符类型的变量中保存数据的时候，如果要保存的数据的大小，没有超过变量空间的存储大小，JVM就会自动将要保存的数据的类型转换为变量的类型，叫做隐式类型转换。
### 4.5.2.强制类型转换
在Java中，将占用空间大的数据向取值范围小的变量中保存时，因为变量空间不足，所以不能直接存放，需要使用强制类型转换。
注意：强制类型转换有可能造成数据损失，使用时需要格外注意！
强制转换格式：(数据类型)(被转数据);
练习：
以下代码编译运行有没有问题？为什么？
```
class Test
{
public static void main(String[] args)
{
byte a = 100;
byte b = a + 1;//这行编译出问题，因为a是变量；使用强制类型转换即可改正；
System.out.println(b);
}
}
```
# 5.运算符
## 5.1.算术运算
Java中的算术运算符和生活中的数学运算基本相似。
### 5.1.1.算术运算符符号
### 5.1.2.自加自减
自加（++）自减（--）运算
++：自增运算
如果运算符在运算的数据左边，就叫做左自增运算；如果在运算的数据右边，就叫做右自增运算；
例如：int a = 10;
++a 是左自增；a++ 是右自增；
左自增，直接对原有的数据进行+1；如果这一行代码没有结束，接下来参与其它运算的，是加一后的值；
右自增： 右自增运算，首先在内存中开辟一个临时空间，将原来的数据保存在这个临时空间中；然后对变量进行加一运算；
如果这一行代码没有结束，接下来参与其它运算的，是临时空间中的值（还没有加一的值）；
--：自减运算
也分为左自减和右自减，原理和自增运算一模一样，只是进行的是减一运算；
练习：
下列程序运行输出的结果是什么？为什么？
```
class Test
{
public static void main(String[] args)
{
int a = 10;
int b = 20;
int c = (a++) + 3*(--a) + 5*(b--) - 4*(--b);
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}
```
### 5.1.3.字符串连接符
如果“+”左右两边至少有一边是一个字符串，他就是一个字符串连接符，可以将左右两边的结果拼接成一个大的字符串；
思考：
1、System.out.println("5+5="+5+5);//打印结果是？
2、若要打印出“5+5”=10 ，上述代码怎么改？
3、下列程序运行输出的结果是什么？为什么？
```
class Test
{
public static void main(String[] args)
{
System.out.println('A' + 'K' + "|" + 47);
System.out.println('A' + "K" + '|' + 47);
}
}
```
## 5.2.赋值运算符
可以将数据赋值给变量的运算符就是赋值运算符；= , +=, -=, *=, /=, %=
普通赋值运算符：=
作用：表示将符号右边的数据，保存到符号左边的变量中；
```
class Demo
{
public static void main(String[] args)
{
int a = 3 ; //将3存储到左侧a空间中
int b , c , d;
b = c = d = a; // 将a空间中的值分别存放到d，c，b 空间中
}
}
```
复合赋值运算符：
+=；-=；*=；/=；%=……
表示：
先将符号左右两边进行运算，然后将运算的结果赋值给左边的变量；
注意：赋值号和算数运算符的混合运算属于一个运算符，不能拆分。并且这个符号会完成自动强转动作。
思考：以下代码有什么区别？
```
class Demo
{
public static void main(String[] args)
{
short s = 3;
s=s+2;
s+=2;
}
}
```
说明：
s=s+2//编译失败，因为s会被提升为int类型，运算后的结果还是int类型。无法赋值给short类型。
s+=2//编译通过，因为+=运算符在给s赋值时，自动完成了强转操作。
## 5.3.比较运算符
### 5.3.1.运算符介绍
在生活中经常需要判断数据大小，相等不相等各种操作，在Java中同样也可以判断数据的大小。
比较运算符符号：
```
>： 大于
>=： 大于或等于
<： 小于
<=： 小于或等于
==： 恒等于，表示比较左右两边是否相等；
!=： 不等于，表示比较左右两边不相等；
注1：比较运算符的结果都是boolean型，也就是要么是true，要么是false。
注2：比较运算符“==”不能误写成“=” 。
注3：比较运算符不能多个连续一起使用；如 1 < a < 5 非法；
```
### 5.3.2.运算符使用演示
## 5.4.逻辑运算符
当需要判断某些数据符合某个区间，比如人的年龄符合某一范围等。发现使用比较运算没法完成。Java给我们提供另外一直机制，逻辑运算。逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
5.4.1.1.逻辑运算符号：
逻辑运算符：用可于进行逻辑运算（就是对布尔型数据进行运算）的符号就是逻辑运算符；
```
& : 与
| ：或
^ : 异或。
！：非。一元逻辑运算符；
&& 短路与 || 短路或
```
特点：
参与逻辑运算的数据都是布尔型数据；
逻辑运算的结果也都是布尔型数据；
#### 5.4.1.2.运算规律
逻辑运算表：!true = false; !false = true;
```
class Demo
{
public static void main(String[] args)
{
int x = 7;
x>2 & x<5
x<2 | x>5
}
}
```
& ：两边都为true，结果是true。否则为false。两边只要有一个false。结果必然是false。
```
true & true = true;
true & false = false;
false & true = false;
false & false = false;
```
| ：两边都为false，结果是false。否则为true。两边只要有一个true。结果必然是true。
```
true | true = true;
true | false = true;
false | true = true;
false | false = false;
```
^ : 异或。两边相同为false。两边不同为true。
```
true ^ true = false;
true ^ false = true;
false ^ true = true;
false ^ false = false;
```
！：非：非真为假，非假为真
```
!true = false;
```
&和&&的区别：
因为与运算，要求左右两边都是true，结果才是true，所以如果左边已经是false，结果肯定是false；
所以：
```
使用&&计算时，如果左边是false，就不计算右边；如果左边是true，才会计算右边；
使用&计算时，不管左边真假，两边都会计算；
```
|和||的区别：
```
使用||计算时，如果左边是true，就不计算右边；如果左边是false，才会计算右边；
使用|计算，不管左边是什么，两边都会计算；
```
问题：什么时候使用 & 和 | ？
如果右边一定要计算，就应该使用&和|；
## 5.5.三元运算符
三元运算符，也称为三目运算符或问号冒号运算符。即有三个表达式参与的运算表达式。
### 5.5.1.1.三元运算符的格式：
接受运算结果的变量 = 布尔表达式 ? 表达式1 ：表达式2；
注意：在三元运算符的左边，一定要有一个变量来接收运算的结果！
### 5.5.1.2.三元运算符举例：
练习：根据给定的数字，在控制台输出奇数或者偶数？
练习二：使用三元运算符，求两个整数的最大数；
作业：使用三元运算符，求三个整数中最大值、最小值；
## 5.6.位运算符（了解）
位运算：直接对二进制数位（0和1）进行操作的运算 符。
5.6.1.1.运算符符号：
双元位运算符：
```
<<：左移运算符 将运算数的二进制码整体左移指定位数，左移之后右边的空位使用“0”来补充，左边移出去的二进制数忽略不计。
```
```
>>：右移运算符 将运算数的二进制码整体右移指定位数，右边移出去的二进制数忽略不计。 左边的空位使用“符号位”来补充：若是正数使用“0”补充；若是负数使用“1”补充；
```
```
>>>：无符号右移运算符 将运算数的二进制码整体右移指定位数，右移之后的左边的空位使用“0”来补充
```
```
&：按位与 相同二进制数位上数值为1，结果为1，否则结果为0；
```
```
|：按位或运算，运算原则：相同二进制数位上数值为0，结果为0，否则结果为1；
```
```
^：按位异或，运算原则：参与运算的两个数相应位相同则结果为0，异号则为1；
```
使用按位异或运算，可以方便的实现两个数字的交换；
```
int a = 5, b = 7;
int c = a ^ b ;
a = c ^ a ; a = 7
b = c ^ a ; b = 5;
```
作业：使用不同的方式实现两个整数的交换；
一元位运算符：
~：按位取反 ：二进制数位上0变1，1变0；
# 6.流程控制语句
## 6.1.程序执行流程
流程：就指的是一个事情的先后顺序；
程序流程： 就是程序中代码的执行顺序；
## 6.2.Java程序的流程
java 中代码的执行顺序，主要有三种基本执行顺序：顺序执行；选择执行；重复执行；
其中，Java程序默认就是顺序流程；
```
class Demo
{
public static void main(String[] args)
{
int a = 3 ;
int b = 5 ;
int sum ;
sum = a + b;
System.out.println("sum="+sum);
}
}
```
上述代码当在dos命令行中写入java Demo 回车之后，首先会启动JVM，JVM就会去加载当前Demo这个class文件，并执行其中的main方法。当程序执行main方法的时候会从第一行开始往下执行，直到整个代码全部执行完成。在此过程中程序按照书写的顺序，不会跳过任何一行代码。像这样的执行流程就是常见的顺序执行结构。
选择流程和重复流程，都需要特殊的流程控制语句来控制；
# 7.选择流程控制语句
Java中控制选择流程的语句，主要有判断语句和选择语句两种；
## 7.1.判断语句(if语句)
判断语句就是根据判断条件的真与假，来选择执行某些代码；根据可以选择执行的代码分支的数量，可将判断语句分为单支判断语句、双支判断语句和多支判断语句；
### 7.1.1.单支判断
语句格式：
```
if(布尔表达式)
{
选择执行的代码分支；
}
```
执行顺序：
案例演示：
需求：模拟买票:如果乘客的身高超过1.2m（包含），就输出“恭喜您的孩子又长高了！请买票！”。
### 7.1.2.双支判断：
语句格式：
```
if(布尔表达式)
{
选择执行的代码分支一；
}else{
选择执行的代码分支二；
}
```
执行顺序：
案例演示：
需求：模拟成绩显示；如果考试成绩超过60分（包含），就输出“恭喜你及格了！”，否则就输出“笨蛋你挂科了！”。
### 7.1.3.双支判断语句和三元运算符的异同：
相同点：
```
都有一个布尔表达式；
都要由两个代码分支；
都是根据布尔表达式的运算结果来选择执行一个代码分支；
```
不同点：
```
三元运算符，是一个运算符，一定有一个运算结果，而双支判断语句是一个流程控制语句，没有返回结果；
三元运算符，必须有一个变量接收返回的结果，双支判断语句不需要；
```
案例演示：
分别使用三元运算符和if-else语句求两个整数的最大值；
### 7.1.4.多支判断：
语句格式：
```
if(布尔表达式一)
{
选择执行的代码分支一；
}else if(布尔表达式二){
选择执行的代码分支二；
}else if(布尔表达式三){
选择执行的代码分支三；
}
……
else{
选择执行的代码分支n；
}
```
执行顺序：
案例演示：
需求：模拟一个游戏中的成就显示系统，根据游戏积分显示下面不同的称号：
### 7.1.5.判断语句的简写：省略大括号
if(布尔表达式)
代码分支；
注意：如果if语句后面没有大括号，则if语句只能到第一个分号结束；
所以开发中为了避免出现错误，最好大括号不要省略；
一般只有在分支代码只有一行的时候才会省略；
### 7.1.6.嵌套判断
如果再选择的代码分支中也存在判断语句，就形成了一个嵌套判断；
格式：
```
if(布尔表达式)｛
if（布尔表达式）｛
代码分支
｝
｝
```
举例：
模拟用户登陆：
后台判断，就一般先判断验证码，如果正确，再判断用户名是否存在；如果存在，再判断密码是否正确；只要有一个判断错误，就登陆失败；
## 7.2.选择结构(switch )
### 7.2.1.switch语句格式：
switch(表达式)//注意：这个表达式不是布尔表达式！这个表达式返回的结果只能是：byte，short，int ， char。（java5之前）。还支持 enum(jdk5), String(jdk7)；
```
{
case 取值1:
执行语句；
break；//break可有可无；
case 取值2:
执行语句；
break；
……
default:
执行语句；
break；
}
```
程序执行时，遇到switch关键字，首先会计算表达式的值，然后根据计算的值和case后面的值做比较，当case后面的值和switch表达式的值相同时，就执行case身后的所有语句，若case身后没有和switch表达式匹配的值，程序就会执行default后面的语句。
```
### 7.2.2.代码演示
class SwitchDemo
{
public static void main(String[] args)
{
int x = 5;
switch(x){
case 5:
System.out.println("a");
break;
case 3:
System.out.println("b");
break;
default:
System.out.println("c");
break;
}
System.out.println("Hello World!");
}
}
```
### 7.2.3.switch语句特点：
switch语句选择的类型只有四种：byte，short，int ， char。（java5之前）。还支持 enum(jdk5), String(jdk7)；
case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
结束switch语句的两种情况：遇到break，执行到switch语句结束。
如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
### 7.2.4.switch练习：
根据用户的给定的数值，显示该数值对应的星期。如：2，星期二。
### 7.2.5.if和switch的区别：
if可以用于判断数值，也可以判断区间，只要运算结果是boolean类型，都可以进行判断。
switch用于对固定的几个值，进行判断。判断的值的类型有限。
### 7.3.循环结构(while&do-while)
## 7.3.1.循环结构：
根据程序的需求，可以将某些代码重复执行的操作。Java中的循环结构有如下三种：
* while:事先不需要知道循环执行多少次；
* do-while:同上，只是至少要执行一次(先做，后判断)；
* for:需要知道循环次数；
### 7.3.2.while循环
格式：
```
while(条件表达式)
{
执行语句；
}
```
while执行顺序：当程序遇到while关键字时，JVM首先会运算while后面的条件表达式，当条件表达式为true时，就会执行while后面大括号中的语句，当把大括号中的所有语句执行完之后，会又回到while的条件表达式处再次判断，若还为true，就继续执行大括号中的语句，若为false就跳过大括号中的所有语句，继续往下执行。
### 7.3.3.while代码举例：
```
class WhileDemo
{
public static void main(String[] args)
{
int i = 1;
while( i < 10 )//这个程序是个死循环
{
System.out.println("i"+i);
}
System.out.println("over");
}
}
```
上述循环是个无限循环（也称为死循环），主要原因是i变量一直为1，每次判断i<10都成立，导致选好条件结束不了。程序永远卡在循环这个地方执行
```
class WhileDemo
{
public static void main(String[] args)
{
int i = 1;
while( i < 10 )
{
System.out.println("i"+i);
i++; // 让i不断的更新，最后使循环可以结束
}
System.out.println("over");
}
}
```
### 7.3.4.while练习
需求：运算1-10的和。
分析：
1+2+3+4+...+10
每次加的和是确定的吗？不确定。需要变量记录和值。
每次和值需要加的下一个数是确定的吗？不确定，需要变量。
求和和+下一个数在重复，说明需要执行多次，用循环。
下一个数，是有规律的。自增。
### 7.3.5.while循环注意事项：
1）while循环的括号中的表达式计算结果必须为boolean类型的值。
2）while循环的括号中不能直接写false常量。
3）while循环的括号后面不要写分号，循环控制的语句的代码用大括号扩起来。
4）while循环控制的条件变量一定要更新，保证循环能够正常结束。
### 7.3.6.do-while循环
格式：
```
do
{
执行语句；
}while(条件表达式);
```
执行顺序：先执行do后面的语句，当执行完之后再进入条件表达式进行判断，若条件表达式结果为true继续执行do后面的语句，若条件表达式结果为false，则结束循环。
do while特点是无论条件是否满足，循环体至少被执行一次。
### 7.3.7.while和do-while对比
以下两个程序的执行结果：
```
int x = 3;
while(x<3)
{
System.out.println("x="+x);
x++;
}
```
```
int y = 3;
do
{
System.out.println("y="+y);
y++;
}while (y<3);
```
### 7.4.循环结构(for)
#### 7.4.1.for循环格式
```
for(初始化表达式（1）；循环条件表达式（2）；循环后的操作表达式（3）)
{
执行语句；（4）
}
```
执行顺序： for里面的3个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。
#### 7.4.2.for循环代码举例
```
class ForDemo
{
public static void main(String[] args)
{
for(int x = 1; x<3; x++)
{
System.out.println("x="+x);
}
}
}
```
#### 7.4.4.无限循环
最简单无限循环格式：while(true){} , for(;;){},无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
#### 7.4.5.for循环练习
需求：获取1-100之间6的倍数的个数。
分析：
1、个数是未知的，所以定义变量。
2、6的倍数咋表示？只要是对6能整除，也就是没有余数。
3、需要对1-100之间所以的数都要进行判断是不是6的倍数。如果是，需要对个数变量进行自增。
4、怎么完成1-100之间呢？使用循环。
### 7.4.6.循环嵌套
循环嵌套：其实就是在循环中还有循环。
#### 7.4.6.1.循环嵌套代码演示
#### 7.4.6.2.循环嵌套练习
需求：在屏幕上显示以下图形。
*
**
***
****
*****
思路：
1、看起图形，发现是由5行的组成。
2、每一行都有多个星。
3、有点意思，多行，循环就可以搞定。每到一行，里面有多个星。循环内，还需要循环负责每一行的星的个数。
4、外循环控制行数，内循环控制每一个行的个数。
### 7.4.7.流程控制(continue,break)
#### 7.4.7.1.break语句、continue语句；
break：终止该层循环；
continue：跳过该层循环
注：
①：若这两个语句离开应用范围，存在是没有意义的。
②：这个两个语句单独存在后面都不能有语句，因为执行不到。
③：continue语句是跳过本次循环，继续下次循环。
④：标签的出现，可以让这两个语句作用于指定的循环。
#### 7.4.7.2.break语句、 continue语句举例：
break是终止循环，即在程序中遇到break，那么break所属的循环将结束。
```
for (int x=0; x<3 ;x++ )
{
if(x==1)
break;
System.out.println("x="+x);
}
```
continue是结束本次循环，继续下次循环。循环是不会结束的。
```
for (int x=0; x<10 ;x++ )
{
if(x%2==0)
continue;
System.out.println("x="+x);
}
```
#### 7.4.7.3.使用循环标签；
在多层嵌套循环中，终止/跳过标签标记的那层循环的执行；break <标签> 或 continue <标签>；
```
outer:for (int x=0; x<3 ;x++ )
{
inner:for (int y=0; y<4 ;y++ )
{
System.out.println("x="+x);
break outer;
}
}
```
```
outer:for (int x=0; x<3 ;x++ )
{
inner:for (int y=0; y<4 ;y++ )
{
System.out.println("x="+x);
continue outer;
}
}
```
