Java中50个关键字和关键字意义_java关键词对照表-CSDN博客

abstract	1.表明类或者成员方法具有抽象属性 2.Class abstract（抽象类），abstract（）抽象方法（）抽象方法
assert	断言，用来进行程序调试
boolean	基本数据类型之一，布尔类型
break	提前跳出一个块
byte	基本数据类型之一，字节类型
case	用在switch语句之中，表示其中的一个分支
catch	用在异常处理中，用来捕捉异常 Try{可能出现异常的代码} Catch(异常的类 e){如果出现异常类型，那么执行该代码}//可以多个catch Finally{最终一定要执行的代码}
char	基本数据类型之一，字符类型
class	声明一个类
const	保留关键字，没有具体含义
continue	1.回到一个块的开始处 2.用在循环中，跳出本次循环，继续执行下一次循环
default	1.默认，例如，用在switch语句中，表明一个默认的分支 2.创建几口interface并在接口interface中定义默认方法hello world（）如： Default void hello world（）{//代码}
do	用在do-while循环结构中 do循环，while判断。也就是先循环后判读。
double	基本数据类型之一，双精度浮点数类型
else	用在条件语句中，表明当条件不成立时的分支
enum	枚举
extends	1.表明一个类型是另一个类型的子类型，这里常见的类型有类和接口 2.class 子类 extends 父类
final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
finally	用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float	基本数据类型之一，单精度浮点数类型
for	一种循环结构的引导词
goto	保留关键字，没有具体含义
if	条件语句的引导词 if(条件){//代码}eles{//代码}
implements	表明一个类实现了给定的接口
import	表明要访问指定的类或包
instanceof	用来测试一个对象是否是指定类型的实例对象
int	基本数据类型之一，整数类型
interface	接口
long	基本数据类型之一，长整数类型
native	用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new	用来创建新实例对象
package	包
private	一种访问控制方式：私用模式
protected	一种访问控制方式：保护模式
public	一种访问控制方式：共用模式
return	从成员方法中返回数据
short	基本数据类型之一,短整数类型
static	表明具有静态属性
strictfp	用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范 [1]
super	表明当前对象的父类型的引用或者父类型的构造方法
switch	分支语句结构的引导词 int i=2 switch(i){ Case 1://语句 break; Case 2://语句 break; Case 3://语句 break; Default://语句 break; }
synchronized	表明一段代码需要同步执行
this	指向当前实例对象的引用
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
transient	声明不用序列化的成员域
try	尝试一个可能抛出异常的程序块
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步地发生变化
while	用在循环结构中

1.Abstract：

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

2.break 跳出

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

3.case 实例

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

4.catch 捕捉

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

5.char 字符

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

6.continue 继续

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

7.do

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

8.double 双精度型

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

9.else 否则

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

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

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

11.finally 最后

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

12.float 浮点数

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

13.for 为了（循环语句）

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

14.if 如果

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

15.implements 实现

通过类来实现接口

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

16.import 导入

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

17.instanceof 判断对象类型

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

18.int 整数类型

Java(TM)的一个关键字，用来定义一个整形变量

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

19.long 长整型

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

20.private 私有的

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

21.protected 保护类型

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

22.public 公共的

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

23.return 返回

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

24.short 短的

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

25.static 静态的

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

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

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

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

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

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

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

29.transient 短暂的、瞬时的

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

30.try 尝试、审判

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

31.void 空

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

32.volati的声明中表示这个变量是被同时运行的几个线程异步修改的。

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

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

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

35.extends：继承（类继承类，或接口继承接口）

Class1 extends Class2

36.关于break和continue。

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

Java中的50个关键字

关键字也称为保留字，是指java语言中规定了特定含义的标示符。对于保留字，用户只能按照系统规定的方式使用，不能自行定义。Java中有50个常用关键字：

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

关键字类型占字节数备注

boolean 布尔数据类型 1 有true和false两个值

int 整型数据类型 4

long 长整型数据类型 8

short 短整型数据类型 2

byte 字节数据类型 1 大小范围为-27—27-1

float 浮点型（实数型） 4

double 双精度型数据类型 8

char 字符型数据类型 2 (Unicode码)

class 表示一个类不确定可用于定义一个类。

interface 表示一个接口不确定可用于定义一个接口

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

if：表示条件判断，一般用法if（关系表达式），后跟else或{……}

else：条件转折，如if （关系表达式）{语句块1}else{语句块2}，如果关系表达式的值为true，则执行语句块1，否则执行语句块2.

do……while……：do和while一般一起使用，用于表示循环语句。do{……}while（关系表达式）……；当关系表达式的值为true是继续循环。

for：用于表示循环，for循环是最常使用的循环，格式for（表达式a; 表达式b; 表达式c）括号里面的书通常用于控制循环的次数，一般会用一个int类型的变量类计数，如（int i=0; i<10; i++）表达式a用于流程控制的开始值，表达式b表示循环终止条件，表达式c用于计数。

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以外出现的情况。

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

break：用于结束本层循环，或跳出某层循环。

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

　}

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

public int fuction()

{

　　int a;

　　……

　　return a; //返回int型的值

}

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

try{

　……

}catch(类型b){

　……

}finally{

　……

}

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

3.与修饰符相关（12）

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

范围本类同软件包不同包中子类不同包且无继承作用(含义)

public 可以可以可以可以公有的

protect 可以可以可以受保护的

default(无权限修饰符)可以可以当前的

private 可以私有的

如：

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

package c13.swing;

public class HelloWorld {

public void show() {

System.out.println("HelloWorld!");

}

在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是私有的不能被其他包内的对象所引用。

final：(类似于C++中的const)，用法如下：

a，final的变量的值不能被改变；1），final的成员变量； 2）final的局部变量；

b，final的方法不能被重写；

c，final的类不能被继承。

void：空类型，用于函数前表示空返回值。

static：可用于定义静态成员变量或方法

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的。

abstract：抽象的意思，可以用定义抽象类，抽象函数。抽象类的用法规则如下：

a，用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，这个方法叫做抽象方法；

b，含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写；

c，抽象类不能被实例化；

d，抽象方法只需声明，而不需实现。

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

使用对象：字段

介绍：字段不是对象持久的一部分，不应该字段和对象一起串起。

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的线程。");

}

volatile：volatile变量一个时间只有一个线程可以访问。保证线程安全。

可以被写入 volatile 变量的这些有效值独立于任何程序的状态，包括变量的当前状态。

所以，Volatile 变量是一种非常简单但同时又非常脆弱的同步机制，它在某些情况下将提供优于锁的性能和伸缩性。

native：是用作java 和其他语言（如c++）进行协作时用的也就是native 后的函数的实现不是用java写的， native的意思就是通知操作系统，这个函数你必须给我实现，因为我要使用。所以native关键字的函数都是操作系统实现的， java只能调用。

4.与动作相关（10）

package：打包，把java程序写在一个包中。

import：引入报名，用法：

a，写全包名：jsxt.java140.Cat c = new com.bjsxt.java140.Cat

a，引入一个包中的具体某个对象：xt.java140.Cat;

b，引入一个包中的所有象：import com.bjsxt.java140.Cat.*;

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

throws：抛出系统异常

extends：继承（类继承类，或接口继承接口）

implements：实现，通过类来实现接口

this：是指向该对象自身的标示符

super：调用基类的构造函数

instanceof：判断某个对象是否为自己所要的对象

new：用于新建一个对象，即类的实例化

5.其他（5）

true：表示boolean类型的真值

false：表示boolean类型的假值，即不成立的情况

null：表示空值，如果是对象，则表示此对象为空，如果是数据类型，在表示相应数据类型的默认值，如int的默认值为0。

goto：C\C++中实现无条件转向语句，为了结构化程序设计java中现在一般不用。

const：和const一样，在Java中,const是作为保留字以备扩充。可以用final替换const，一般C++中用const，java中用final。