一、概念

Java关键字（Key Word）：  对Java的编译器有特殊的意义，他们用来表示一种数据类型或者表示程序的结构.

保留字（Reserve Word）：即它们在Java现有版本中没有特殊含义，以后版本可能会作为有特殊含义的词，或者该词虽然在Java中没有特殊含义，以后版本也不打算使用，但在其它语言中有特殊含义，不宜在Java中定义为变量名称等，因为容易混淆。

注意：关键字和保留字均不能用作变量名、方法名、类名、包名和参数。

二、具体的保留字（2个)

goto、const

三、具体的关键字（51个）
大致含义：

1. abstract  抽象的

Java语言的一个关键字，用在类的声明中来指明一个类是不能被实例化的，但可以被其它类继承。一个抽象类可使用抽象方法，抽象方法不需实现，但是需在子类中被实现。

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类不能有子类。

2. assert 断言 

Java语言的一个关键字。

断言在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。一般来说， 断言用于保证程序最基本、关键的正确性。断言检查通常在开发和测试时开启。为了保证程序 的执行效率，在软件发布后断言检查通常是关闭的。

断言是一个包含布尔表达式的语句，

在执 行这个语句时假定该表达式为 true;如果表达式的值为 false，那么系统会报告一个 AssertionError。 断言的使用如下面的代码所示:

assert(a > 0); // throws an AssertionError if a <= 0

断言可以有两种形式:

assert Expression1;
assert Expression1 : Expression2 ;

3. boolean  布尔型

Java语言的一个关键字。

boolean类型适用于逻辑运算，一般用于程序流程控制。boolean类型数据只允许取值true或false，不可以0或非0的整数代替true和false，这点与C语言不同。

4. break 跳出

 Java语言的一个关键字，用来改变程序执行流程，立刻从当前语句的下一句开始执行从。如果后面跟有一个标签，则从标签对应的地方开始执行。

5. case 实例

 Java语言的一个关键字，用来定义一组分支选择，如果某个值和switch中给出的值一样，就会从该分支开始执行。

6. catch 捕捉

Java语言的一个关键字，用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。 

7. char 字符

 Java语言的一个关键字，用来定义一个字符类型。

char型数据用来表示通常意义上“字符”。

字符常量为用单引号括起来的单个字符，例如：

char e='a'; 

char e='中'；

java字符采用Unicode编码，每个字符占两个字节（1个字节占8位,数据在计算机底层存储，用0101表示，每一个0，1都叫一个位（byte）），因而可用十六进制编码形式表示。例如：

char c1='\u0061';（在内存中应是01100001，\u指的是后面4位数是十六进制的Unicode编码）

注：Unicode编码是全球语言统一编码。

java语言中还允许使用转义字符‘\’来将其后的字符转变为其它的含义，例如：

char c2='\n';

8. continue  继续

 Java语言的一个关键字，用来打断当前循环过程，从当前循环的最后重新开始执行，如果后面跟有一个标签，则从标签对应的地方开始执行。

<关于break&continue>

continue语句与break语句相关，但较少用到。continue语句用于使其所在的for、while或do-while语句开始下一次循环。在while与do-while语句中，continue语句的执行意味着立即执行测试部分；在for循环语句中，continue语句的执行则意味着使控制传递到增量部分。

<关于break&continue&switch>

如下：

break语句：用于终止某个语句块的执行。用在循环语句体中，可以强行推出循环。

continue语句：用在循环语句体中，用于终止某次循环过程，跳过循环体中continue语句下面未执行的循环，开始下一次循环。

switch语句：

语句形式：switch(choice){

     case xx:

            ....

        break;

    case xx:

            ....

         break;

    default:

            ....

        break;

}

9. do （do-while循环结构中）

Java语言的一个关键字，用来声明一个循环，这个循环的结束条件可以通过while关键字设置。 

10. double 双精度型

 Java语言的一个关键字，用来定义一个double类型的变量。

11. else 否则

Java语言的一个关键字，如果if语句的条件不满足就会执行该语句。

12. enum 枚举

Java语言的一个关键字，代表一组常用常量，可用来代表一类相同类型的常量值。如：

性别：

public enum SexEnum {

     male, female;

}

颜色：

public enum Color {

    RED, BLUE,GREEN,BLACK;

}

枚举对象里面的值都必须是唯一的。

13. extends  类的继承和权限控制

Java语言的一个关键字，表明一个类型是另一个类型的子类型，这里常见的类型有类和接口

类的继承与权限控制(继承关系：能说通XX是XX就可以看作继承关系，比如，狗是动物)

1）java中使用extends关键字实现类的继承机制，其语法规则为：<modifier>class<name>[extends<superclass>]{... ...}

2）通过继承，子类自动拥有了父类（基类superclass）的所有成员（成员变量和方法）。

3）java只支持单继承，不允许多继承（一个子类只能有一个基类，一个基类可以派生出多个子类）。

释例：public class Student extends Person{}

14. final 最终、不可更改的//不常用

 Java语言的一个关键字，只能定义一个实体一次，以后不能改变它或继承它。
更严格的讲：一个final修饰的类不能被子类化，一个final修饰的方法不能被重写，一个final修饰的变量不能改变其初始值。

15. finally 最后

 Java语言的一个关键字，用来执行一段代码不管在前面定义的try语句中是否有异常或运行时错误发生。

16. float 浮点数

 Java语言的一个关键字，用来定义一个浮点数变量。

<关于float&double>

浮点类型：java浮点类型有固定的表数范围和字段长度，不受平台影响。

                  java浮点型常量有两种表示形式

1.十进制数形式，例如：3.14    41.0   .314

2.科学计数法形式，如3.14e2   3.14E2   100E-2

java浮点型常量默认为double，如果声明一个常量为float，则需在数字后面加f或F，如：

double d=123.4; float f=12.3f;//不加f则出错，f必须加

  类型         占用存储空间                          表数范围

  float           【4字节】         -3.403E38～3.403E38（小数点后有效位数7位）
  double       【 8字节】        -1.798E308～1.798E308（小数点后有效位数15位）

注意：浮点数在计算机中表示是离散的，有误差，在有效位数（精度）之后就不精确了，浮点数值不适用于禁止出现舍入误差的金融计算中。如果需要在数值计算中不含有任何舍入误差，就应该用BigDecimal类。

17. for 为了（循环语句）

 Java语言的一个关键字，用来声明一个循环。程序员可以指定要循环的语句，推出条件和初始化变量。 

18. if 如果

 Java语言的一个关键字，用来生成一个条件测试，如果条件为真，就执行if下的语句。

19. implements 实现

 通过类来实现接口

Java语言的一个关键字，在类的声明中是可选的，用来指明当前类实现的接口。 tm=tradeMark（Java商标的意思）。

20. import 导入

  Java(TM)语言的一个关键字，在源文件的开始部分指明后面将要引用的一个类或整个包，这样就不必在使用的时候加上包的名字。

import（引入）：用于引入非同包类，同胞类不需要引入，直接用就可以。

     例：import oop.Birthday;  //引入oop包下的Birthday类

21. instanceof 判断对象类型

 Java(TM)语言的一个关键字，用来测试第一个参数的运行时类型是否和第二个参数兼容。 

22. int 整数类型

 Java(TM)语言的一个关键字，用来定义一个整形变量 Java(TM)语言的一个关键字，用来定义一系列的方法和常量。它可以被类实现，通过implements关键字。 

23. long 长整型

 Java语言的一个关键字，用来定义一个long类型的变量。

 24. package  包

Java语言的一个关键字。

例如：package  com.jd;

1）为了便于管理大型软件系统中数目众多的类，解决类的命名冲突问题，java引入包（package）机制，提供类的多重类命名空  间。

2）约定俗称的包起名方式：把公司的域名倒过来。如：package  com.jd;这个包包了两层（建包可不是只能建两层哈，别误会，只是这个例子中有两层），公司域名不是一样的，这样起名避免类名产生重复。

3）package语句作为java源文件的第一条语句，指明该文件中定义的类所在的包。（若缺省该语句，则指定为无名包）。

格式为package pkg1[.pkg2[.pkg3....[];

4）java编译器把包对应于文件系统的目录管理，package语句中，用“.“来指明包（目录）的层次，例如package  com.jd;则该文件中所有的类位于.\com\jd 目录下

5）class文件的最上层包的父目录应位于classpath下（在公司不同的项目一般设置不同的classpath）。

6）要想执行一个类必须写全包名。如：java com.jd.TestPackage

25. private 私有的

 Java语言的一个关键字，用在方法或变量的声中。它表示这个方法或变量只能被这个类的其它元素所访问。

26. protected 保护类型

 Java语言的一个关键字，在方法和变量的声明中使用，它表示这个方法或变量只能被同一个类中的，子类中的或者同一个包中的类中的元素所访问。

27. public 公共的

 Java语言的一个关键字，在方法和变量的声明中使用，它表示这个方法或变量能够被其它类中的元素访问。

28. return 返回

 Java语言的一个关键字，用来结束一个方法的执行。它后面可以跟一个方法声明中要求的值。

28. short 短的

 Java语言的一个关键字，用来定义一个short类型的变量。 

29. static 静态的

 Java语言的一个关键字，用来定义一个变量为类变量。类只维护一个类变量的拷贝，不管该类当前有多少个实例。"static" 同样能够用来定义一个方法为类方法。类方法通过类名调用而不是特定的实例，并且只能操作类变量。

1）在类中，用static声明的成员变量为静态成员变量，它为该类的公用变量。在第一次使用时候被初始化，对于该类的所有对象来说，static成员变量只有一份。

2）用static声明的方法为静态方法，在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。（静态方法只能访问静态成员，因为非静态方法的调用要先创建对象，在调用静态方法时可能对象并没有被初始化）。

3）可以通过对象引用或类名（不需要实例化）访问静态成员。

4）static静态变量存在在data seg数据区，就算是不new它，它也会在data seg部分保留一份。静态变量是属于整个类的，它不属于某一个对象。  

30. this  这个
是指向该对象自身的标示符

Java语言的一个关键字，用来代表它出现的类的一个实例。this可以用来访问类变量和类方法。

1）在类的方法定义中使用this关键字代表代表使用该方法的对象的引用

2）当必须指出当前使用方法的对象是谁时要用this。

3）有时使用this可以处理方法中成员变量和参数重名的情况。

4）this可以看作是一个变量，它的值是当前对象的引用。

31. throw 投、抛——抛出用户自己定义的异常

 Java语言的一个关键字，允许用户抛出一个exception对象或者任何实现throwable的对象。

throw是你执行的动作。比如你觉得可能有异常，那么就抛出去 。

String a;

if(a == null),

throw new exception("a为null");

所以throw是一个抛出去的动作

throws只用在一个方法的末端，表示这个方法体内部如果有异常，这抛给它的调用者。

如：

public void add(int a, int b) throws Exception();

32. throws 声明抛弃异常——抛出系统异常

 Java语言的一个关键字，用在方法的声明中来说明哪些异常这个方法是不处理的，而是提交到程序的更高一层。

33. transient 短暂的、瞬时的

 Java语言的一个关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。 

34. try 尝试、审判

 Java语言的一个关键字，用来定义一个可能抛出异常语句块。如果一个异常被抛出，一个可选的catch语句块会处理try语句块中抛出的异常。同时，一个finally语句块会被执行，无论一个异常是否被抛出。

35. void 空

 Java语言的一个关键字，用在Java语言的方法声明中说明这个方法没有任何返回值。"void"也可以用来表示一句没有任何功能的语句。 

36. volati
Java语言的一个关键字，声明中表示这个变量是被同时运行的几个线程异步修改的。

37. volatile
一个类型修饰符（type specifier）。它是被设计用来修饰被不同线程访问和修改的变量。
如果没有volatile，基本上会导致这样的结果：要么无法编写多线程程序，要么编译器失去大量优化的机会。

38. while 一会儿（循环语句）

 Java语言的一个关键字，用来定义一段反复执行的循环语句。循环的退出条件是while语句的一部分。

while语句形式：while(逻辑表达式){语句;....;}

执行过程：先判断逻辑表达式的值，若为true则执行其后面的语句，然后再次判断条件并反复执行，直到条件不成立为止。

39. extends 继承（类继承类，或接口继承接口）

 >1.与数据类型相关（10）

>2.与流程控制相关（13）

1. if： 表示条件判断，一般用法if（关系表达式），后跟else或{……}
2. else： 条件转折，如if （关系表达式）{语句块1}else{语句块2}，如果关系表达式的值为true，则执行语句块1，否则执行语句块2.
3. do……while……：do和while一般一起使用，用于表示循环语句。do{……}while（关系表达式）……；当关系表达式的值为true是继续循环。
4. for：用于表示循环，for循环是最常使用的循环，格式for（表达式a; 表达式b; 表达式c）括号里面的书通常用于控制循环的次数，一般会用一个int类型的变量类计数，如（int i=0; i<10; i++）表达式a用于流程控制的开始值，表达式b表示循环终止条件，表达式c用于计数。
5. switch（条件a）case……：switch和case合起来用于表示条件分支流程。如：

             while(int c) {
             case 1: {语句块1} 
             case 2: {语句块2}
             ……?????? ……
             case n: {语句块n}
             default：exit(0);
             }
         如果c为1，则执行语句块1；如果c为2，则执行语句块2；以此类推，如果c为n，则执行语句块n。default表示除case以外出现的情况。

  6.  default：在switch……case……分支语句可知，default是在所有case条件下都不成立时使用。用于包表示s“rc”文件夹下的当前包；如果用于类，表示只可被本文件内的其它类访问。

  7.  break：用于结束本层循环，或跳出某层循环。
  8. continue：用于跳出本次循环，而break跳出本层循环。

Break和continue可以实现类似于C\C++中goto语句的用法：
label0:
{
for (int k = 0; k < 10; k++) {
.......... 
label1:
for (int j = 0; j < 10; j++) {
................
break label0; //跳转至label0
}
...........
label2:
for (int kk = 0; kk < 10; kk++) {
..............
break label0; //跳至label2
}
 

9. return:返回一个值，通常用于函数中，返回一个具有特定类型的值。如:

public int fuction(){ int a; …… return a;//返回int型的值}

 10. try……catch……finally……：用于异常处理，使用形式如：

try{
……
}catch(类型b){
……
}finally{
……
}

try{……}中放置可能会发生异常的的语句块，catch(){……}用于抓住异常，{}定义当出现异常时的处理方法。finally{……}表示不管异常是否发生，都得进行finally{}中的处理。

>3.与修饰符相关（12）

不同访问修饰符的访问权限

1. 一个".java"后缀名的文件里面只能一个publi型的cass类。如c13.swing包下有HelloWorld.java 文件，该文件下有如下代码：

package c13.swing;
public class HelloWorld {
    public void show() {
        System.out.println("HelloWorld!");
    }    
}

2. 在default包下有如下代码：

import c13.swing.*;  //引入所需要的包里的所有类
public class Test {
    public static void main(String args[]) {
        HelloWorld h = new HelloWorld();
        h.show();
    }
}
此时运行正常，结果：HelloWorld!

如果把public class HelloWorld改成privateclass HelloWorld则会运行错误，因为private是私有的不能被其他包内的对象所引用。
  3. final：(类似于C++中的const)，用法如下：
      final的变量的值不能被改变；
     1) final的方法不能被重写；<final的成员变量>

     2) final的类不能被继承。 <final的局部变量>
   4. void：空类型，用于函数前表示空返回值。
   5. static：可用于定义静态成员变量或方法
   6. strictfp：意思是FP-strict，也就是说精确浮点的意思。在Java虚拟机进行浮点运算时，如果没有指定strictfp关键字时，Java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作，以致于得到的结果往往无法令你满意。而一旦使用了strictfp来声明一个类、接口或者方法时，那么所声明的范围内Java的编译器以及运行环境会完全依照浮点规范IEEE-754来执行。因此如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，那就请用关键字strictfp。  
你可以将一个类、接口以及方法声明为strictfp，但是不允许对接口中的方法以及构造函数声明strictfp关键字，例如下面的代码： 
 

1. 合法的使用关键字strictfp 
strictfp interface A {}
public strictfp class FpDemo1 { 
strictfp void f() {} 
} 
2. 错误的使用方法 
interface A { 
strictfp void f(); 
}
public class FpDemo2 { 
strictfp FpDemo2() {} 
}

一旦使用了关键字strictfp来声明某个类、接口或者方法时，那么在这个关键字所声明的范围内所有浮点运算都是精确的，符合IEEE-754规范的。例如一个类被声明为strictfp，那么该类中所有的方法都是strictfp的。
  7. abstract：抽象的意思，可以用定义抽象类，抽象函数。抽象类的用法规则如下：
a，用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，这个方法叫做抽象方法；
b，含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写；
c，抽象类不能被实例化；
d，抽象方法只需声明，而不需实现。
  8. transient: 用来表示一个域不是该对象串行化的一部分。当一个对象被串行化时，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。
 使用对象：字段
介绍：字段不是对象持久的一部分，不应该字段和对象一起串起。
  9. synchronized：锁定当前对象，在执行当前这个对象时不应许其他线程打断插入。使用的方式有：

（1）class Timer {
private static int num = 0;
public synchronized void add(String name) { //执行这个方法的过程中锁定当前对象。
num ++;
try {
Thread.sleep(1);
} catch( InterruptedException e) {
return;
}
System.out.println(name + ",你是第" + num +"使用Timer的线程。");
}
}
（2）class Timer {
private static int num = 0;
public void add(String name) { 
synchronized(this) { //锁定大括号这个区域的代码段
num ++;
try {
Thread.sleep(1);
} catch( InterruptedException e) {
return;
}
System.out.println(name + ",你是第" + num +"使用Timer的线程。");
}
}
}

  11. volatile：volatile变量一个时间只有一个线程可以访问。 保证线程安全。 
可以被写入 volatile 变量的这些有效值独立于任何程序的状态，包括变量的当前状态。 
所以，Volatile 变量是一种非常简单但同时又非常脆弱的同步机制，它在某些情况下将提供优于锁的性能和伸缩性。
  12. native：是用作java 和其他语言（如c++）进行协作时用的也就是native 后的函数的实现不是用java写的， native的意思就是通知操作系统，这个函数你必须给我实现，因为我要使用。所以native关键字的函数都是操作系统实现的，
 java只能调用。

>4.与动作相关（10）

1. package：打包，把java程序写在一个包中。
2. import：引入报名，用法：  

       1) 写全包名：jsxt.java140.Cat c = new com.bjsxt.java140.Cat
       2) 引入一个包中的具体某个对象：xt.java140.Cat;
       3) 引入一个包中的所有象：import com.bjsxt.java140.Cat.*;

   3. throw：抛出用户自己定义的异常

   4. throws：抛出系统异常
   5. extends：继承（类继承类，或接口继承接口）
   6. implements：实现，通过类来实现接口
   7. this：是指向该对象自身的标示符
   8. super：调用基类的构造函数
   9. instanceof：判断某个对象是否为自己所要的对象
 10. new：用于新建一个对象，即类的实例化

>5.1其他（5）

1. true：表示boolean类型的真值
2. false：表示boolean类型的假值，即不成立的情况
3. null：表示空值，如果是对象，则表示此对象为空，如果是数据类型，在表示相应数据类型的默认值，如int的默认值为0。
4. goto：C\C++中实现无条件转向语句，为了结构化程序设计java中现在一般不用。
5. const：和const一样，在Java中,const是作为保留字以备扩充。可以用final替换const，一般C++中用const，java中用final。

>6.与格式规范（1）

1. strictfp：

修饰类、接口或方法。

修饰方法时，该方法中所有的float和double表达式都严格遵守FP-strict的限制,符合IEEE-754规范。

修饰类或接口时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。

严格约束意味着所有表达式的结果都必须是 IEEE 754 算法对操作数预期的结果，以单精度和双精度格式表示。

--------------------- 
参考原作者：Alexwym，luoweifu 
 

本文于周末温习Java关键字，以及观看博客文章后，有感而发的参考原文章，重新整理结合知识点进行编写，望各位大牛大佬们在查阅这篇文章中，发现有错误之处，或是其他小文章，都可直接向鄙人（刚入门小弟子）指点，感谢支持，我会更加努力的，谢谢【微笑】！！！