Java关键字学习

最新推荐文章于 2024-08-27 17:31:13 发布
最新推荐文章于 2024-08-27 17:31:13 发布
阅读量407 收藏 3
点赞数 2
分类专栏： Java学习 Java关键字 Java 关键字总结 文章标签： Java Java学习 Java关键字 关键字 关键字总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nimeia2014/article/details/89296531
版权

Java关键字简介

Java关键字（Keywords）是计算机语言里预先定义的符号，是具有特别意义的标识符，有时也包括保留字（Reserved Words），广义上也包括特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等。

到目前为止，java语言共确定48个关键字和14个保留字。为便于总结，我自己根据对java语言的学习经历和经验，对已有明确定义的48个关键字进行分类和解释，本表格仅仅是自己学习时根据不同关键字的理解进行分类，如有错误，欢迎大家指正。

Java关键字介绍
类型声明型：13基本数据类型：8boolean char byte short int long double float                  
引用数据类型：3class interface enmu           
特殊类型：2void package                       
类型声明标识型：3extends implents  import  
修饰符型：11访问权限修饰符：3public  protected 默认权限（无符号）private                        
并发功能修饰符：2synchronized volatile           
其他功能修饰符：6abstract final static transient strictfp native           
程序控制型：17条件判断：5if else switch case  default          
循环：5for while do continue break 
异常处理:6try catch finally throw throws assert       
方法终止：1retrun                        
变量引用指代型：2this super                            
运算符型：2new instanceof                    
保留字：14true false null const goto outer inner byValue cast rest future genenric var operator

Java关键字的详细介绍

（一）类型声明型关键字

基础数据类型

Java中规定8个关键字分别对应8种基本数据类型。可修饰变量，包括成员变量、本地变量以及方法参数，也可用在成员方法的声明中表示返回值的类型。

（1）boolean：表示布尔型数据，在计算机内存中占用1个字节（1byte =  8bit），储存逻辑运算的结果，有且仅有true和false两个值，默认值为false（00000000） 。

（2）char：表示字符型数据，在计算机内存中占用2个字节，无符号整型，范围为0~2^16-1，但实际存储的值是编码表中对应的各种符号。java使用Unicode编码，在Unicode编码表中，可以用两个字节表示一个汉字，因此java中一个char能存一个汉字，注意，Unicode只收录了常用汉字。

（3）byte ：表示字节型数据，在计算机内存中占用1个字节，有符号整型，范围为-2^7~2^7-1，存储的是整数数字。

（4）short ：表示短整型数据，在计算机内存中占用2个字节，有符号整型，范围为-2^15~2^15-1，存储的是整数数字。

（5）int ：表示整形数据，在计算机内存中占用4个字节，有符号整型，范围为-2^31~2^31-1，存储的是整数数字。

（6）long ：表示长整型数据，在计算机内存中占用8个字节，有符号整型，范围-2^63~2^63-1，存储的是整数数字。

（7）double：表示单精度浮点型数据，在计算机内存中占用4个字节，存储的是小数。

（8）float：表示双精度浮点型数据，在计算机内存中占用8个字节，存储的是范围更广的小数。

引用数据类型

（1）class：表示声明一个类，即类声明的标志。外部类（严谨地说应该是字节码文件名中第一个$左边那个类，这么说好累啊，e.g. Boy$Girl$Love.class中的Boy类) class前面须有访问权限修饰符public或者默认权限（又称为包访问权限符，默认不写，不管是内部类还是外部类，此时该类只能在本包中使用），final或者abstract（二者不可得兼，final修饰的类不可继承，不管是外部类还是内部类）中的组合；内部类可用static、final、abstract修饰，可选用任意的访问权限修饰符（public/protected/默认权限/private）。当然，类内部也可以嵌套接口（内部接口，可用abstract、static修饰，默认abstract已存在可不写）、枚举（内部枚举，可用static修饰）、类（可用final、static、abstract修饰），可选用任意的访问权限修饰符。另外，所有的类的默认父类是Java.Lang.Object，在类声明中明确指示父类时，父类为指示的类，因为类是单继承。

public class ClassDemo {
	@Test
	public void name() {	
		System.out.println(ClassDemo.class);//class testClass.ClassDemo
		System.out.println(ClassDemo.class.getSuperclass());//class java.lang.Object
	}
	
	public static class InnerClass extends Thread{
		@Test
		public void name() {	
			System.out.println(InnerClass.class);//class testClass.ClassDemo$InnerClass
			System.out.println(InnerClass.class.getSuperclass());//class java.lang.Thread
		}
	}
}

（2）interface：表示声明一个接口，即接口声明的标志。interface前面只能用public或者默认权限（可不写）修饰，以及abstract（默认已存在，可不写）。public代表可跨包实现，而默认权限则只能在本包实现。接口内也可嵌套类（可用final、static、abstract修饰）、枚举（可用static修饰）、接口（可用static、abstract修饰，默认abstract已存在可不写），可选用任意的访问权限修饰符。

public interface InterfaceDemo {
	interface InnerInterface{
		void test1();
	}
}

public class Test implements InterfaceDemo{
	@org.junit.Test
	public void name() {
		System.out.println(InterfaceDemo.class);//interface testInterface.InterfaceDemo
		System.out.println(InterfaceDemo.class.getSuperclass());//null
	}	
	@org.junit.Test
	public void name1() {	
		System.out.println(InterfaceDemo.InnerInterface.class);//interface testInterface.InterfaceDemo$InnerInterface
		System.out.println(InterfaceDemo.InnerInterface.class.getSuperclass());//null
	}	
}

（3）enmu：表示声明一个枚举，即枚举声明的标志。enmu前面只能用public或者默认权限（无符号可不写）修饰，作用同上。枚举可以实现一个或多个接口，但是枚举的默认父类是java.lang.Enum<E extends Enum<E>>且不可更改，而不是java.lang.Object，所以枚举不能显示的继承其他类，类继承的唯一性。可嵌套类（可用static、final修饰）、接口（可用abstract、static修饰，默认abstract已存在）、枚举（可用static修饰），可选用任意的访问权限修饰符。另外，枚举的构造器必须用private或者默认权限修饰，这是规定。

特殊类型

（1）void：用在方法声明中，表示方法执行后无返回值，也可以说是没有类型要求的返回值，那就是不存在喽。

（2）package：表示包，为避免类名之间的冲突而设置的空间命名方式，一个类（class）必须在一个包（package）中，包名+类名即全限定名，可用来唯一定位类所在位置。由于package都具有相近的结构，可以将其视为一种特殊的类型。

（二）类型声明标识型关键字

（1）extends:表示继承关系，即存在父类或父接口，有两个表述，（一）子类继承父类（非final修饰的类）的非private修饰成员以及非默认权限成员（若子父类不在一个package）；（二）子接口继承父接口，接口不存在以上规则，因为接口中的成员变量（Fields）只能用public static final修饰，且方法只能用public（只有public访问权限）以及abstract、default、static（三者中的一个），strictfp修饰。不管是类还是接口，只能一对一继承。

另外，补充一下类继承中可见性原理，包括继承时和继承后：①继承时：同一包下，除final修饰的类外，都可被继承；不同包下，除final修饰的类外，public（必须有该标识符）修饰的外部类和public static（必须有这两个标识符）修饰的内部类可被继承。②继承后：同一包下，除private修饰的变量，都可被访问；不同包下，只有public和protected修饰的变量可被访问。

（2）implemments:表示实现关系，即一个类实现接口，相当于继承接口中声明的成员变量以及重写接口中的抽象方法，其中接口中的成员变量默认public static final修饰，接口中的方法默认是public访问权限，以及abstract、default、static（三者中的一个）、strictfp修饰，可以一对多实现，面向接口编程思想实现的途径。

（3）import：表示导包，即该包中的类被调用者可见，也相当于添加依赖关系，但不影响访问权限修饰符的作用。若调用者调用者与被调用者不在同一包下，那么二者依然是不同包。

（三）修饰符型关键字

访问权限修饰符

这里就不详细总结了，大家可根据以上内容自行贯通。附上经典的表格说明，^_^。

 同一类中（同一包的特殊情况）同一包中（不含同一类情况）子类中（同一包或不同包）不同包中
public        √          √          √       √ 
protected        √          √          √       ×
默认包访问权限（无符号）        √          √          ×       ×      
private        √          ×          ×       ×

并发功能修饰符

（1）synchronized：由JVM底层实现的同步锁机制，可用来修饰方法和代码块。修饰方法时，该方法为同步方法，锁是对象锁this（指代调用者），方法每次只允许一个线程调用，该关键字只能修饰非抽象方法（也就是说，不能和abstract连用），因为方法中有具体的方法体时JVM才能确定同步内容，一般放在返回值类型前；修饰代码块时，该代码块为同步代码块，一般结构如下：

synchronzied(Object obj){
    //To do
}

其中，obj为锁对象，既可以是类的实例（new出来的对象的引用）,称为对象锁，也可以是类本身（类名.class），称为类锁。

补充一点：同步非静态方法就是对象锁，同步静态方法就是类锁，因为静态（static修饰的）的都属于类。

（2）volatile：表示轻量级的同步机制，由JVM底层实现，只能用来修饰成员变量，被修饰的成员变量保证多个线程中的“内存可见性”，从而确保并发访问共享数据时数据的有效性和正确性。

其他功能修饰符

我之所以将以下关键字称为其他功能修饰符，实在是抽取不到它们之间的共性了，姑且就这么分吧。

（1）abstract ：表示抽象，没有具体实现。只能修饰class/interface/成员方法，修饰类（class）时类为抽象类，修饰接口（interface，默认已存在可不写），修饰方法（method）时方法为抽象方法，无方法实现体。

（2）final：表示最终、不可改变。修饰基本数据类型时，表示变量的值不变，修饰引用数据类型时，表示内存地址不变。可修饰类（不可被继承）、方法（可被子类继承但不能被子类重写）、变量包括成员变量和本地变量（不可变性）、方法的参数（只有8个基本数据类型关键字和final才能修饰方法的参数），不能修饰接口（因为接口是用来实现的）、枚举。不可与abstract同用，因为abstract要求方法实现。

（3）static：表示静态，被static修饰的都是属于对象的，可利用对象名直接调用；在类加载过程中，执行<cinit>方法初始化时执行static修饰的代码，且仅加载一次。可修饰成员方法、成员变量、代码块、内部类、内部接口、内部枚举，注意：在接口中修饰方法时该方法必须有方法体。

（4）transient：表示不被序列化。只能用来修饰成员变量，当对象存储时，被它修饰的成员变量的值不需要被存储。transient关键字标记的成员变量不参与序列化过程。

（5）strictfp：表示精确浮点运算（strict float point ） 。strictfp 关键字可应用于类、接口、枚举和方法。使用 strictfp 关键字声明一个方法时，该方法中所有的float和double表达式都严格遵守FP-strict的限制,符合IEEE-754规范。当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。严格约束意味着所有表达式的结果都必须是 IEEE 754 算法对操作数预期的结果，以单精度和双精度格式表示。在浮点运算时，可以用strictfp保证不同硬件平台所执行的运算结果的一致性。

（6）native：表示调用非java代码实现的方法，此类方法的实现体为非java代码实现体。native预示着方法有实现体，但该实现体是非java代码，因此，native不能与abstract连用，不能在接口中存在（abstract表示无方法实现体，default和static修饰的接口中方法要求的是java代码实现体）。可与public protected 默认权限 private , boolean char byte short int long double float void , synchronized static final strictfp 关键字连用。

对修饰符作用的总结：

（1）类类型中：

类：修饰符有public 默认权限 , strictfp abstract final且abstract与final不连用；嵌套类中，修饰符有public protected 默认权限 private , strictfp abstract static final且abstract与final不连用；嵌套接口中，修饰符有public protected 默认权限 private , strictfp abstract static其中abstract是默认已存在；嵌套枚举中，修饰符有public protected 默认权限 private , static strictfp。

成员变量：修饰符有public protected 默认权限 private , boolean char byte short int long double float , volatile final static transient 。

成员方法：修饰符有public protected 默认权限 private , boolean char byte short int long double float void , synchronized static final strictfp , abstract（抽象方法），native（非Java代码实现）。

方法参数：修饰符有 boolean char byte short int long double float , final。

本地变量：修饰符有public protected 默认权限 private , boolean char byte short int long double float , final。

（2）接口类型中：

接口：修饰符有public 默认权限 , abstract 默认已存在；嵌套类中，修饰符有public protected 默认权限 private , strictfp abstract static final且abstract与final不连用；嵌套接口中，修饰符有public protected 默认权限 private , strictfp abstract static其中abstract是已默认存在；嵌套枚举中，修饰符有public protected 默认权限 private , strictfp static。

成员变量：修饰符有public , static final ，并且是默认都存在的。

成员方法：修饰符有public默认存在的 , abstract default static且三者只能选用一个 , strictfp。

方法参数：修饰符有 boolean char byte short int long double float , final。

本地变量：只存在default与static修饰的方法中，修饰符有public protected 默认权限 private , boolean char byte short int long double float , final。

（3）枚举类型中：

枚举：修饰符有public 默认权限 , strictfp；嵌套类中，修饰符有public protected 默认权限 private , strictfp abstract static final且abstract与final不连用；嵌套接口中，修饰符有public protected 默认权限 private , strictfp abstract static其中abstract是默认存在的；嵌套枚举中，修饰符有public protected 默认权限 private , strictfp static。

成员变量：修饰符有public protected 默认权限 private , boolean char byte short int long double float , volatile final static transient 。注意，枚举变量前面默认public static final修饰。

成员方法：修饰符有public protected 默认权限 private , boolean char byte short int long double float void , synchronized static final strictfp abstract native。

方法参数：修饰符有 boolean char byte short int long double float , final。

本地变量：修饰符有public protected 默认权限 private , boolean char byte short int long double float , final。

（四）程序控制型关键字

条件判断

（1）if ：表示判断并选择。常用的条件判断语法，可单独使用，也可与else连用，若符合条件，则进入执行体。常用格式如下：

if(condition){
    //代码执行体
}else{
    //代码执行体
}

（2）else： 表示判断并选择。常用的条件判断语法，不可单独使用，只能与if连用，常用格式如上。

（3）switch：表示判断并选择。常用的条件判断语法，不可单独使用，只能与case连用，在执行体中根据case判断结果决定具体执行代码。

switch(Object obj){

    case: obj.value
        //代码执行体
        break;

    ......//可存在许多case

    default:
        //默认的代码执行体
        break

}

（4）case：表示判断并选择。同上。

（5）default  :表示默认。在switch条件判断语句中，表示在无匹配case的条件下的执行结果；另外，在1.8JDK中，该关键字可在接口中修饰方法，但被其修饰的方法必须有方法体。

循环

（1）for：表示迭代循环，一般在确定循环次数时可使用此循环结构，并衍生出一种增强循环。

(1)数组常用
for (int i = 0; i < args.length; i++) {
	String string = args[i];
	//执行代码
}
(2)集合迭代器
for (Iterator iterator = collection.iterator(); iterator.hasNext();) {
	type type = (type) iterator.next();
	//执行代码
}
(3)增强for循环
for (String string : args) {
	//执行代码
}

（2）while：表示迭代循环，可单独使用，也可与do连用。

        （1）迭代器
        while (it.hasNext()) {
			type type = (type) it.next();
			//执行代码
        }
        （2）一般判断条件
        while (condition) {
			//执行代码
        }

（3）do：表示循环中的执行体，即使判断条件不成立，do代码块也会执行一次。

		do {
			//执行代码
		} while (condition);

（4）continue：表示在循环体中，对满足条件的循环不执行，直接跳过，执行下一个循环。

for (int i = 0; i < 5; i++) {
	if (i==3 ) {
		continue;
	}
	System.out.println(i);//结果是0/1/2/4
}

（5）break：表示在循环体中，对满足条件的循环不执行，直接跳出本循环体，结束本循环。注意只是跳出本循环，不影响外层循环。

for (int i = 0; i < 5; i++) {
	if (i==3 ) {
		break;
	}
	System.out.println(i);//结果是0/1/2
}

异常处理

异常处理是程序编写和运行时重要的环节，最简单的处理方式就是使用throws关键字直接抛给调用者，当然也可人为控制的处理方式，那就是使用try catch finally throw代码块进行处理。

（1）try：表示在代码块执行前，对代码进行异常检查。若发现有异常，则异常交给catch代码块进行处理；否则，正常执行代码。

（2）catch：表示对捕获的异常进行处理。一般在该代码块中会使用throw关键字显示异常信息。

（3）finally：表示无论try代码块中是否存在异常，都会执行finally代码块中的代码。

（4）throw：表示显示异常信息或遇到异常时显示的信息。

（5）throws: 表示异常处理方式，运行中若出现异常，则将异常向上抛出，抛给调用者，一般用在方法声明和类声明中。补充向上抛出异常规则。

（6）assert：表示在代码执行前的一种检查行为。编写代码时，总是会做出一些假设，断言就是用于在代码中捕捉这些假设，可以将断言看作是异常处理的一种高级形式。若判断结果为false，则程序抛出异常，并中止执行，类似于Junit单元测试。

public class Demo {
	public static void main(String[] args) throws Exception {
		name();
	}
	public static int name() throws Exception{
		int a = 0;
		try {
			a = 1/0;
		} catch (Exception e) {
			throw new ArithmeticException("Error!");//显示异常信息：
            //Exception in thread "main" java.lang.ArithmeticException: Error!
		}finally {
			System.out.println("Always Operation!");
		}		
		return a;
	}

执行结果如图：

方法终止

（1）retrun：表示方法正常执行结束的标志，可单独使用或者后面接方法执行的结果。

（五）变量引用指代型

（1）this：表示对象本身的引用，默认存在的一个成员变量或构造方法this()。

（2）super：表示父类对象的引用，默认存在的一个成员变量或构造方法super()。

（六）运算符型

（1）new：表示创建对象，可理解为动态内存分配符（一种抽象运算吧）。比如代码<code>Object obj = new Object(); </code>在执行时，第一步，将方法压栈（stack）执行，将要执行的方法信息加载；第二步，执行对象创建操作，执行<init>方法，调用Object类的无参构造方法，在JVM的堆内存（heap）中创建对象并分配一个内存地址；第三步，执行赋值操作，将内存地址赋值给obj引用变量。大致可以这么理解，因此，new可以算是一种运算符。

（2）instanceof：表示类型判断，比如代码<code>obj.instanceof Object; </code>在执行时,对象引用obj与Object类进行判断，若obj是Object的子类或自身，则返回true，否则返回false。

（七）保留字

保留字就不作介绍了，等官方慢慢产出吧。

积硅步，汇小流
关注
专栏目录
java关键字
m0_46566163的博客
09-28 278
零、关键字一览： abstract continue for new switch assert*** default goto* package synchronized boolean do if private this break double implements protected throw byte else import public throws case enum**** instanceof return transient catch extends int short try c
Java关键字
Goo_Woo的专栏
04-28 779
Java关键字
Java常用关键字详解
最新发布
Broken_x的博客
08-27 611
Java中的关键字是具有特殊含义的保留字，每个关键字都有其特定的作用、意义和用法。类和访问控制class：定义类。publicprivateprotected：控制访问权限。static：定义类级别的成员。final：定义常量、不可继承的类或不可重写的方法。方法和返回类型void：表示方法没有返回值。return：从方法中返回值。条件和循环ifelse：条件判断。forwhiledo：循环控制。switchcasedefault：多路选择。breakcontinue：控制循环流程。
java关键字学习
Longui的博客
07-10 257
博客——java关键字学习   Java语言中大概有着50个左右的关键词，即在java中一些固定的单词，都被赋予了固定的含义的单词。在这些关键词中，不被允许用来定义变量名、方法名、类名等。   对java关键字分类可分为8类：第一，访问权限关键字：public、protected、private；第二，跟类相关的关键字：class、interface、extends、implements、i
Java关键字、标识符、注释、转义字符.docx
11-20
Java 关键字、标识符、注释、转义字符详解 Java 语言中有四个重要的概念：关键字、标识符、注释和...理解 Java 关键字、标识符、注释和转义字符是编写 Java 代码的基础，这些概念对于 Java 语言的学习和应用非常重要。
java volatile 关键字 学习
06-26
java volatile 关键字 学习
java关键字总结
04-01
下面是对Java关键字的详细总结。 一、类型关键字 1. 基本数据类型：`byte`（1字节）、`short`（2字节）、`int`（4字节）、`long`（8字节）用于表示整数；`float`（4字节）、`double`（8字节）用于表示浮点数；`char...
java关键字static学习心得
08-28
Java中的`static`关键字是Java语言中的核心特性之一，它有着多方面的用途，对理解和编写高效、整洁的代码至关重要。以下是对`static`关键字详细解释和应用的总结： 1. **静态变量（类变量/静态变量）** - `static`...
Java关键字学习（一）：this关键字
qq_36955849的博客
12-12 321
1
Java关键字大全 Java关键字
10-05
Java关键字大全 doc 文档　,学习必备,目前我看到的最好的关键字文档
java关键字学习（转）
qq_39809613的博客
10-31 152
https://blog.csdn.net/Myuhua/article/details/81411707
细节决定成败，浅析一些容易被忽视的Java关键字
Leeon的博客
08-28 1791
一、default关键字 default关键字，并不是访问修饰符中的default（默认的访问权限，不加public、private、protected访问修饰符的情况自动使用，同一包下的类可以访问字段），而是Java8的新特性，default关键字是不能修饰字段的。 Java8以前的认知，Java的接口中的方法只能定义不能有方法体，方法体是由实现类去实现的。但是如果当我们要去扩展接口时，所有
java关键字名单
Java极客技术
07-11 2934
大家好，我是本周的带班编辑 子悠(这个月来的早了点)，本周由于轮班小哥懿在出差，所以就由我为大家排版并送出技术干货，大家可以在公众号后台回复“java”，获得作者 Ja...
java的关键字
weixin_44606912的博客
06-05 3285
这个方法表示，在执行这个方法的时候，可能产生一个异常，如果产生异常了，那么谁调用了这个方法，就抛给谁。因为你没有处理异常，所以遇到异常后，执行完finally后，方法就已抛出异常的方式退出了。程序的流程是：运行到try块中，如果有异常抛出，则转到catch块,catch块执行完毕后，执行finally块的代码，再执行finally块后面的代码。3）两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。
2、关键字与标识符
06-08 365
关键字：有特殊含义，被保留的，不能随意使用的字符。 关键字的特点：1、完全小写的字母。 2、在notepad++ 中有特殊颜色。 关键字 含义 abstract 表明类或者成员方法具...
Java关键字学习笔记——mars老师讲解
以下是对给定标签和部分内容中的Java关键字的详细解释： 1. `abstract` - 抽象的，用于定义抽象类和抽象方法。抽象类不能被实例化，通常用作其他类的基类，定义接口或者提供部分实现。抽象方法没有具体的实现，需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值