JAVA中的关键字和保留字.docx
《JAVA中的关键字和保留字.docx》由会员分享，可在线阅读，更多相关《JAVA中的关键字和保留字.docx（15页珍藏版）》请在冰豆网上搜索。
JAVA中的关键字和保留字
Java关键字列表（依字母排序共51组）:
abstract,用在类的声明中来指明一个类是不能被实例化的，但是可以被其它类继承。
一个抽象类可以使用抽象方法，抽象方法不需要实现，但是需要在子类中被实现
assert,
boolean,
break,用来改变程序执行流程，立刻从当前语句的下一句开始执行从。
如果后面跟有一个标签，则从标签对应的地方开始执行
byte,
case,用来定义一组分支选择，如果某个值和switch中给出的值一样，就会从该分支开始执行。
catch,用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。
char,用来定义一个字符类型
class,
const,
continue,用来打断当前循环过程，从当前循环的最后重新开始执行，如果后面跟有一个标签，则从标签对应的地方开始执行。
default,
do,用来声明一个循环，这个循环的结束条件可以通过while关键字设置
double,用来定义一个double类型的变量
else,如果if语句的条件不满足就会执行该语句。
enum,
extends,
final,
finally,用来执行一段代码不管在前面定义的try语句中是否有异常或运行时错误发生。
float,用来定义一个浮点数变量.
for,用来声明一个循环。
程序员可以指定要循环的语句，推出条件和初始化变量。
if,生成一个条件测试，如果条件为真，就执行if下的语句。
implements,在类的声明中是可选的，用来指明当前类实现的接口.
import,在源文件的开始部分指明后面将要引用的一个类或整个包，这样就不必在使用的时候加上包的名字。
instanceof,用来测试第一个参数的运行时类型是否和第二个参数兼容。
int,用来定义一个整形变量
interface,
long,用来定义一个long类型的变量。
native,
new,
package,
private,用在方法或变量的声中。
它表示这个方法或变量只能被这个类的其它元素所访问。
protected,在方法和变量的声明中使用，它表示这个方法或变量只能被同一个类中的，子类中的或者同一个包中的类中的元素所访问
public,在方法和变量的声明中使用，它表示这个方法或变量能够被其它类中的元素访问。
return,用来结束一个方法的执行。
它后面可以跟一个方法声明中要求的值。
short,用来定义一个short类型的变量。
static,用来定义一个变量为类变量。
类只维护一个类变量的拷贝，不管该类当前有多少个实例。
同样能够用来定义一个方法为类方法。
类方法通过类名调用而不是特定的实例，并且只能操作类变量。
strictfp,
super,
switch,
synchronized,
this,用来代表它出现的类的一个实例。
this可以用来访问类变量和类方法。
throw,允许用户抛出一个exception对象或者任何实现throwable的对象
throws,用在方法的声明中来说明哪些异常这个方法是不处理的，而是提交到程序的更高一层。
transient,用来表示一个域不是该对象串行化的一部分。
当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。
try,用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。
用来定义一个可能抛出异常语句块。
如果一个异常被抛出，一个可选的catch语句块会处理try语句块中抛出的异常。
同时，一个finally语句块会被执行，无论一个异常是否被抛出。
void,用在Java语言的方法声明中说明这个方法没有任何返回值。
"void"也可以用来表示一句没有任何功能的语句。
volatile,用在变量的声明中表示这个变量是被同时运行的几个线程异步修改的。
while，用来定义一段反复执行的循环语句。
循环的退出条件是while语句的一部分。
Java保留字列表（依字母排序共14组）:
Java保留字是指现有Java版本尚未使用但以后版本可能会作为关键字使用。
byValue,
cast,
false,
future,
generic,
inner,
operator,
outer,
rest,
true,
var，
goto，
const,
null
java中的50个关键字和关键字的意思
Abstract抽象的
一个Java语言中的关键字，用在类的声明中来指明一个类是不能被实例化的，但是可以被其它类继承。
一个抽象类可以使用抽象方法，抽象方法不需要实现，但是需要在子类中被实现
break
一个Java的关键字，用来改变程序执行流程，立刻从当前语句的下一句开始执行从。
如果后面跟有一个标签，则从标签对应的地方开始执行
case
Java语言的关键字，用来定义一组分支选择，如果某个值和switch中给出的值一样，就会从该分支开始执行。
catch
Java的一个关键字，用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。
char
Java语言的一个关键字，用来定义一个字符类型
continue
一个Java的关键字，用来打断当前循环过程，从当前循环的最后重新开始执行，如果后面跟有一个标签，则从标签对应的地方开始执行。
do
一个Java语言的关键字，用来声明一个循环，这个循环的结束条件可以通过while关键字设置
double
一个Java语言的关键字，用来定义一个double类型的变量
else
一个Java语言的关键字，如果if语句的条件不满足就会执行该语句。
final
一个Java语言的关键字。
你只能定义一个实体一次，以后不能改变它或继承它。
更严格的讲：
一个final修饰的类不能被子类化，一个final修饰的方法不能被重写，一个final修饰的变量不能改变其初始值。
finally
一个Java语言的关键字，用来执行一段代码不管在前面定义的try语句中是否有异常或运行时错误发生。
float
一个Java语言的关键字，用来定义一个浮点数变量
for
一个Java语言的关键字，用来声明一个循环。
程序员可以指定要循环的语句，推出条件和初始化变量。
if
Java编程语言的一个关键字，用来生成一个条件测试，如果条件为真，就执行if下的语句。
implements
Java（TM）（java虚拟机）编程语言的一个关键字，在类的声明中是可选的，用来指明当前类实现的接口。
import
Java（TM）编程语言的一个关键字，在源文件的开始部分指明后面将要引用的一个类或整个包，这样就不必在使用的时候加上包的名字。
instanceof
一个二操作数的Java（TM）语言关键字，用来测试第一个参数的运行时类型是否和第二个参数兼容。
int
Java（TM）的一个关键字，用来定义一个整形变量
Java（TM）的一个关键字，用来定义一系列的方法和常量。
它可以被类实现，通过implements关键字。
long
Java语言的一个关键字，用来定义一个long类型的变量。
private
Java语言的一个关键字，用在方法或变量的声中。
它表示这个方法或变量只能被这个类的其它元素所访问。
protected
Java语言的一个关键字，在方法和变量的声明中使用，它表示这个方法或变量只能被同一个类中的，子类中的或者同一个包中的类中的元素所访问。
public
Java语言的一个关键字，在方法和变量的声明中使用，它表示这个方法或变量能够被其它类中的元素访问。
return
Java语言的一个关键字，用来结束一个方法的执行。
它后面可以跟一个方法声明中要求的值。
short
Java语言的关键字，用来定义一个short类型的变量。
static
Java语言的关键字，用来定义一个变量为类变量。
类只维护一个类变量的拷贝，不管该类当前有多少个实例。
"static"同样能够用来定义一个方法为类方法。
类方法通过类名调用而不是特定的实例，并且只能操作类变量。
this
Java语言的关键字，用来代表它出现的类的一个实例。
this可以用来访问类变量和类方法。
throw
Java语言的关键字，允许用户抛出一个exception对象或者任何实现throwable的对象
throws
Java语言的关键字，用在方法的声明中来说明哪些异常这个方法是不处理的，而是提交到程序的更高一层。
transient
Java语言的关键字，用来表示一个域不是该对象串行化的一部分。
当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。
try
Java语言的关键字，用来定义一个可能抛出异常语句块。
如果一个异常被抛出，一个可选的catch语句块会处理try语句块中抛出的异常。
同时，一个finally语句块会被执行，无论一个异常是否被抛出。
void
Java语言的关键字，用在Java语言的方法声明中说明这个方法没有任何返回值。
"void"也可以用来表示一句没有任何功能的语句。
volatile
Java语言的关键字，用在变量的声明中表示这个变量是被同时运行的几个线程异步修改的。
while
Java语言的一个关键字，用来定义一段反复执行的循环语句。
循环的退出条件是while语句的一部分。
关于break和continue。
continue语句与break语句相关，但较少用到。
continue语句用于使其所在的for、while或do-while语句开始下一次循环。
在while与do-while语句中，continue语句的执行意味着立即执行测试部分；在for循环语句中，continue语句的执行则意味着使控制传递到增量部分。
测试代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
publicclassLabledFor{
//staticTestmonitor=newTest（）;
publicstaticvoidmain（String[]args）{
inti=0;
outer:
for（;true;）{
inner:
for（;i<10;i++）{
"i="+i）;
if（i==2）{
"continue"）;
continue;
}
if（i==3）{
"break"）;
i++;
break;
}
if（i==7）{
"continueouter"）;
i++;
continueouter;
}
if（i==8）{
"breakouter"）;
breakouter;
}
for（intk=0;k<5;k++）{
if（k==3）{
"continueinner"）;
continueinner;
}
}
}
}
}
}
结果
i=0
continueinner
i=1
continueinner
i=2
break
i=3
continue
i=4
continueinner
i=5
continueinner
i=6
continueinner
i=7
continueouter
i=8
Java保留关键字
Java语言有51个保留关键字，其中const和goto虽然被保留但未被使用。
你不能使用保留关键字来命名类、方法或变量。
一、保留关键字
数据类型：
Booleanintlongshortbytefloatdoublecharclassinterface
流程控制：
ifelsedowhileforswitchcasedefaultbreakcontinuereturntrycatchfinally
修饰符：
publicprotectedprivatefinalvoidstaticstrictfpabstracttransient
synchronizedvolatilenative
动作：
packageimportthrowthrowsextendsimplementsthisSuperinstanceofnew
保留字：
truefalsenullgotoconst
二、访问修饰符：
访问修饰符：
public,protected,private
*只能应用于类的成员变量。
（局部变量只能在函数的范围内可见，不能使用访问修饰符）
*能够用来修饰类本身。
（protected,private不能用于顶级类，只能用于内部类）
*能够应用于成员方法和构造函数。
下面是一个例子：
packageExamples;
publicclassHelloWorld02{
//以下定义了三个了类成员变量
publicStringstr1="Hello";//可被你程序中的任何其他代码访问
protectedStringstr2="World!
";//程序中同一包的成员和不同包中的该类子类可以访问
privateStringstr3="";//仅该类中的成员可以访问
Stringstr=str1+str3+str2;//不使用修饰符的话，变量的访问控制在所在包内为public，
//不能被所在包外的代码存取
//以下定义了三个使用不同修饰符和不同参数的构造方法。
publicHelloWorld（）{
;
}
protectedHelloWorld（longl）{
"Use\"protected\"constructor!
Andlis["+l+"]"）;
;
}
privateHelloWorld（floatf）{
"Use\"private\"constructor!
Andfis["+f+"]"）;
;
}
//声明构造方法为void类型是合法的.不过因为没有返回值,所以不能用来创建新对象.
publicvoidHelloWorld（）{
+"Usethevoidconstructor!
"）;
}
publicstaticvoidmain（String[]args）{
HelloWorldhw1=newHelloWorld（）;//使用无参数的构造方法
HelloWorldhw2=newHelloWorld（5）;//虽然5是int类型，但会自动提升成long类型
HelloWorldhw3=newHelloWorld（5L）;
HelloWorldhw5=newHelloWorld（3.14f）;//但float类型则必须指明，否则会出错
hw5.HelloWorld（）;//无返回值的构造方法只能这样调用
（newHelloWorld（））.HelloWorld（）;//这里创建了一个匿名类对象并调用无返回值的构造方法
}
}
总结：
请认真思考一下：
（1）public、protected、private可用来修饰哪些成员？
使用这些修饰符的成员的访问控制是怎样的？
没有指定访问修饰符的成员的访问控制是怎样的？
*public、protected和private可以用来修饰类成员变量、方法、构造方法和内部类；
public可以用来修饰顶级类，但protected和private则不行。
*类成员访问控制可见下表：
Private成员
默认成员
Protected成员
Public成员
同一类中可见
是
是
是
是
同一包中对子类可见
否
是
是
是
同一包中对非子类可见
否
是
是
是
不同包中对子类可见
否
否
是
是
不同的包中对非子类可见
否
否
否
是
简单总结一下，（按它们的访问范围由大到小排列）：
public：
任何地方均可访问
protected：
同一包和子类可见
默认：
同一包中可见
private：
仅该类内部可见
注意事项：
*每一个java文件中可以包含多个类，但只能存在一个public顶级类，如果声明了两个顶级类的话，则会出现编译错误。
二、部分其他修饰符
this：
Java中定义了this关键字来访问当前对象实例内的成员。
当局部变量和类实例内的类变量同名时，在这个局部变量所作用区域内类变量就被隐藏了，必须使用this来指明。
static：
有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。
通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它所在类使用，而不必引用所在类的实例。
将类中的成员声明为static就能实现这样的效果。
声明为static的变量实质就是全局变量。
当声明一个对象（某个类的实例）时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。
声明为static的方法有以下三条限制：
*它们只能访问static数据
*它们仅能调用其他的static方法
*它们不能以任何方式引用this或super
实例分析：
packageExamples;
publicclassStaticDemo{
publicstaticvoidmain（String[]args）{
;//不用创建MyStaticClass的实例就能访问它的str变量
//;这句是错误的。
MyStaticClassmsc=newMyStaticClass（）;//这里创建MyStaticClass的一个实例
"Aftercreateinstance:
"）;
msc.printString（）;
}
}
classMyStaticClass{
staticStringstr="HelloWorld!
";
Stringstr2;
voidsetString（Strings）{
str2=s;
}
staticvoidsetNewString（Strings）{
str=s;
}
staticvoidprintString（）{
//setString（str）;在static方法中调用非static方法是错误的
//;也不能访问非static变量
//Java中是先检测static变量再检测static方法的
;//可以正常访问static变量
setNewString（"StaticmethodisOK!
"）;//正常调用static方法
;
}
}
final：
一个变量可以被声明为final，这样做的目的是阻止它的内容被修改。
这意味着在声明final变量的时候，你必须初始化它。
一个final变量实质上是一个常数，为final变量的所有字母选择大写是一个普遍的编码约定。
声明为final的变量在实例中不占用内存。
声明成final的方法不能被重载。
通常，Java在运行时动态的调用方法，这叫做后期绑定（latebinding）；由于被声明为final的方法不能被重载，那么对final方法的调用可以在编译时解决，这叫做早期绑定（earlybingding）。
声明为final的类不能被其他类继承。
声明一个final类含蓄的宣告了它的所有方法也都是final的。
所以，声明一个既是abstract的，又是final的类是不合法的，因为抽象类本身是不完整的，它依靠它的子类提供完整的实现。
strictfp：
Java2向Java语言增加了一个新的关键字strictfp。
与Java2同时产生的浮点运算计算模型很轻松的使某些处理器可以以较快速度进行浮点运算（例如奔腾处理器）。
这个浮点运算计算模型在计算过程中，不需要切断某些中介值。
如果用strictfp来修饰类或方法，可以确保浮点运算（以及所有切断）正如它们在早期Java版本中那样准确（即使用原始的浮点运算模型）。
切断只影响某些操作的指数。
当一个类被strictfp修饰，所有该类的方法都自动被strictfp修饰。
坦白说，很多程序员从未用过strictfp，因为它只对非常少的问题有影响。
native：
有时你希望调用不是用Java语言写的子程序，或者你希望调用一个专用的第三方的库，例如统计学包。
虽然这种情况比较少，但Java提供了native关键字，该关键字用来声明本机代码方法。
为声明一个本机方法，在该方法之前用native修饰符，但是不要定义任何方法体。
例如：
publicnativeintmeth（）;
声明本机方法后，必须编写本机方法并要执行一系列复杂的步骤使它与Java代码链接。
很多本机方法是用C写的。
把C代码结合到Java程序中的机制是调用JavaNativeInterface（JNI）。
transient：
如果用transient声明一个实例变量，当对象储存时，它的值不需要维持。
例如：
classT{
transientinta;//willnotpersist
intb;//willpersist
}
这里，如果T类的一个对象被写入一个持久的存储区域，a的内容不被保存，但b将被保存。
volatile：
（不是很明白，待研究）
volatile修饰符告诉编译器被volatile修饰的变量可以被程序的其他部分改变。
一种这样的情形是多线程程序。
在多线程程序里，有时两个或更多的线程共享一个相同的实例变量。
考虑效率的问题，每个线程可以自己保存该共享变量的私有拷贝。
实际的（或主要的）变量副本在不同的时候更新，例如当进入synchronized方法时。
当这种方法运行良好时，它在时间上会是低效的。
在某些情况下，真正要紧的是变量主副本的值会体现当前的状态。
为保证这点，仅需把变量定义成volatile型，它告诉编译器它必须总是使用volatile变量的主副本（或者至少总是保持一些私有的最新的主副本的拷贝，反之亦然），同时
升级会员 