JAVA关键字大全.doc

abstract
boolean
break -
byte
case
catch
char
class
continue
default
do
double
else
extends
false
final
finally
float
for
if
implements
import
instanceof -
int -
interface
long -
native
new
null
package
private
protected
public
return
short
static
super
switch
synchronized
this
throw
throws
transient
try
true
void
volatile
while
- 45 -

JAVA关键字单词记忆表

1.abstract
解释：抽象，抽象的
用法：类修饰符的一种，可以用来修饰类，方法，被修饰的类不能够实例化（即不能用new关键字得到对象），被修饰的方法不能够实现。一个抽象类中不一定要有抽象方法，但是一个类里面有抽象方法就一定是抽象类。如果由类要继承抽象类的话，必须要实现里面的抽象方法。构造方法和静态方法不可以修饰为抽象。
abstract 关键字可以修改类或方法。
abstract 类可以扩展（增加子类），但不能直接实例化。
abstract 方法不在声明它的类中实现，但必须在某个子类中重写。
-示例-
public abstract class MyClass{
}
public abstract String myMethod();
-注释-
采用 abstract 方法的类本来就是抽象类，并且必须声明为 abstract。
abstract 类不能实例化。
仅当 abstract 类的子类实现其超类的所有 abstract 方法时，才能实例化 abstract 类的子类。这种类称为具体类，以区别于 abstract 类 。
如果 abstract 类的子类没有实现其超类的所有 abstract 方法，该子类也是 abstract 类。
abstract 关键字不能应用于 static、private 或 final 方法，因为这些方法不能被重写，因此，不能在子类中实现。
final 类的方法都不能是 abstract，因为 final 类不能有子类。
1> abstract抽象用在类的声明中来指明一个类是不能被实例化的，但是可以被其他类继承。一个抽象类可以使用抽象方法，抽象方法不需要实现，但是需要在子类中被实现。它的用途是向子类提供通用的信息。抽象类可以包含正常的类包含的任何东西，也就是说，类和实例变量，以及带有任何修饰词的方法。只有抽象类可能有抽象方法。如果一个不是抽象的类包含一个抽象方法，那么将会出现编译错误。
例子：如果下列的一个成立，那么一个有抽象方法：
a.它显式的声明了一个abstract方法。
b.它从它的直接父类继承了一个抽象方法。
c.一个直接的类的父借口声明或继承了它的一个方法（这因此必须是abstract）
2>如果用户声明private,static,和final方法为abstarct，编译错误将出现。不可能重设一个private方法，因为一个abstarct  private永远不能被实现。static方法总是可用的，因此必须有一个实现；static abstract将永远没有实现。final方法不能被重设，因此不回有final abstract方法的实现。

2.boolean
解释：数据类型，布尔型,它的取值只能为true或者false。
用法：用来定义临时变量、形参、属性的数据类型。格式如下：boolean 【变量名、形参名、属性名】
变量的值可以是 true 或 false。
-示例-
boolean valid = true;
if (valid){

}
-注释-
boolean 变量只能以 true 或 false 作为值。
boolean 不能与数字类型相互转换。
包含 boolean 操作数的表达式只能包含 boolean 操作数。
Boolean 类是 boolean 原始类型的包装对象类。

3.break
用法：用于提前退出 for、while 或 do 循环，或者在 switch 语句中用来结束 case 块。
-示例-
for (i=0; i){
break;
}
}
int type = ;
switch (type){
case 1:
t>
break;
case 2:

break;
default:

}
-注释-
break 总是退出最深层的 while、for、do 或 switch 语句。

4.byte
解释：数据类型，字节型
用法：用来定义临时变量、形参、属性的数据类型。格式如下：byte 【变量名、形参名、属性名】
byte 是 Java 原始类型。
byte 可存储在 [-128, 127] 范围以内的整数值。
-示例-
byte b = 124;
-注释-
Byte 类是 byte 原始类型的包装对象类。它定义代表此类型的值的范围的 MIN_VALUE 和 MAX_VALUE 常量。
Java 中的所有整数值都是 32 位的 int 值，除非值后面有 l 或 L（如 235L），这表示该值应解释为 long。

5.case
用法：用来标记 switch 语句中的每个分支。
-示例-
int arg = ;
switch (arg){
case 1:

break;
case 2:

break;
default:

break;
}
-注释-
case 块没有隐式结束点。break 语句通常在每个 case 块末尾使用，用于退出 switch 语句。
如果没有 break 语句，执行流将进入所有后面的 case 和/或 default 块。

6.catch
解释：捕捉，捕获
用法：当发现被监视的代码中有异常出现的时候,catch就用相对应的异常类进行捕捉。并且打印出相应的异常信息。catch块，必须要配合try块一起使用，不能单独使用，也不能直接和finally块一起使用。
catch 关键字用来在 try-catch 或 try-catch-finally 语句中定义异常处理块。
-示例-
try{
<可能引发异常的块>
}
catch (<java.lang.Exception 或子类> e){
<处理异常 e 的代码>
}
try{
<可能引发其他异常的块>
}
catch (FooException e){
<处理 FooException e 的代码>
}
catch (BarException e){
<处理 BarException e 的代码>
}
try{
<可能引发异常的块>
}
catch ( e){
<处理异常 e 的代码>
}
finally{
<有异常或无异常情况下都执行的语句>
}
-注释-
开始和结束标记 { 和 } 是 catch 子句语法的一部分，即使该子句只包含一个语句，也不能省略这两个标记。
每个 try 块都必须至少有一个 catch 或 finally 子句。
如果某个特定异常类未被任何 catch 子句处理，该异常将沿着调用栈递归地传播到下一个封闭 try 块。如果任何封闭 try 块都未捕获到异常，Java 解释器将退出，并显示错误消息和堆栈跟踪信息。

7.char
用法：char 是 Java 原始类型。
char 变量可以存储一个 Unicode 字符。
-示例-
char delimiter = ';';
-注释-
可以使用下列 char 常量：
\b - 空格
\f - 换页
\n - 换行
\r - 回车
\t - 水平制表符
\' - 单引号
\" - 双引号
\" - 反斜杠
\xxx - 采用 xxx 编码的 Latin-1 字符。\x 和 \xx 均为合法形式，但可能引起混淆。
\uxxxx - 采用十六进制编码 xxxx 的 Unicode 字符。
Character 类包含一些可用来处理 char 变量的 static 方法，这些方法包括 isDigit()、isLetter()、isWhitespace() 和 toUpperCase()。
char 值没有符号。

8.class
解释：类，种类
用法：定义一个类，这时候定义的类，在内存空间里面没有分配空间。换句话说，它还没有存在于现实生活中，它不是一个实体。类里面有方法有属性，要想访问它里面的方法和属性就要通过对象去使用。
格式如下: 访问权限修饰符 class 类名{}
class 关键字用来声明新的 Java 类，该类是相关变量和/或方法的集合。
类是面向对象的程序设计方法的基本构造单位。类通常代表某种实际实体，如几何形状或人。类是对象的模板。每个对象都是类的一个实例。
要使用类，通常使用 new 操作符将类的对象实例化，然后调用类的方法来访问类的功能。
-示例-
public class Rectangle{
float width;
float height;
public Rectangle(float w, float h){
width = w;
height = h;
}
public float getWidth(){
return width;
}
public float getHeight(){
return height;
}
}

9.continue
用法：continue 关键字用来跳转到 for、while 或 do 循环的下一个迭代。
-示例-
for (i=0; i
if (){
continue;
}

}
-注释-
continue 总是跳到最深层 while、for 或 do 语句的下一个迭代。

10.default
用法：default 关键字用来标记 switch 语句中的默认分支。
-示例-
int arg = ;
switch (arg){
case 1:

break;
case 2:

break;
default:

break;

}
-注释-
default 块没有隐式结束点。break 语句通常在每个 case 或 default 块的末尾使用，以便在完成块时退出 switch 语句。
如果没有 default 语句，其参数与任何 case 块都不匹配的 switch 语句将不执行任何操作。

11.do
用法：do 关键字用于指定一个在每次迭代结束时检查其条件的循环。
-示例-
do{

}
while (!found);
-注释-
do 循环体至少执行一次。
条件表达式后面必须有分号。

12.double
用法：double 是 Java 原始类型。

用法：double 变量可以存储双精度浮点值。
-示例-
double ratio = .01;
double diameter = 6.15;
double height = 1.35E03; // 1.35 * 103 或 1350.0
double height = 1e-2; // 1.0 * 10-2 或 0.01
-注释-
由于浮点数据类型是实际数值的近似值，因此，一般不要对浮点数值进行是否相等的比较。
Java 浮点数值可代表无穷大和 NaN（非数值）。Double 包装对象类用来定义常量 MIN_VALUE、MAX_VALUE、NEGATIVE_INFINITY、POSITIVE_INFINITY 和 NaN。

13.else
用法：else 关键字总是在 if-else 语句中与 if 关键字结合使用。else 子句是可选的，如果 if 条件为 false，则执行该子句。
-示例-
if (condition){

}
else{

}

14.extends
解释：扩充，扩展
用法：一个类继承另一个类的关键字，当出现了这个关键字，两个类就有了继承关系，extends前面的类，我们称之为父类。extends后面的类，我们称之为子类。有了继承关系之后，我们就说子类拥有父类继承下来的所有非私有的成员（包括了属性，方法），但是不包括构造方法
extends 关键字用在 class 或 interface 声明中，用于指示所声明的类或接口是其名称后跟有 extends 关键字的类或接口的子类。
-示例-
public class Rectangle extends Polygon{
}
-注释-
在上例中，Rectangle 类继承 Polygon 类的所有 public 和 protected 变量和方法。
Rectangle 类可以重写 Polygon 类的任何非 final 方法。
一个类只能扩展一个其他类。

15.false
解释：假，布尔型的字面值
用法：boolean类型的取值范围之一.
false 关键字代表 boolean 变量的两个合法值之一。
-示例-
boolean isComplete = false;

16.final
解释：最终的，决定性的
用法：修饰符的一种，它可以用来修饰类，方法，属性。当一个属性被修饰成final的之后，这个属性变成了常量，它的值必须在定义的时候初始化，并且后面的代码不能对其进行修改,它的命名应该全部都是大写。当一个方法被修饰成final的之后，这个方法在继承中是不能够被进行覆盖的。当一个类被修饰成final的之后，这个类不能再有子类。

final 关键字可以应用于类，以指示不能扩展该类（不能有子类）。
final 关键字可以应用于方法，以指示不能重写任何子类中的方法。
-示例-
public final class MyFinalClass{
}
public class MyClass{
public final String myFinalMethod()
{

}
}
例子：
public final class Math{
private final float PI = 3.1415926;
public final int abs(int i){
return i>=0?i:-I;
}
}

-注释-
一个类不能同时是 abstract 又是 final。abstract 意味着必须扩展类，final 意味着不能扩展类。
一个方法不能同时是 abstract 又是 final。abstract 意味着必须重写方法，final 意味着不能重写方法。
1>对于基本类型前加以final修饰，表示被修饰的变量为常数，不可以修改。一个既是static又是final的字段表示只占据一段不能改变的存储空间。
2>final用于对象应用时，final使应用恒定不变。一旦引用被初始化指向一个对象，就无法再把它指向另一个对象。
3>final方法:一是把方法锁定，以防止继承类修改它的含义，二是确保继承中使方法行为保持不变，并且不会被覆盖。类中所有的private方法都隐式地指定为是final。
4>final参数：对于基本类型的变量，这样做并没有什么实际意义，因为基本类型的变量在调用方法时是传值，也就是说你可以在方法中更改这个参数变量而不会影响到调用语句，然而对于对象变量，却显得很实用，以为对象变量在传递时是传递其引用，这样你在方法中对对象变量的修改也会影响到调用语句的对象变量，当你在方法中不需要改变作为参数的变量时，明确使用final进行声明，会防止你无意的修改而影响到调用方法。
5>final类：当将某个类的整体定义为final时，就表明了该类不允许被继承。

17.finally
解释：最后，终于，不可更改地
用法：在异常处理机制当中，它的作用就像是人吃饭一样，必须得做的，不论有异常还是没有异常都要执行的代码就可以放到finally块当中去。finally块，必须要配合try块一起使用，不能单独使用，也不能直接和catch块一起使用。
finally 关键字用来定义始终在 try-catch-finally 语句中执行的块。
finally 块通常包含清理代码，用在部分执行 try 块后恢复正常运行。
-示例-
try{
<可能引发异常的块>
}
catch (tion 或子类> e){
<处理异常 e 的代码>
}
finally{
<有异常或无异常情况下都执行的语句>
}
-注释-
开始和结束标记 { 和 } 是 finally 子句语法的一部分，即使该子句只包含一个语句，也不能省略这两个标记。
每个 try 块都必须至少有一个 catch 或 finally 子句。
如果执行 try 块的任何部分，不论是否出现异常，也不论 try 或 catch 块是否包含 return、continue 或 break 语句，都一定会执行 finally 块中的代码。
如果不出现异常，控件将跳过 try 块，进入 finally 块。
如果在执行 try 块期间出现异常，并且相应的 catch 块包含 break、continue 或 return 语句，控件将首先穿过 finally 块，之后再执行 break、continue 或 return。

18.float
用法：float 是 Java 原始类型。float 变量可以存储单精度浮点值。
-示例-
float ratio = .01;
float diameter = 6.15;
float height = 1.35E03; // 1.35 * 103 或 1350.0
float height = 1e-2; // 1.0 * 10-2 或 0.01
-注释-
使用此关键字时应遵循下列规则：
Java 中的浮点文字始终默认为双精度。要指定单精度文字值，应在数值后加上 f 或 F，如 0.01f。
由于浮点数据类型是实际数值的近似值，因此，一般不要对浮点数值进行是否相等的比较。
Java 浮点数值可代表无穷大和 NaN（非数值）。Float 包装对象类用来定义常量 MIN_VALUE、MAX_VALUE、NEGATIVE_INFINITY、POSITIVE_INFINITY 和 NaN。

19.for
用法：for 关键字用于指定一个在每次迭代结束前检查其条件的循环。
-示例-
int i;
for i=0; i
}
-注释-
for 语句的形式为 for(initialize; condition; increment)
控件流进入 for 语句时，将执行一次 initialize 语句。
每次执行循环体之前将计算 condition 的结果。如果 condition 为 true，则执行循环体。
每次执行循环体之后，在计算下一个迭代的 condition 之前，将执行 increment 语句。

20.if
用法：if 关键字指示有条件地执行代码块。条件的计算结果必须是布尔值。
-示例-
if (condition){

}
if (condition){

}
else{

}
-注释-
if 语句可以有可选的 else 子句，该子句包含条件为 false 时将执行的代码。
包含 boolean 操作数的表达式只能包含 boolean 操作数。

21.implements
解释：实现
用法：用来让一个类实现一个接口的关键字，实现接口的这个类必须实现接口里面所有的方法。
implements 关键字在 class 声明中使用，以指示所声明的类提供了在 implements 关键字后面的名称所指定的接口中所声明的所有方法的实现。
-示例-
public class Truck implements IVehicle{
}
-注释-
在上例中，Truck 类必须提供在 IVehicle 接口中所声明的所有方法的实现。
否则，Truck 类将是独立的；它可以声明其他方法和变量，并扩展另一个类。
一个类可以实现多个接口。

22.import
解释：引入，导入
用法：相对应打包而言，当一个类被放在包下面了，如果要使用这个类就必须到这个包下面去寻找这个类，因此出现了导包语句。导包可以有多条语句。
import 关键字使一个包中的一个或所有类在当前 Java 源文件中可见可以不使用完全限定的类名来引用导入的类。
-示例-
import java.io.File;
import .*;
-注释-
当多个包包含同名的类时，许多 Java 程序员只使用特定的 import 语句（没有“*”）来避免不确定性。

23.instanceof
用法：instanceof 关键字用来确定对象所属的类。
-示例-
if (node instanceof TreeNode){

}
-注释-
在上例中，如果 node 是 TreeNode 类的实例，或者是 TreeNode 的子类的实例，则 instanceof 表达式的值将为 true。
instanceof 通常是用于判断父类或者接口的引用是否是某个子类的实例，例如：
class Animal{}
class Bird extends Animal {}
class Dog extends Animal {}
Animal a= new Bird();
System.out.println( a instanceof Bird);
System.out.println( a instanceof Dog);
24.int
用法：int 是 Java 原始类型。
int 变量可以存储 32 位的整数值。
-示例-
int number = 5;
int octalNumber = 0377;
int hexNumber = 0xff;
-注释-
Integer 类是 int 原始类型的包装对象类。它定义代表此类型的值的范围的 MIN_VALUE 和 MAX_VALUE 常量。
Java 中的所有整数值都是 32 位的 int 值，除非值后面有 l 或 L（如 235L），这表示该值应解释为 long。

25.interface
解释：接口，界面
用法：它本质上是一个类，一个完全抽象的类，里面没有任何实现的方法。它不是用来继承的，是用来实现的。某个类如果实现了接口就必须要实现接口里面的所有方法。并且接口是不能用来实例化的，它也是不能通过new关键字获得对象。
interface 关键字用来声明新的 Java 接口，接口是方法的集合。
接口是 Java 语言的一项强大功能。任何类都可声明它实现一个或多个接口，这意味着它实现了在这些接口中所定义的所有方法。
-示例-
public interface IPolygon{
public float getArea();
public int getNumberOfSides();
public int getCircumference();
}
-注释-
实现了接口的任何类都必须提供在该接口中的所有方法的实现。
一个类可以实现多个接口。

26.long
用法：long 是 Java 原始类型。long 变量可以存储 64 位的带符号整数。
-示例-
long number = 5;
long anotherNumber = 34590L;
long octalNumber = 0377;
long hexNumber = 0xffl;
-注释-
Long 类是 long 原始类型的包装对象类。它定义代表此类型的值的范围的 MIN_VALUE 和 MAX_VALUE 常量。
Java 中的所有整数值都是 32 位的 int 值，除非值后面有 l 或 L（如 235L），这表示该值应解释为 long。

27.native
native 关键字可以应用于方法，以指示该方法是用 Java 以外的语言实现的。
-示例-
native String getProcessorType();
-注释-
Java不是完美的，Java的不足除了体现在运行速度上要比传统的C++慢许多之外，Java无法直接访问到操作系统底层（如系统硬件等)，为此Java使用native方法来扩展Java程序的功能。

可以将native方法比作Java程序同Ｃ程序的接口，其实现步骤：
１、在Java中声明native()方法，然后编译；
２、用javah产生一个.h文件；
３、写一个cpp文件实现native导出方法，其中需要包含第二步产生的.h文件（注意其中又包含了JDK带的jni.h文件）；
４、将第三步的.cpp文件编译成动态链接库文件；
５、在Java中用System.loadLibrary()方法加载第四步产生的动态链接库文件，这个native()方法就可以在Java中被访问了。
JAVA本地方法适用的情况
1.为了使用底层的主机平台的某个特性，而这个特性不能通过JAVA API访问
2.为了访问一个老的系统或者使用一个已有的库，而这个系统或这个库不是用JAVA编写的
3.为了加快程序的性能，而将一段时间敏感的代码作为本地方法实现。

首先写好JAVA文件
　　/*
　　* Created on 2005-12-19 Author shaoqi
　　*/
　　package com.hode.hodeframework.modelupdate;
　　public class CheckFile
　　{
　　public native void displayHelloWorld();
　　static
　　{
　　System.loadLibrary("test");
　　}
　　public static void main(String[] args) {
　　new CheckFile().displayHelloWorld();
　　}
　}
　　然后根据写好的文件编译成CLASS文件
　　然后在classes或bin之类的class根目录下执行javah -jni com.hode.hodeframework.modelupdate.CheckFile， 就会在根目录下得到一个com_hode_hodeframework_modelupdate_CheckFile.h的文件，然后根据头文件的内容编写com_hode_hodeframework_modelupdate_CheckFile.c文件
　　#include "CheckFile.h"
　　#include
　　#include
　　JNIEXPORT void JNICALL Java_com_hode_hodeframework_modelupdate_CheckFile_displayHelloWorld(JNIEnv *env, jobject obj)
　　{
　　printf("Hello world!\n");
　　return;
　　}
　　之后编译生成DLL文件如“test.dll”，名称与System.loadLibrary("test")中的名称一致
　　vc的编译方法：cl -I%java_home%\include -I%java_home%\include\win32 -LD com_hode_hodeframework_modelupdate_CheckFile.c -Fetest.dll
　　最后在运行时加参数-Djava.library.path=[dll存放的路径]
28.new
解释：新建
用法：创建对象时使用，当一看倒new关键字，意味着在内存的堆空间里开辟了一个空间，存放了相对应类型的对象出来。创建的对象由一个相对应类型的引用去指向访问，类似与C语言中指针的用法。
格式如下：类名 引用名 = new 类名()。
new 关键字用于创建类的新实例。
-示例-

String sName = new String();
Float fVal = new Float(0.15);
-注释-
new 关键字后面的参数必须是类名，并且类名的后面必须是一组构造方法参数（必须带括号）。
参数集合必须与类的构造方法的签名匹配。
= 左侧的变量的类型必须与要实例化的类或接口具有赋值兼容关系。

29.null
解释：空
用法：对象的一种取值，称呼为：“null值”，这时候我们理解成内存里面还没有得到这个对象空间。
null 是 Java 的保留字，表示无值。
-示例-
Integer i;
i = null;
String s;
if (s != null){

}
-注释-
将 null 赋给非原始变量相当于释放该变量先前所引用的对象。
不能将 null 赋给原始类型（byte、short、int、long、char、float、double、boolean）变量。

30.package
解释：包裹，包
用法：为了防止同一个目录下面存在于两个相同名字的源文件，使用打包的用处和文件夹的作用是相似的。要注意，打包语句一定只能放在源文件的第一句话，并且不能在同一个源文件中出现两个或者两个以上的打包语句。包可以嵌套，通常来讲，第一个包称之为根包，后面的嵌套包称之为子包。
package 关键字指定在 Java 源文件中声明的类所驻留的 Java 包。
-示例-
package com.mycompany;
public class MyClass{
}
-注释-
package 语句（如果出现）必须是 Java 源文件中的第一个非-注释-性文本。
在上面的-示例-中，MyClass 类的完全限定类名是 com.mycompany.MyClass。
如果 Java 源文件不包含 package 语句，在该文件中定义的类将位于“默认包”中。请注意，不能从非默认包中的类引用默认包中的类。

31.private
解释：访问权限修饰符的一种，私有的意思。
用法：用来修饰属性，方法。只能类的内部本身才能够访问,不能修饰类.
private 关键字是访问控制修饰符，可以应用于方法或字段（在类中声明的变量）。
-示例-
public class MyPublicClass{
private class MyPrivateClass{
}
private int i;
private String myMethod(){

}
}
-注释-
只能在声明 private（内部）类、方法或字段的类中引用这些类、方法或字段。在类的外部或者对于子类而言，它们是不可见的。
所有类成员的默认访问范围都是 package 访问，也就是说，除非存在特定的访问控制修饰符，否则，可以从同一个包中的任何类访问类成员。

32.protected
解释：访问权限修饰符的一种，受保护的意思。
用法：用来修饰属性，方法。只能符合有包内友好关系，或者是父子友好的类才能够访问,不能修饰类.
protected 关键字是可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。
-示例-
public class MyPublicClass{
protected class MyPrivateClass{
}
protected int i;
protected String myMethod(){

}
}
-注释-
可以在声明 protected 类、方法或字段的类、同一个包中的其他任何类以及任何子类（无论子类是在哪个包中声明的）中引用这些类、方法或字段。
所有类成员的默认访问范围都是 package 访问，也就是说，除非存在特定的访问控制修饰符，否则，可以从同一个包中的任何类访问类成员。

33.public
解释：访问权限修饰符的一种，公开，公共的意思。
用法：用来修饰类，属性，方法。对于外部的任何类都能够访问。
public 关键字是可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。
-示例-
public class MyPublicClass{
public class MyPrivateClass{
}
public int i;
public String myMethod(){

}
}
-注释-
可能只会在其他任何类或包中引用 public 类、方法或字段。
所有类成员的默认访问范围都是 package 访问，也就是说，除非存在特定的访问控制修饰符，否则，可以从同一个包中的任何类访问类成员。

34.return
用法：return 关键字会导致方法返回到调用它的方法，从而传递与返回方法的返回类型匹配的值。
-示例-
public void myVoidMethod(){

return;
}
public String myStringMethod(){
String s = "my response";
return s;
}
public int myIntMethod(){
int i = 5;
return(i);
}
-注释-
如果方法具有非 void 的返回类型，return 语句必须具有相同或兼容类型的参数。
返回值两侧的括号是可选的。

35.short
用法：short 是 Java 原始类型。short 变量可以存储 16 位带符号的