在JAVA中目前一共有53个关键字：其中由51+2个保留字=53个关键字

1、JAVA的保留关键字（2个）

     const——常量，常数：用于修改字段或局部变量的声明。

     goto——转到：指定跳转到标签，找到标签后，程序将处理从下一行开始的命令

2、访问修饰符的关键字（3个）

     public （公有的）：可跨包

     protected (受保护的)：当前包内可用

     private (私有的)：当前类可用

3、定义类、接口、抽象类和实现接口、继承类的关键字、实例化对象（6个）

     class (类)：public class A(){}花括号里是已实现的方法体，类名需要与文件名相同

     interface (接口)：public interface B(){}花括号里有方法体，但没有实现，方法体句子后面是英文分号;结尾

     abstract (声明抽象)：public abstract class C(){}介于类与接口中间，可以有，也可以没有已经实现的方法体

     implemenst (实现)：用于类或接口，实现接口public class A interface B(){}

     extends (继承)：用于类继承类public class A extends D(){}

     new (创建新对象)：A a=new A();A表示一个类

4、包的关键字（2个）

     import (引入包的关键字)：当使用某个包的一些类时，仅需要类名，然后使用ctrl+shift+o或者选定类名（类或属性或方法）按住ctrl+单击，即可自动插入类所在的包

     package (定义包的关键字)：将所有相关的类放在一个包类以便查找修改等

5、数据类型的关键字（12个）

     byte (字节型)：8bit

     char (字节型)：16bit

     boolean (布尔型)：--

     short (短整型)：16bit

     int (整型)：32bit

     float (浮点型)：32bit

     long (长整型)：64bit

     double (双精度)：64bit

     void (无返回)：public void A(){}其他需要反回的经常与return连用

     null (空值)

     true (真)

     false (假）

6、条件循环（流程控制）（12个）

     if (如果) ：if（条件语句｛执行代码｝如果条件语句成立，就开始执行｛｝里面的内容

     else (否则，或者) ：常与if连用，用法相同：if(...){...}else{...}

     while (当什么时候)：while（条件语句）｛执行代码｝

     for（满足三个条件时）：for(初始化循环变量；判断条件；循环变量值｛｝

    switch (选择结构)：switch(表达式）｛case 常量表达式1：语句1；...case 常量表达式2；语句2；default:语句；｝default就是如果没有匹配的case就执行它，default并不是必须的。case后的语句可以不用大括号。

    case (匹配switch的表达式里的结果) ：同上

    default (默认)： default就是如果没有匹配的case就执行它， default并不是必须的

    do (运行) ：通长与while连用

    break (跳出循环)：直接跳出循环，执行循环体后的代码

    continue (继续) ： 中断本次循环，并开始下一轮循环

    return (返回) ：return 一个返回值类型

    instanceof(实例)：一个二元操作符，和==、>、<是同一类的。测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据

7、修饰方法、类、属性和变量（9个）

    static(静态的)：属性和方法都可以用static修饰，直接使用类名、属性和方法名。只有内部类可以使用static关键字修饰，调用直接使用类名、内部类类名进行调用。static可以独立存在

    final(最终的不可被改变)：方法和类都可用final来修饰；final修饰的类是不能被继承的；final修饰的方法是不能被子类重写。常量的定义：final修饰的属性就是常量

    super(调用父类的方法)：常见public void paint(Graphics g){super.paint(g);...}

    this(当前类的父类的对象)：调用当前类中的方法（表示调用这个方法的对象）this.addActionListener(al):等等

    native(本地)

    strictfp(严格，精准)

    synchronized(线程，同步)：一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块

    transient(短暂)

    volatile(易失)

 8、错误处理（5个）

    catch(处理异常)：（1）try+catch 程序流程是：运行到try块中，如果有异常抛出，则转到catch块去处理。然后执行catch块后面的语句

                                 （2）try+catch+finally 程序流程是：运行到try块中，如果有异常抛出，则转到catch垮，catch块执行完毕后，执行finally块的代码，再执行finally块后面的代码。如果没有异常抛出，执行完try块，也要去执行finally块的代码。然后执行finally块后                                                 面的语句

                                 （3）try+finally  程序流程是：运行到try块中，如果有异常抛出，则转到finally块的代码。

   try(捕获异常)

  finally（有没有异常都执行）

  throw(抛出一个异常对象)：一些可以导致程序出问题，比如书写错误，逻辑错误或者是api的应用错误等等。为力防止程序的崩溃就要预先检测这些因素，所以java使用了异常这个机制

                                            在java中异常是靠“抛出”  也就是英语的“throw”来使用的，意思是如果发现到什么异常的时候就把错误信息“抛出”

  throws(声明一个异常可能被抛出)：把异常交给他的上级管理，自己不进行异常处理

9、其他（2个）

   enum(枚举，列举，型别)

   assert(断言)

1）48个关键字：abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。

 

2）2个保留字（现在没用以后可能用到作为关键字）：goto、const。

 

3）3个特殊直接量：true、false、null。

修饰符：

• abstract:抽象类修饰符

• class:标准类修饰符

• final:可以声明成员变量、方法、类以及本地变量,final变量是只读的.

• private:修饰仅限于类的内部访问变量的修饰符.

• protected:修饰可以用于子类的访问变量的修饰符.

• public:修饰最大访问权限的访问变量的修饰符.

• static:用于方便在没有创建对象的情况下来进行调用（方法/变量）的修饰符。

Java数据类型：

• boolean:布尔型

• byte:字节类型

• char:字符型

• double:双精度浮点型

• float:单精度浮点型

• int:整型

• long:长整型

• short:短整型

• void:空类型,通常用于方法返回.

语句组成：

• break:中断循环修饰符.

• case:条件选择修饰符.

• catch:异常处理修饰符.

• continue:循环跳过修饰符.

• default:条件选择默认条件修饰符.

• do:循环修饰符

• else:条件选择修饰符

• extends:扩展子类修饰符

• finally:异常处理修饰符.finally作为异常处理的一部分,不管是否异常最后都要处理这部分内容.

• Java for:循环修饰符

• if:条件选择修饰符

• implements:加载接口类修饰符

• import:引用类修饰符.

• instanceof:支出判断对象是否是特定类修饰符.

• interface:接口类定义修饰符.

• new:新建类修饰符.

• package:命名空间修饰符.

• return:返回修饰符.

• super:父类指针修饰符.

• switch:条件选择修饰符.

• sychronized:同步块修饰符.

• this:本类指针修饰符.

• throw:语句异常抛出修饰符.

• throws:方法异常抛出修饰符.

• try:异常处理修饰符.

• while:循环处理修饰符.

特殊含义关键字：

• assert:断言，用于调试，多被junit代替，IDE默认不开启。

• const：预留关键字。

• goto：预留关键字。

• enum:枚举。

• native:本地方法。

• strictfp:精确浮点，可用于类、接口、方法。

• transient:免除变量序列化。

• volatile:被设计用来修饰被不同线程访问和修改的变量。

非java关键字：

• true:布尔值真.

• false:布尔值假.

• null:空值修饰符.

• serilizable:序列化修饰符.

1.访问修饰符的关键字（共3个）

关键字	释义	备注，常用
public	公有的	作用范围：可跨包
protected	受保护的	作用范围：当前包内可用
private	私有的	作用范围：当前类可用

2.定义类、接口、抽象类和实现接口、继承类的关键字、实例化对象（共6个）

关键字	释义	备注，常用
class	类	public class A(){} 花括号里有已实现方法体，类名需要与文件名相同
interface	接口	public interface B(){} 花括号里有方法体，但没有实现，方法体句子后面是英文分号“:”结尾
abstract	声明抽象	public abstract class C(){} 介于类与接口中间，可以有也可以没有已经实现的方法体
implements	实现	用于类或接口实现接口public class A interface B(){}
extends	继承	用于类继承类 public class A extends D(){}
new	创建新对象	A a=new A(); A表示一个类

3.包的关键字（共2个）

关键字	释义	备注，常用
import	引入包的关键字	当使用某个包的一些类时，仅需类名 然后使用ctrl+shift+o或者选定类名 （类或属性或方法）按住ctrl+单击 即可自动插入类所在的包。 如：JFrame 快捷键之后自动加入 import javax.swing.JFrame;
package	定义包的关键字	将所有有关的类放在一个包类以便查找修改等。 如：package javake.flycat.draw002;

 

4.数据类型的关键字（共12个）

关键字	释义	备注，常用
byte	字节型	8bit
char	字符型	16bit
boolean	布尔型	--
short	短整型	16bit
int	整型	32bit
float	浮点型	32bit
long	长整型	64bit
double	双精度	64bit
void	无返回	public void A(){} 其他需要返回的经常与return连用
null	空值
true	真
false	假

5.条件循环（流程控制）（共12个

关键字	释义	备注，常用
if	如果	if(条件语句){执行代码} 如果条件语句成立，就开始执行{}里面的内容
else	否则，或者	常与if连用，用法相同: if(..) {.....} else{...}
while	当什么的时候	while(条件语句){执行代码}
for	满足三个条件时	for ( 初始化循环变量;判断条件;循环变量值迭代 ){}
switch	选择结构	switch(表达式) { case 常量表达式1: 语句1; .... case 常量表达式2: 语句2; default:语句; } default就是如果没有匹配的case就执行它,default并不是必须的。 case后的语句可以不用大括号。 switch语句的判断条件可以接受int,byte,char,short，不能接受其他类型.
case	匹配switch的表达式里的结果	同上
default	默认	default就是如果没有匹配的case就执行它,default并不是必须的。
do	运行	通长与while连用
break	跳出循环	直接跳出循环，执行循环体后的代码
continue	继续	中断本次循环，并开始下一轮循环
return	返回	return 一个返回值类型
instance of	实例	一个二元操作符，和==，>，<是同一类的。测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据

6.修饰方法、类、属性和变量（共9个）

关键字	意思	备注，常用
static	静态的	属性和方法都可以用static修饰，直接使用类名.属性和方法名。只有内部类可以使用static关键字修饰，调用直接使用类名.内部类类名进行调用。 static可以独立存在。
final	最终的不可被改变的	方法和类都可以用final来修饰 ； final修饰的类是不能被继承的 ； final修饰的方法是不能被子类重写。 常量的定义： final修饰的属性就是常量。
super	调用父类的方法	常见public void paint(Graphics g){ super.paint(g); ··· }
this	当前类的父类的对象	调用当前类中的方法（表示调用这个方法的对象） this.addActionListener(al):等等
native	本地
strictfp	严格,精准
synchronized	线程,同步	一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
transient	短暂
volatile	易失

7.错误处理（共5个）

关键字	释义	备注，常用
catch	处理异常	1.try+catch 程序的流程是：运行到try块中，如果有异常抛出，则转到catch块去处理。然后执行catch块后面的语句。 2.try+catch+finally 程序的流程是：运行到try块中，如果有异常抛出，则转到catch块,catch块执行完毕后，执行finally块的代码，再执行finally块后面的代码。 如果没有异常抛出，执行完try块，也要去执行finally块的代码。然后执行finally块后面的语句。 3.try+finally 程序的流程是：运行到try块中,如果有异常抛出的话，程序转向执行finally块的代码。那末finally块后面的代码还会被执行吗？不会！因为你没有处理异常，所以遇到异常后，执行完finally后，方法就已抛出异常的方式退出了。 这种方式中要注意的是：由于你没有捕获异常，所以要在方法后面声明抛出异常。
try	捕获异常
finally	有没有异常都执行
throw	抛出一个异常对象	一些可以导致程序出问题的因素，比如书写错误，逻辑错误或者是api的应用错误等等。为了防止程序的崩溃就要预先检测这些因素，所以Java 使用了异常这个机制。 在Java中异常是靠 "抛出" 也就是英语的"throw" 来使用的,意思是如果发现到什么异常的时候就把错误信息 "抛出"。
throws	声明一个异常可能被抛出	把异常交给他的上级管理，自己不进行异常处理

  8.其他（共2个）

关键字	意思	备注，常用
enum	枚举，列举型别