Java语言基础组成
关键字
定义:被Java语言赋予了特殊含义的单词。
特点:关键字中所有字母都为小写。
用于定义数据类型的关键字 | ||||
---|---|---|---|---|
class | interface | byte | short | int |
long | float | double | char | boolean |
void | ||||
用于定义数据类型值的关键字 | ||||
true | false | null | ||
用于定义流程控制的关键字 | ||||
if | else | switch | case | default |
while | do | for | break | continue |
return | ||||
用于定义访问权限修饰符的关键字 | ||||
private | protected | public | ||
用于定义类,函数,变量修饰符的关键字 | ||||
abstract | final | static | synchronized | |
用于定义类与类之间关系的关键字 | ||||
extends | implements | |||
用于定义建立实例及引用实例,判断实例的关键字 | ||||
new | this | super | instanceof | |
用于异常处理的关键字 | ||||
try | catch | finally | throw | throws |
用于包的关键字 | ||||
package | ||||
其他修饰符关键字 | ||||
native | strictfp | transient | volatile | assert |
标识符
- 在程序中自定义的一些名称。
- 由26个英文字母大小写,数字: 0-9,符号: _、$ 组成。
- 定义合法标识符规则:
- 数字不可以开头。
- 不可以使用关键字。
- java中严格区分大小写。
注意:在起名字的时候,为了提高阅读性,要尽量有意义。
Java中的名称规范:
- 包名:多单词组成时所有字母都小写。例,
xxxyyyzzz
。 - 类名、接口名:多单词组成时,所有单词的首字母大写。例,
XxxYyyZzz
。 - 变量名和函数名:多单词组成时,第一个单词首字母小写,第二
个单词开始每个单词首字母大写。例,xxxYyyZzz
。 - 常量名:所有字母都大写。多单词时每个单词用下划线连接。例,
XXX_YYY_ZZZ
。
注释
用于注解说明解释程序的文字就是注释。注释提高了代码的阅读性。
java中的注释格式:
- 单行注释,格式:
//注释文字
- 多行注释,格式:
/* 注释文字 */
- 文档注释,格式:
/** 注释文字 */
对于单行和多行注释,被注释的文字,不会被JVM(java虚拟机)解释执行。
对于文档注释,是java特有的注释,其中注释内容可以被JDK提供的工具javadoc
所解析,生成一套以网页文件形式体现的该程序的说明文档。
注释是一个程序员必须要具有的良好编程习惯。
初学者编写程序可以养成习惯:先写注释再写代码。将自己的思想通过注释先整理出来,在用代码去体现,因为代码仅仅是思想的一种体现形式而已。
例,
/**
这个类是用于演示hello world.
作者:李阿昀
版本:V1.0
*/
class Demo {
/*
main函数可以保证该类的独立运行
它是程序的入口
它会被JVM所调用
*/
public static void main(String[] args) {
//这是输出语句用于将括号内的数据打印到控制台。
System.out.println("hello java");
System.out.println("hello world");
}
}
变量与常量
常量表示不能改变的数值。Java中常量的分类:
- 整数常量。所有整数
- 小数常量。所有小数
- 布尔型常量。较为特殊,只有两个数值:
true
、false
- 字符常量。将一个数字、字母或者符号用单引号(
' '
)标识 - 字符串常量。将一个或者多个字符用双引号标识
- null常量。只有一个数值就是:
null
对于整数,java有四种表现形式:
- 十进制:
0-9
,满10进1 - 八进制:
0-7
,满8进1,用0
开头表示 - 十六进制:
0-9、A-F
,满16进1,用0x
或0X
开头表示 - 二进制:
0、1
,满2进1
注意:
- 负数在计算机内存中的二进制表现形式:对应的正数二进制取反加1。
- (在计算机内存中的二进制表现的)负数转换成十进制数:对应的负数二进制减1取反,转成十进制数,最后前面加一个
-
。
变量的概念:
- 内存中的一个存储区域
- 该区域有自己的名称(变量名)和类型(数据类型)
- 该区域的数据可以在同一类型范围内不断变化
为什么要定义变量?
用来不断的存放同一类型的常量,并可以重复使用。(即当数据不确定时,需要对数据进行存储时,就定义一个变量来完成存储动作。)
定义变量的格式:数据类型 变量名 = 初始化值;
。注:格式是固定的,记住格式,以不变应万变。
理解:变量就如同数学中的未知数。
Java语言是强类型语言,对于每一种数据都定义了明确的具体数据类型,在内存中分配了不同大小的内存空间。如图:
Java基本数据类型
数据类型 | 说明 | 所占内存 | 举例 | 备注 |
---|---|---|---|---|
byte | 字节型 | 1 byte | 3, 127 | |
short | 短整型 | 2 bytes | 3, 32767 | |
int | 整型 | 4 bytes | 3, 21474836 | |
long | 长整型 | 8 bytes | 3L, 92233720368L | long最后要有一个L字母(大小写无所谓) |
float | 单精度浮点型 | 4 bytes | 1.2F, 223.56F | float最后要有一个F字母(大小写无所谓) |
double | 双精度浮点型 | 8 bytes | 1.2, 1.2D, 223.56, 223.56D | double最后最好要有一个D字母(大小写无所谓) |
char | 字符型 | 2 bytes | ‘a’, ‘A’ | 字符型数据只能是一个字符,由单引号包围 |
boolean | 布尔型 | 1 bit | true, false |
注意:整数默认为int
,小数默认为double
。
在Java中可以通过Integer.SIZE
这样的方法直接查看基本类型所占内存空间的大小。通过以下程序就能够查看了:
class JavaType {
public static void main(String[] args) {
System.out.println("Byte: " + Byte.SIZE);
System.out.println("Short: " + Short.SIZE);
System.out.println("Integer: " + Integer.SIZE);
System.out.println("Long: " + Long.SIZE);
System.out.println("Float: " + Float.SIZE);
System.out.println("Double: " + Double.SIZE);
System.out.println("Character: " + Character.SIZE);
}
}
输出结果为:(单位是bit
)
Byte: 8(一个字节)
Short: 16(二个字节)
Integer: 32(四个字节)
Long: 64(八个字节)
Float: 32(四个字节)
Double: 64(八个字节)
Character: 16(二个字节)
Boolean
类型有点奇怪,官方文档是这么说的:
This data type represents one bit of information, but its “size” isn’t something that’s precisely defined.
中文翻译:这种数据类型保存一位的信息,但是它的大小却不是精确定义的。
例,Java基本数据类型举例:
int x = 4;
byte b = 2; //2是一个int常量,但是会自动判断2是不是在byte类型的范围内(-128~127),=运算符在给b赋值时,自动完成了强转操作
byte b1 = 128; //编译未通过,超出byte类型的范围
short s = 30000;
long l = 4l;
float f = 2.3f;
double d = 34.56;
char ch = '4';
char ch1 = 'a';
char ch2 = '+';
char ch3 = ' ';
char ch4 = '昀'; //一个中文在内存中占2个字节,而char就是2个字节空间大小
boolean bo = true;
boolean bo1 = false;
自动类型转换(也叫隐式类型转换)和强制类型转换(也叫显式类型转换)。
表达式的数据类型自动提升:
- 所有的byte型、 short型和char型的值将被提升到int型
- 如果一个操作数是long型/float型/double型,计算结果就是long型/float型/double型
试分析System.out.println('a')
与System.out.println('a'+1)
的区别。
System.out.println('a'); //a
System.out.println('a'+1); //98
System.out.println((char)('a'+1)); //b
System.out.println('A'+0); //65
System.out.println('1'+0); //49
System.out.println((char)5);
会输出♣
的形状。
自动类型提升:
byte b = 3;
int x = 4;
x = x + b;//b会自动提升为int类型进行运算。
强制类型转换:
byte b = 3; // 3是一个int常量,但是会自动判断3是不是在byte类型的范围内(-128~127),=运算符在给b赋值时,自动完成了强转操作
b = b + 4;//报错
b = (byte)(b+4);//强制类型转换,强制将b+4的结果转换为byte类型,再赋值给b。
运算符
算术运算符的注意问题
- 如果对负数取模,可以把模数负号忽略不记,如:
5%-2=1
。但被模数是负数就另当别论,如:-5%2=-1
。面试的时候可能会考到。 对于除号“/”,它的整数除和小数除是有区别的:整数之间做除法时,只保留整数部分而舍弃小数部分。如:
int x = 4270; x = x / 1000 * 1000; System.out.println(x); // 4000
字符串数据和任何数据使用
+
都是相连接,最终都会变成字符串。如:System.out.println("5+5="+5+5); //"5+5=55" System.out.println("5+5="+(5+5)); // "5+5=10"
转义字符
转义字符:通过\
来转变后面字母或者符号的含义。如:
\n
:换行
\b
:退格。相当于backspace键
\r
:按下回车键。windos系统中,回车符是由两个字符来表示\r\n
\t
:制表符。相当于tab键
例,
System.out.println("hello\tworld");
System.out.println("\"hello java\"");
System.out.println("\\hello java\\");
char ch = '\'';
赋值运算符
例,
int a, b, c;
a = b = c = 5;
一个面试题:
思考如下代码中s = s + 2;
与s += 2;
的区别?
short s = 3;
s = s + 2;
s += 2;
解:
short s = 3;
s = s + 2; // 编译失败,因为s会被提升为int类型,运算后的结果还是int类型,无法赋值给short类型
s += 2; // 编译通过,因为+=运算符在给s赋值时,自动完成了强转操作
比较运算符
注意:
- 比较运算符的结果都是boolean型,也就是要么是true,要么是false。
- 比较运算符
==
不能误写成=
逻辑运算符
逻辑运算符用于连接boolean类型的表达式。
&
——AND
(与)
boolean类型的表达式 | 逻辑运算符 | boolean类型的表达式 | 结果 |
---|---|---|---|
true | & | true | true |
true | & | false | false |
false | & | true | false |
false | & | false | false |
特点:只要两边的布尔表达式结果有一个为false,那么结果就为false。只有两边都为true,结果为true。
|
——OR
(或)
boolean类型的表达式 | 逻辑运算符 | boolean类型的表达式 | 结果 |
---|---|---|---|
true | | | true | true |
true | | | false | true |
false | | | true | true |
false | | | false | false |
特点:两边只要有一个为true,结果为true,两边都为false,结果为false。
^
——XOR
(异或),就是和|
有点不一样,当true ^ true = false
boolean类型的表达式 | 逻辑运算符 | boolean类型的表达式 | 结果 |
---|---|---|---|
true | ^ | true | false |
true | ^ | false | true |
false | | | true | true |
false | ^ | false | false |
特点:两边相同,结果是false;两边不同,结果为true。
!
——Not
(非),即!true = false
,!fasle = true
。
注意:&和&&的区别以及|和||的区别
&
:无论左边是true是false,右边都运算。
&&
:当左边为false时,右边不运算。
|
:两边都参与运算。
||
:当左边为true时,右边不运算。
位运算符
位运算符 | 运算 | 范例 |
---|---|---|
<< | 左移 | 3 << 2 = 12 → 3 * 2 * 2 = 12 |
>> | 右移 | 3 >> 1 = 1 → 3 / 2 = 1 |
>>> | 无符号右移 | 3 >>> 1 = 1 → 3 / 2 = 1 |
& | 与运算 | 6 & 3 = 2 |
| | 或运算 | 6 |
^ | 异或运算 | 6 ^ 3 = 5 |
~ | 反码 | ~6 = -7 |
位运算是直接对二进制进行运算。
注意:
<<
:其实就是乘以2的移动的位数次幂。>>
:其实就是除以2的移动的位数次幂。
位运算符的细节
位运算符 | 细节 |
---|---|
<< | 空位补0,被移除的高位丢弃,空缺位补0 |
>> | 被移位的二进制最高位是0,右移后,空缺位补0;最高位是1,空缺位补1 |
>>> | 被移位二进制最高位无论是0或者是1,空缺位都用0补 |
& | 二进制位进行&运算,只有1&1时结果是1,否则是0 |
| | 二进制位进行|运算,只有0|0时结果是0,否则是1 |
^ | 任何相同二进制位进行^运算,结果是0:1^1=0,0^0=0;不相同二进制位^运算结果是1:1^0=1,0^1=1 |
例,
7 ^ 4
111
^ 100 (加密)
------
011
^ 100 (解密),密钥:100
------
111 = 7; ----> 7 ^ 4 ^ 4 = 7;
结论:一个数异或同一个数两次,结果还是那个数。
练习:对两个整数变量的值进行互换(不需要第三方变量)。
解:
第一种方式:(使用第三方变量,实际开发时使用)
int n = 3, m = 8;
System.out.println("n = " + n + ", m = " + m);
int temp;
temp = n;
n = m;
m = temp;
System.out.println("n = " + n + ", m = " + m);
第二种方式:(不需要第三方变量)
int n = 3, m = 8;
System.out.println("n = " + n + ", m = " + m);
n = n + m; // 如果n和m的值非常大,容易超出int范围
m = n - m;
n = n - m;
System.out.println("n = " + n + ", m = " + m);
第三种方式:(不需要第三方变量,炫技型)
int n = 3, m = 8;
System.out.println("n = " + n + ", m = " + m);
n = n ^ m;
m = n ^ m; // (n ^ m) ^ m = n;
n = n ^ m; // n ^ (n ^ m) = m;
System.out.println("n = " + n + ", m = " + m);
三元运算符
格式:(条件表达式) ? 表达式1 : 表达式2
- 如果条件为true,运算后的结果是表达式1
- 如果条件为false,运算后的结果是表达式2
例,
int x = 2, y;
y = (x > 1) ? 'a' : 200;
System.out.println("y = " + y); // 97,自动类型提升
练习:取出三个数中的最大值(三元运算符的嵌套)。
int a = 2;
int b = 10;
int c = 3;
int max = a > b ? (a > c ? a : c) : (b > c ? b : c); // 取出三个数中的最大值(三元运算符的嵌套)
System.out.println("max = " + max);
程序流程控制
判断结构
if else
结构简写格式:变量 = (条件表达式) ? 表达式1 : 表达式2;
三元运算符的特点:
- 好处:可以简化
if else
代码 - 弊端:因为是一个运算符,所以运算完必须要有一个结果。
if语句练习:
练习一:根据用户的给定的数值,显示该数值对应的星期。如:2,星期二。
解:
class IfTest
{
public static void main(String[] args)
{
/*
需求:根据用户的给定的数值,显示该数值对应的星期。如:2,星期二。
思路:
1,咋获取这个数值呢?来源有很多,不确定,只要是不确定的数据,都用变量存储。
只要操作该变量即可。
2,数值不确定,如何显示对应的星期呢?那就需要对该数值进行判断。
3,咋显示呢?通过输出语句就可以显示在屏幕上。
步骤:
1,定义变量,记录数据。
2,通过判断结构语句对该变量进行判断。
3,根据不同的条件,通过输出语句显示不同的结果。
*/
// 1,定义变量,记录数据。
int week = 9;
// 2,通过判断结构语句对该变量进行判断。
if (week == 1)
// 3,根据不同的条件,通过输出语句显示不同的结果。
System.out.println(week + "对应的是星期一");
else if (week == 2)
System.out.println(week + "对应的是星期二");
else if (week == 3)
System.out.println(week + "对应的是星期三");
else if (week == 4)
System.out.println(week + "对应的是星期四");
else if (week == 5)
System.out.println(week + "对应的是星期五");
else if (week == 6)
System.out.println(week + "对应的是星期六");
else if (week == 7)
System.out.println(week + "对应的是星期日");
else
System.out.println(week + "没有对应的星期");
}
}
练习二:根据用户的给定月份数据,显示该月份在哪个季节。
解:
第一种方式:
//需求:根据用户的给定月份数据,显示该月份在哪个季节。
// 3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12,1,2 冬季
class IfTest {
public static void main(String[] args) {
int x = 4;
if(x == 3 || x == 4 || x == 5) {
System.out.println(x + "春季");
} else if(x == 6 || x == 7 || x == 8) {
System.out.println(x + "夏季");
} else if(x == 9 || x == 10 || x == 11) {
System.out.println(x + "秋季");
} else if(x == 12 || x == 1 || x == 2) {
System.out.println(x + "冬季");
} else {
System.out.println(x + "月份不存在");
}
}
}
第二种方式:
class IfTest {
public static void main(String[] args) {
int x = 4;
if(x > 12 || x < 1) {
System.out.println(x + "月份不存在");
} else if(x >= 3 && x <= 5) {
System.out.println(x + "春季");
} else if(x >= 6 && x <= 8) {
System.out.println(x + "夏季");
} else if(x >= 9 && x <= 11) {
System.out.println(x + "秋季");
} else {
System.out.println(x + "冬季");
}
}
}
选择结构
switch语句特点:
- switch语句选择的类型只有四种:
byte
,short
,int
,char
。但JDK7.0
对switch语句进行了增强,可以判断字符串,JDK5.0
对switch语句也进行了增强,可以对枚举类型进行判断。 - case之间与default没有顺序。先执行第一个case,没有匹配的case执行default。
- 结束switch语句的两种情况:遇到break,执行到switch语句结束。
- 如果匹配的case或者default没有对应的break,那么程序会继续向下
执行,运行可以执行的语句,直到遇到break或者switch结尾结束(switch特性——case穿透性)。
例,
int x = 3;
switch(x) { // byte,short,int,char
default:
System.out.println("d");
case 4:
System.out.println("a");
case 6:
System.out.println("b");
break;
case 2:
System.out.println("c");
break;
}
以上代码输出:
d
a
b
switch语句练习:
练习一:根据用户的给定的数值,显示该数值对应的星期。如:2,星期二。
解:
class SwitchTest
{
public static void main(String[] args)
{
// 需求1:根据用户的给定的数值,显示该数值对应的星期。如:2,星期二。
int week = 9;
switch (week)
{
case 1:
System.out.println(week + "对应的是星期一");
break;
case 2:
System.out.println(week + "对应的是星期二");
break;
case 3:
System.out.println(week + "对应的是星期三");
break;
case 4:
System.out.println(week + "对应的是星期四");
break;
case 5:
System.out.println(week + "对应的是星期五");
break;
case 6:
System.out.println(week + "对应的是星期六");
break;
case 7:
System.out.println(week + "对应的是星期日");
break;
default:
System.out.println(week + "没有对应的星期");
break;
}
}
}
练习二:根据用户的给定月份数据,显示该月份在哪个季节。
class SwitchTest {
public static void main(String[] args) {
int x = 4;
switch(x) {
case 3:
case 4:
case 5:
System.out.println(x + "春季");
break;
case 6:
case 7:
case 8:
System.out.println(x + "夏季");
break;
case 9:
case 10:
case 11:
System.out.println(x + "秋季");
break;
case 12:
case 1:
case 2:
System.out.println(x + "冬季");
break;
default:
System.out.println("nono");
}
}
}
if
和switch
语句很像,具体什么场景下,应用哪个语句呢?
答:如果判断的具体数值不多,而且符合byte
short
int
char
这四种类型,虽然两个语句都可以使用,但建议使用switch
语句,因为效率稍高。
其他情况:对区间判断,对结果为boolean类型判断,使用if,if的使用范围更广。
循环结构
while
:先判断条件,只有条件满足才执行循环体。
do while
:先执行循环体,再判断条件,条件满足,再继续执行循环体。
简单一句话:do while
无论条件是否满足,循环体至少执行一次。
for
循环格式:
for(初始化表达式;循环条件表达式;循环后的操作表达式)
{
执行语句;
}
例1,
class ForDemo {
public static void main(String[] args) {
for (int x = 0; x < 3; x++) {
System.out.println("x = " + x);
}
//System.out.println("x ======= " + x);
int y = 0;
while (y < 3) {
System.out.println("y = " + y);
y++;
}
System.out.println("y ======= " + y);
}
}
从以上代码中可得:
- 变量有自己的作用域,对于for来讲,如果将用于控制循环的增量定义在for语句中,那么该变量只在for语句内有效,for语句执行完毕,该变量在内存中被释放。而while循环使用的变量在循环结束后还可以继续使用。
- for和while可以进行互换。如果需要定义循环增量,用for更为合适。
总结:
什么时候使用循环结构?
答:当要对某些语句执行很多次时,就使用循环结构。
例2,for
循环还可以写成:
int x = 1;
for (System.out.println("a"); x < 3; System.out.println("c"), x++) {
System.out.println("d");
}
输出结果为:
a
d
c
d
c
例3,
for (int y = 0; y < 3; y++) {
}
以上代码可以写成如下代码:
int y = 0;
for ( ; y < 3; ) {
y++;
}
例4,最简单无限循环格式:
for(;;) {
}
while(true) {
}
无限循环存在的原因是并不知道循环多少次,而是根据某些条件,来控制循环。
练习一:获取1~10的和,并打印。
解:
class ForTest2 {
public static void main(String[] args) {
int sum = 0;
for (int x = 1; x <= 10; x++) {
sum += x;
}
System.out.println("sum = " + sum);
}
}
其实这就是累加思想。原理:通过变量记录住每次变化的结果,并通过循环的形式,进行累加动作。
练习二:获取1~100之间7的倍数的个数,并打印。
解:
/*
获取1~100之间7的倍数的个数,并打印
思路:
1.先对1~100进行循环(遍历)
2.在遍历的过程中,定义条件,只对7的倍数进行操作
3.因为7的倍数不确定,只要符合条件,就通过一个变量来记录这个变化的次数。
步骤:
1.定义循环语句,选择for语句
2.在循环中定义判断,只要是7的倍数即可,使用if语句。条件:7的倍数 x % 7 == 0;
3.定义变量,该变量随着7的倍数的出现而自增
*/
class ForTest3 {
public static void main(String[] args) {
int count = 0;
for (int x = 1; x <= 100; x++) {
if(x % 7 == 0) {
count++;
}
}
System.out.println("count = " + count);
}
}
其实这就是计数器思想,原理:通过一个变量记录住数据的状态变化,也需要通过循环完成。
for
循环嵌套
例1,使用for
循环打印如下所示的图形:
****
****
****
解:对于打印长方形,外循环控制行数,内循环控制每一行的列数,也就是一行中元素的个数。代码如下:
class ForForDemo {
public static void main(String[] args) {
for (int x = 0; x < 3; x++) {
for (int y = 0; y < 4; y++) {
System.out.print("*");
}
System.out.println();
}
}
}
例2,使用for
循环打印如下所示的图形:
*****
****
***
**
*
解:发现图形有很多行,每一个行有很多列,所以得使用嵌套循环。原理:形象说法,大圈套小圈。代码如下:
class ForForDemo {
public static void main(String[] args) {
for (int x = 0; x < 5; x++) {
for (int y = x; y < 5; y++) {
System.out.print("*");
}
System.out.println();
}
}
}
例3,使用for
循环打印如下所示的图形:
*
**
***
****
*****
解:
class ForForDemo {
public static void main(String[] args) {
for (int x = 0; x < 5; x++) {
for (int y = 0; y <= x; y++) {
System.out.print("*");
}
System.out.println();
}
}
}
总结:不是规律的规律:
- 尖朝上,可以改变条件,让条件随着外循环变化
- 尖朝下,可以初始化值,让初始化值随着外循环变化
例4,使用for
循环打印如下所示的图形:
1
12
123
1234
12345
解:
class ForForDemo {
public static void main(String[] args) {
for (int x = 0; x < 5; x++) {
for (int y = 1; y <= x + 1; y++) {
System.out.print(y);
}
System.out.println();
}
}
}
例5,打印一个99乘法表。
解:
class ForForDemo {
public static void main(String[] args) {
for (int x = 1; x <= 9; x++) {
for (int y = 1; y <= x; y++) {
System.out.print(y + "*" + x + "=" + (y*x) + "\t");
}
System.out.println();
}
}
}
例6,打印如下所示的图形:
□□□□*
□□□*□*
□□*□*□*
□*□*□*□*
*□*□*□*□*
注意:□
表示空格。
解:
class ForForDemo {
public static void main(String[] args) {
for (int x = 0; x < 5; x++) {
for (int y = x + 1; y < 5; y++) {
System.out.print(" ");
}
for (int z = 0; z <= x; z++) {
System.out.print("* ");
}
System.out.println();
}
}
}
其他流程控制语句
break(跳出),应用于选择结构和循环结构。
例,
w:for (int x = 0; x < 3; x++) {
for (int y = 0; y < 4; y++) {
System.out.println("x = " + x);
break w;
}
}
可以给循环标号,然后通过break
指定跳出哪个循环。
continue(继续),只能作用于循环结构,继续循环。特点:结束本次循环,继续下一次循环。
例1,
for (int x = 1; x <= 10; x++) {
if(x % 2 == 1)
continue;
System.out.println("x = " + x);
}
例2,也可以给循环标号,然后通过continue
指定继续哪个循环。
w:for (int x = 0; x < 3; x++) {
for (int y = 0; y < 4; y++) {
System.out.println("x = " + x);
continue w;
}
}
记住:
break
和continue
语句作用的范围break
和continue
单独存在时,下面不可以有任何语句,因为都执行不到