*Java中的关键字*

*Java中的关键字*

说明：

关键字是Java中的一些具有特定含义的单词，定义的变量名不能和关键字冲突。（下面按如下图所示的顺序进行学习）

附-图

一、用于定义访问权限修饰符的关键字

1.private（私有的）

在同一类内可见，抽象类和接口不能修饰为private，该访问修饰符的使用主要是为了隐藏类的实现细节和保护类的内部数据，外部类只能通过私有属性的所属类提供的开放操作去访问，使用对象：变量、方法、不能修饰外部类；

2.default（即默认，什么也不写，非关键字，只是一种权限）

顾名思义不使用任何修饰符，在同一包内可见，例如接口里的变量都隐式声明为 public static final（即使不明写）,而接口里的方法默认情况下访问权限为 public，使用对象：类、接口、变量、方法均可；

3.protected（受保护的）

对同一包内的“类和所有子类”可见，接口和接口的成员变量、成员方法不能声明为protected，使用对象：变量、方法，不能修饰外部类；进一步说明如下：

（1）子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；

（2）子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。

4.public（公共的）

对同一项目内的所有类可见，若几个相互访问的public类分布在不同的包中，只需在本包中导入所使用的包即可访问，使用对象：类、接口、变量、方法均可；

综上所述，依次向下修饰符的访问权限越来越大，数据安全性也将越来越低。

附-图

“说明”详见：

https://www.runoob.com/w3cnote/java-protected-keyword-detailed-explanation.html

二、用于定义类、变量、方法修饰符的关键字

1.abstract（抽象的）

（1）使用对象：类、方法；

（2）一个类若含有抽象方法，则该类必须声明为抽象类，否则会编译报错，抽象方法不能被private修饰，抽象方法的具体实现由其子类完成；

（3）抽象类不能实例化，即不能new一个抽象类对象，只能定义抽象类的引用（抽象类是天生的父类），用来实现多态，但可以有构造方法（有参/无参），为了保证子类对象的顺利创建；

（4）抽象类可以不含有抽象方法，抽象方法的声明以“;”结尾，不带有方法体；

（5）一个类不能同时被abstract和final修饰；

2.final（最后的，最终的）

（1）使用对象：变量，方法，类；

（2）被final修饰的变量必须显示指定初始值，且一旦赋值后，不能再重新赋值，若在初次赋值后又重新赋值，语法上就会出现错误提示；（对于基本数据类型，其值一旦被初始化将不能再改变；对于引用类型，其在初始化之后不能再指向别的对象，但该引用所指向的对象的内容是可以发生变化的）

*注：类的成员变量必须在定义时初始化或构造方法中进行初始化，而局部变量只需在使用之前完成初始化即可。

*补充：https://www.cnblogs.com/xuelisheng/p/11158110.html

（3）父类中被final修饰的方法可以被子类继承，但是不能被重写；

（4）在一个类中被final修饰的方法可以被重载；

（5）被final修饰的类不能被继承；

（6）使用final关键字的目的是可以防止某些特定内容被修改；

3.static（静态的）

（1）使用对象：内部类、成员变量、成员方法、静态代码块；

（2）被static修饰的成员变量独立于对象之外，即无论一个类实例化多少对象，它的静态变量在内存中都只有一份存储，静态成员变量也称为“类变量”，局部变量不能被static修饰；

（3）被static修饰的静态方法同样独立于对象之外，也称为“类方法”，静态方法中不能直接使用非静态的成员变量，也不能调用非静态的方法，但在非静态方法中可以使用静态变量，也可以调用静态方法；

（4）对静态变量和静态方法的访问格式建议“类名.静态变量名”，“类名.静态方法名(参数)”；

（5）加载类时语句的执行顺序为（静态代码块按定义顺序执行-->非静态代码块-->构造方法），该类不管创建多少对象，静态代码块只执行一次；

*注：关于内部类，此处不做粗糙的介绍；

*补充：https://blog.csdn.net/qq_34337272/article/details/82766943

4.synchronized（同步的）

（1）使用场景：多用于并发中的代码块、普通方法、成员方法；

（2）作用：保证同一时刻最多只有1个线程执行被synchronized修饰的方法或代码，其他线程必须等待当前线程执行完该部分代码才能执行；

*更多详细内容，值得阅读：

https://blog.csdn.net/carson_ho/article/details/82992269

https://www.cnblogs.com/paddix/p/5405678.html（锁的级别）

三、用于定义类与类之间关系的关键字

1.extends（继承）

（1）Java中类的继承是单继承，即一个类只能继承一个父类，允许多层继承，简单说就是父类的父类...；

（2）抽象类是天生的父类；

（3）被final修饰的类不能被继承；

（4）子类会继承父类中的所有属性和方法，但被private修饰的属性和方法子类无法直接访问；

（5）extends与泛型相关，对于泛型机制（还未进行系统地学习）。

*关于泛型：https://www.jianshu.com/p/448742e97944

2.implements（实现）

（1）一个类可以实现一个或多个接口（接口中声明的方法只能是抽象方法），实现接口时必须实现接口中的所有方法；

（2）接口允许多继承，即一个接口可以将其他若干个接口的抽象方法继承下来，然后用一个类去实现这个接口，定义多个接口的目的是将多个共性单独抽取出来，在必要的时候进行按需组合即可（设计模式方面的应用）；

（3）先继承后实现，即extends关键字必须在implements关键字之前。

四、用于创建实例/引用实例/判断实例的关键字

1.new（创建实例）

创建实例的时候会开辟两个空间，一个空间在堆区，用于存放所创建的这个对象本身；另一块空间在栈区，存放指向这个对象的引用，两者之间存在映射关系即引用的值就是所指向的对象的内存地址。（调用构造方法只是将对象中的相关属性初始化，并未涉及开辟空间）

2.this（指向当前对象）

（1）当成员变量名和局部变量重名时，可通过“this.成员变量名”来进行区分；

（2）“this.成员方法名(参数列表)”用来调用当前对象的成员方法；

（3）“this(有参/无参)”用来调用该类中的其他构造方法，且只能在构造方法中使用，必须是构造方法中的第一条语句，参数列表决定具体调用哪个构造方法；

（4）需要注意的是两个构造方法不能相互调用，效果类似于没有出口的递归。

3.super（指向父类对象，前提自然是要满足继承）

（1）当子类和父类存在重名的成员变量和成员方法时，在子类中默认访问的是在子类自己的变量和方法（就近原则），如果需要访问父类的变量和方法可以使用“super.成员变量名”和“super.成员方法名(参数列表)”；

（2）在子类的构造方法中需要指定调用父类的哪个构造方法，格式为“super(有参/无参)”，若没有指定，Java编译器会在子类的构造方法内加上“super()”语句（默认调用父类的无参构造）；

（3）使用super关键字调用父类的构造方法时，必须是子类构造方法的第一条语句，因此this和super不能同时出现在一个构造方法中去调用其他构造方法。

4.instanceof

（1）instanceof可以说是Java中的一个双目运算符（只能应用于引用类型），左边的操作数是一个引用变量（对象/实例），右边的操作数通常是一个类或者接口，用来判断前面的对象是否是后面的类、或其子类、实现类的实例，如果是则返回true，不是则返回false；（若左操作数为null，则结果就是false，不关心右操作数是什么类）

*注：对于instanceof的底层实现原理，还未进行系统地学习。

五、用于异常处理的关键字

1.try

2.catch

3.finally

这三个关键字通常一起使用，形如try{...}catch{...}finally{...}，try是将可能发生异常的语句块括起来，以便进行异常处理；catch用来捕获异常，在try中发生异常时才执行，对捕获到的异常进行处理；finally有时候也可缺省，通常为了保证代码执行的安全性还是应该加上最后的finally，无论try和catch是否执行，finally中的语句总会执行，主要用于回收在try中打开的物理资源（如数据库连接、网络连接、磁盘文件等）。

*注：

（1）try，catch，finally中都可以含有return语句，但同时存在时，finally中的return语句会覆盖try和catch中的return；

（2）finally中不含return时，会先将try或catch中的返回结果保存在局部变量表中，直到finally中的语句执行结束然后返回；

（3）try和catch中的return语句不可能同时执行，因为如果try中return了，说明没有发生异常，不会进入catch；如果catch中return了，说明在try中发生异常，执行中断了，开始进行异常处理，不会再返回try中。

4.throw

throw用于抛出异常，作为异常处理的一种方式出现在catch中。

5.throws

throws用在方法签名后面，用于声明该方法可能抛出的异常。

*注：

方法签名包括方法名和参数列表，不包括返回类型、修饰符以及异常类型。

六、用于包的关键字

1.package（包）

package相当于文件夹，作用就是将字节码（.class）文件分类存放，其语法格式为“package 包名”，包名可以是单级包或多级包，中间用“.”分隔，“.”就相当于路径分隔符。

*注：

（1）一个java文件只能属于一个package；

（2）如果有package，必须是程序的第一条可执行语句；

（3）包名的命名规范：全部小写；如果有域名，域名需倒着写，例如域名：“51cto.com”-->“com.51cto”，此时“51cto”不符合标识符规范（不能以数字开头），我们可以使用下划线“com._51cto”，也可以使用一个字母来代替“_”，比如:“package com.m51cto”；“package com.a51cto”。

2.import（java文件中，先package后import再class）

用于导入包，在使用非当前包下的类时需要导包，格式如下：

（1）import 包名.*; //导入指定包中的所有类

（2）import 包名.类名; //导入指定包中的指定类（推荐）

（3）JDK 1.5之后的新增特性——静态导入，格式为

import static 包名.类名; //使用静态导入某个类，可以直接使用该类中的静态属性和静态方法

*注：java中常见的包

（1）java.lang包——java核心类库，String,System,Math...该包下的类可以直接使用，无需导包；

（2）java.util包——工具类，Arrays,List,Map,Set...；

（3）java.io包——i（input）/o（output）和java中流的输入/输出相关的类库；

（4）java.net包——网络编程相关的类库；

（5）java.sql包——与数据库操作相关的类库；

（6）java.text包——国际化或格式化输出相关的类库；

（7）java.awt包 / javax.swing包——图形化界面相关的类库。

七、其他修饰符关键字

1.native（本地的）

*说明：目前笔者还未使用过

*博客学习：

https://www.cnblogs.com/Qian123/p/5702574.html

https://www.cnblogs.com/KingIceMou/p/7239668.html

2.strictfp（strict float point，精确浮点，即确保浮点数运算的准确性）

（1）使用对象：类、接口、方法均可（接口中的方法和构造方法除外）；

（2）作用：可以保证浮点数运算的精确性和一致性（保证程序的可移植性），即在不同的硬件平台进行相同浮点数运算时，执行结果可能不一致，若是指定了strictfp关键字，则可以保证不同硬件平台上的浮点数运算精度一致（符合IEEE-754规范）；

（3）使用：strictfp 声明一个类、接口或者方法时，其所声明的范围内Java的编译器以及运行环境会完全依照浮点规范IEEE-754来执行，当一个类被strictfp修饰时，该类中的所有方法都会自动被strictfp修饰。

3.transient

（1）使用对象：仅限变量（局部变量除外）；

（2）作用：当串行化某个对象时，如果该对象的某个变量被transient修饰，那么这个变量不会被串行化进去，且该变量内容在序列化后无法访问。换句话说，若某个类的成员变量被transient修饰，那么当通过ObjectOutputStream把这个类的某个实例保存到磁盘上时，实际上transient修饰的变量的值是不会保存的；

（3）其他：一个静态变量不管是否被transient修饰，均不能被序列化。

https://baijiahao.baidu.com/s?id=1636557218432721275&wfr=spider&for=pc

*补充：

（1）序列化：Java序列化是指把Java对象转换为字节序列的过程，作用是在传递和保存对象时.保证对象的完整性和可传递性，将对象转换为有序字节流,以便在网络上传输或者保存在本地文件中。

（2）反序列化： Java反序列化是指把字节序列恢复为Java对象的过程，作用是根据字节流中保存的对象状态及描述信息重建对象。

4.volatile

（1）使用对象：变量

（2）作用：

①内存可见性：保证了不同线程对该变量操作时的可见性，即一个线程修改了该变量的值对其他线程也是可见的，被volatile修饰的变量存储在主内存中，任何线程对它进行操作都必须从主内存中获取，然后写回主内存，因此保证了可见性；

②禁止进行指令重排序（在保证单线程最后执行结果一致的前提下，为了减少内存操作速度远慢于CPU运行速度所带来的CPU空置影响，虚拟机会按照自己的一些规则将程序编写顺序打乱以进行程序的优化，重排序不能保证多线程中并发执行的正确性）

*注：推荐https://www.cnblogs.com/dolphin0520/p/3920373.html

5.assert（断言）

*说明：assert关键字，笔者知之甚少，几乎不使用，通过下面的博客，有了一定的认知了解。

https://www.cnblogs.com/HaveChen/p/11453902.html

https://www.cnblogs.com/binbang/p/6386780.html