java 按多关键字查询 java中关键字有多少个

转载

mob6454cc7901c3 2023-09-12 10:49:53

文章标签 java 按多关键字查询 Java中的所有关键字呕心总结 Java关键字总结 Java中的关键字关键字 文章分类 Java 后端开发

java官方文档有说明: An identifier cannot have the same spelling (Unicode character sequence) as a keyword , boolean literal , or the null literal, or a compile-time error occurs. While true and false might appear to be keywords, they are technically boolean literals . Similarly, while null might appear to be a keyword, it is technically the null literal . {标识符不能具有与关键字、布尔文字或null文字相同的拼写(Unicode字符序列)或编译时错误。虽然真和假可能是关键字，但它们在技术上是布尔文字。类似地，虽然null可能看起来是一个关键字，但它在技术上是null字面值。}
true、false、null不属于关键字，但是属于标识符规定的关键字，官方意义上关键字只有51个并包含两个保留字，但是这3个都属于标识符规定的，所以它们之间的关系是:标识符包含的关键字-->boolean literal（true,false）、 null literal;

1，java的关键字（keyword）有多少个？

54个关键字+2个保留字=56个关键字(java的关键字都是小写的！！严格的说是52个关键字或51个关键字，分具体的场景)

2，java的保留字(reserve word)有多少个？问题：分别是什么？

2个保留字：Java语言的的保留字是指预留的关键字

1).const 有道释义：n. 常量，常数

用于修改字段或局部变量的声明。它指定字段或局部变量的值是常数，不能被修改

2).goto 有道释义：vi. 转到

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

3.java的关键字分别是什么，作用是什么？

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

关键字	意思	备注，常用形式等
public	公有的	可跨包，开放访问
protected	受保护的	当前包内可用及有继承关系的子类可访问
private	私有的	当前类可用

default：这个访问修饰符是默认的，在Java8之后也是一种关键字，用来定义函数式接口的默认方法。
default：作为访问修饰符的话不需要显式的书写，(即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

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

关键字	意思	备注，常用形式等
class	类	public class A(){} 花括号里有已实现方法体，一个源文件中至多一个用public关键字修饰的类（内部类除外），类名必须要与文件名相同
interface	接口	public interface B(){} 花括号里有默认方法、抽象方法，静态方法，Java8之后可以定义默认方法与静态方法（都是可以实现的）
abstract	声明抽象	public abstract class C(){} 介于类与接口中间，可以有也可以没有已经实现的方法体；有抽象方法的类一定是抽象类
implements	实现	用于类或接口实现接口public class A interface B(){}
extends	继承	用于类继承类 public class A extends D(){}，继承的关键字（Java只支持单继承）
new	创建新对象	A a=new A(); A表示一个类，使用new关键字来创建一个新的对象，申请内存空间

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

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

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

（↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑点击蓝色文字查看具体使用与原理）

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

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

关键字	意思	备注，常用
if	如果	if(){} 如果小括号里面怎么怎么样花括号就怎么怎么样
else	否则，或者	常与if连用，用法相同
while	当什么的时候	while 怎么样就do什么 while(){}
for	满足三个条件时	for ( ; ; ){}
switch	开关	switch(表达式) { case 常量表达式1:语句1; .... case 常量表达式2:语句2; default:语句; } default就是如果没有符合的case就执行它,default并不是必须的. case后的语句可以不用大括号. switch语句的判断条件可以接受int,byte,char,short,不能接受其他类型.
case	返回开关里的结果
default	默认
do	运行	长与while连用
break	跳出循环
continue	继续	中断本次循环，并并开始下一次
return	返回	return 一个返回值类型
instanceof	实例	java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。返回Boolean。

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

关键字	意思	备注，常用
static	静态的	属性和方法都可以用static修饰，直接使用类名.属性和方法名。只有内部类可以使用static关键字修饰一个类，调用直接使用类的对象名.内部类类名进行调用（后面的Java专栏会有讲到这个内部类）。 static可以独立存在。静态块。静态修饰的成员或代码块会在类加载时进行内存申请。
final	最终的不可被改变的	方法和类都可以用final来修饰； final修饰的类是不能被继承的； final修饰的方法是不能被子类重写。 final修饰的属性就是常量。
super	调用父类的方法	常见于继承于父类的子类中的构造器。
this	当前类的父类的对象	隐式的调用当前类的对象（表示调用这个类的对象，引用当前类的对象） this.addActionListener(al):等等
native	本地	只用来修饰方法，意味着该方法是本地方法，本地方法没有具体实现（实现的话需要c++等系统的后台实现，常用的是内存中的运算）。
strictfp	严格,精准	在做Java的浮点运算是使用的关键字，提高浮点运算的精准度。
synchronized	线程,同步	同步锁，解决多线程的数据或逻辑同步问题。
transient	短暂，瞬变的	只能用来修饰成员属性（全局的变量），被修饰的成员属性不参与序列化。
volatile	易失	修饰成员属性,实现在多线程环境中数据的可见性，在不用同步的情况下实现数据同步的一种轻量级同步机制（简单来说就是保证在多线程环境下的数据一致性）

static 例子：

public class Test{

            class A{}   //内部类

            ActionListener al=new ActionListener(···){}   //匿名内部类

     }

注意：静态块优先于其他方法/类的执行（静态修饰的成员或代码块会在类加载时进行内存申请）

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	声明一个异常可能被抛出	把异常交给他的上级管理，自己不进行异常处理

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

String a; if(a == null),

throw new exception("a为null");

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

throws只用在一个方法的末端，表示这个方法体内部如果有异常，这抛给它的调用者。如： public void add(int a, int b) throws Exception(); 这个方法表示，在执行这个方法的时候，可能产生一个异常，如果产生异常了，那么谁调用了这个方法，就抛给谁。（来自百度）

8).不知道怎么归类（共2个）

关键字	意思	备注，常用
enum	枚举，列举类	枚举类型，引用数据类型中的类类型，常用于常量的存储或懒汉模式
assert	断言	assert断言在代码测试时比较实用。

Enum:代表一组常用常量，可用来代表一类相同类型的常量值如：

性别：

public enum SexEnum {

  male, female;

}

颜色：

public enum Color {

  RED, BLUE,GREEN,BLACK;

}

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

附：throw 和throws的差别

区别一：
             throw 是语句抛出一个异常；throws 是方法抛出一个异常；
              throw语法：throw <异常对象>
              在方法声明中，添加throws子句表示该方法将抛出异常。
             throws语法：[<修饰符>]<返回值类型><方法名>（[<参数列表>]）[throws<异常类>]
             其中：异常类可以声明多个，用逗号分割。
区别二：
          throws可以单独使用，但throw不能；
区别三：
            throw要么和try-catch-finally语句配套使用，要么与throws配套使用。但throws可以单独使用，然后再由处理异常的方法捕获。

throws E1,E2,E3 只是告诉程序这个方法可能会抛出这些个异常，方法的调用者可能要处理这些异常。而这些异常E1，E2，E3可能是该函数体产生的。

而throw是明确之处这个地方要抛出这个异常。

void doA() throws Exception1, Exception3 {

  try {

    ……

  } catch(Exception1 e) {

    throw e;

  } catch(Exception2 e) {

    System.out.println("出错了");

  }

  if (a != b)

    throw new Exception3("自定义异常");

}

代码块……中可能产生异常Exception1、Exception2和Exception3。
如果产生Exception1异常，则捕捉了之后抛出由该方法的调用者去做处理；
如果产生Exception2异常，则该方法自己做了处理(打印出了说出错了)，所以该方法就不会再向外抛出Exception2异常了，void doA() throws Exception1,,Excpetion3里面的Exception2也就不用写了；
而Exception3异常是该方法的某段逻辑出错，程序员自己作了处理在该段逻辑错误的情况下抛出异常Exception3，则调用者也需要处理。