本文主要介绍Java中几个重要关键字的详细分析。文章围绕主题，具有一定的借鉴意义。需要的小伙伴可以参考一下。希望对你的学习有帮助。

:

目录

1.扩展2。工具3。决赛4。原生5。静态6。瞬变7。同步9。这个10。超级10.1。实例化子类的过程11。访问修饰符

1.extends

用于类继承，用法：类子类名称扩展父类名{}

动物类{}//父类

class extends animal { }//子类用扩展实现继承。

注意：一个类只能用分机关键字声明继承一个父类

用于接口继承接口，用法：接口接口名称扩展接口名称{}

接口裁剪器{}

界面战士{}

Interfaces扩展了快船、勇士{ }//interface类用extends关键字继承了其他接口(多个)。

注意：

接口不能用扩展声明继承其他类接口。只有其他接口接口可以用扩展声明和可以继承多个接口继承。当一个类用implements实现一个接口时，它不仅要实现该接口的方法，还要实现该接口继承的接口的方法。

2.implements

用于声明一个类实现了接口类。用法：类名实现接口名{}

Classnets实现了快船、勇士{ }//用implements关键字声明并实现了两个接口类。

注意：

一个普通类可以用implements关键字声明实现多个接口，但是接口必须由实现所有接口中的所有方法抽象类实现，实现接口的方法可以省略(因为抽象类中可以有抽象方法)。

意义：您可以使用implements关键字声明来实现多个接口，以实现类似多继承的内容。

3.final

使用方法：

修饰类，使这个类不能被继承，修饰方法，使这个方法不能被子类覆盖(仍然可以被继承和调用修改)，使这个属性的值不能被修改(make属性)，修饰010-5900。

常量

最终修饰属性定义时必须是局部变量，不可修改。您可以在以下位置分配初始值

局部常量使用细节：赋初值

静态最终：全局常数

如果final修饰的属性是静态的，则为定义时（显示初始化）。原因：静态属性需要在构造器中的初始值，但是构造函数是在在代码块中调用的，所以可能会导致静态属性在没有创建对象和赋值的情况下被调用。final不能修饰不能在构造器中赋初值，被final和static010调用没有意义。

4.native

类加载

Native用于修改创建对象，修改后的方法变成Java调用but构造方法，可以对外使用。

本地方法是一种java方法，其实现由非java代码提供。

同时修饰的属性

native修饰符的位置必须在方法不会导致类的加载中，对方法访问修饰符的位置没有要求，比如：public native int hashCode()；

本机详细信息：

Native方法基本介绍：，并且没有用native修改的{}方法方法抽象非Java代码实现的接口（本地方法），因为抽象表示这个方法没有实现者，而native方法有实现者。只有用非Java代码实现的本机方法的返回类型可以是任何语言去实现。如果具有本机方法的类被使用方法：，返回类型之前native没有方法体Java不能用

使用JNI(Java本地接口)与其他语言交互

JNI是Java平台的一部分，它允许Java代码与用修饰编写的代码进行交互。

任意类型

用原生方法写java类，生成。java文件，编译生成。带有javac命令的类文件，生成。h文件用javah -jni类名，用C/C(或者其他编程语言)实现原生方法。创建一个. cpp(或其他)文件创建一个由C/C继承编写的文件。在本机方法中，使用System.loadLibrary()方法子类会继承这个，方法，并且可以用作为参数传入。此时，可以通过运行。java程序。

详细步骤参考

语言重写

Java不能直接访问其他语言(比如系统硬件)，但是可以用native关键字修饰使用步骤：Java动态链接库（生成DLL文件），提高程序的效率。

5.static

将变量修改为加载动态库或DLL文件名。

native意义：访问修饰符“静态”数据类型变量名

操作系统底层

静态变量将由借用其他的语言来扩展乘程序的功能，并在静态变量初始化。静态变量的访问方法(以相关访问权限为准):类名、静态变量名或对象名、静态变量名。

修改方法为类变量或使用方法：。

方法：访问修饰符“static”返回数据类型方法名{}

注意事项：

调用方法(受相关访问权限限制):类名、静态方法名或对象名。静态方法名类的所有对象实例和共享都加载了类加载，在静态方法静态方法中存储结构信息类方法这个注意事项：超静态方法静态方法只能访问普通方法和类加载普通方法可以访问静态成员和普通成员来修饰代码块，就变成方法区

静态代码块将在不允许使用加载，优先级与和相同。当有多个静态代码块和静态属性时，初始化顺序将是关键字。

好处：使用static关键字将类的部分成员修改为静态变量，这样我们就可以在静态方法调用这个成员，大大提高了编程效率。

6.transient

静态代码块

Transient用于在实现可序列化接口的类中修改类加载，静态属性，定义顺序transient静态在该类的不需要创建该类的对象中执行。

基本介绍：

导入Java . io . file output stream；

导入Java . io . io exception；

导入Java . io . object output stream；

导入Java . io . serializable；

公共类输出流{

公共静态void main(String[] args)引发IOException {

string file path=' d:\ cat . txt '；

object output stream OOS=new object output stream(new file output stream(file path))；

Oos.writeObject(新猫('小花猫'，3))；

OOS . close()；

}

}

类别Cat实现Serializable {

私有字符串名称；

私人年龄；//没有用瞬态来修饰

公共类别(字符串名称，整数){

this.name=name

this.age=年龄；

}

@覆盖

公共字符串toString() {

返回“汽车”

名称=' '名称'''

，年龄='年龄

'}';

}

}

流中的公共类{

公共静态void main(String[] args)引发IOException，ClassNotFoundException {

string file path=' d:\ cat . txt '；

ObjectInputStream ois=new ObjectInputStream(new file inputstream(file path))；

system . out . println(ois . read object())；

ois . close()；

}

}

在Cat.txt文件中可以看到，两个成员变量都可以序列化，通过反序列化可以读出信息。

当小花猫觉得自己的年龄是隐私，不想被人读出时，成员变量瞬实例对象年龄：

.

私有字符串名称；

私人短暂逗留时间；//用瞬变来修饰

.

此时可以在Cat.txt文件中看到序列化处理时name被，反序列化的成员变量age读取int类型的默认值，表示修饰的成员变量不会进行序列化transient使用例子：。

短暂的细节

被transient修改的成员变量可以理解为：用，生命周期只存在于修饰成员变量，而被只有修改的成员变量(静态变量)也是一个成员变量被序列化，无论是否被transient修改。

因为序列化是保存的实例对象的状态，而静态变量是类的状态。

Transient关键字只能修改对于，不能修改方法和类。transient关键字不能修改局部变量。例如，如果transient关键字修改用户定义的类的变量，则该类需要修饰的成员变量，在类的实例对象序列化的过程中会被忽略Serializable不会参与进行对象的序列化和反序列化过程。

调用者的内存

实现可序列化接口的类的实例对象是不会写进磁盘里进行持久化。如果序列化对象的类实现了可外部化接口，则为不可序列化。如果需要在接口中实现方法来指定要序列化的变量，这与变量Transient实现相同。

7.synchronized

接口

关键字synchronized可以保证注意：，自动进行序列化可以执行synchronized修饰的方法或者代码块。

序列化不会自动进行:

有无，这个方法是用synchronized修饰的。当多个线程调用此方法时，必须遵循修饰无关。

基本介绍：:

当一个线程使用synchronized modified方法时，其他线程必须等待，直到该线程使用完synchronized方法。

在同一时刻

常见的同步方法：public synchronized void m () {}

公共类syn实现Runnable {

静态int I=0；

公共静态void main(String[] args)引发InterruptedException {

syn test=new syn()；

线程t1=新线程(测试)；

线程t2=新线程(测试)；

t1 . start()；

T2 . start()；

}

public synchronized void increase(){//synchronized修饰的同步方法

system . out . println(thread . current thread()。getname()'调用：'我')；

}

@覆盖

公共无效运行(){

for(int j=0；j 100j ) {

增加()；

}

}

}

只有一个线程，因为线程同步，只有一个线程可以获取这个对象的锁，而另一个线程不能，所以不能调用这个对象的synchronized方法。需要多个线程都要使用同一个方法。

从运行结果可以证明，线程1抢了锁，线程0必须等待线程1执行完，否则无法访问同步方法。

静态方法：公共静态同步void m () {}

公共类syn实现Runnable {

静态int I=0；

公共静态void main(String[] args)引发InterruptedException {

syn test=new syn()；

syn test1=new syn()；

线程t1=新线程(测试)；//传入实例对象测试

线程t2=新线程(test1)；//传入实例对象test1

t1 . start()；

T2 . start()；

}

public static synchronized void increase(){//同步静态方法

system . out . println(thread . current thread()。getname()'调用：'我')；

}

@覆盖

公共无效运行(){

for(int j=0；j 100j ) {

增加()；

}

}

}

虽然两个线程实例化了同步机制，但是同步修饰是线程同步机制，synchronized使用方法：还是发生在两个线程中。因为两个线程同时调用一个对象的一个同步方法不是一个对象，所以线程1先抢占了类的锁，而线程0要等线程1执行完释放后才能调用同步方法。

同步代码块：同步(对象){}

公共类syn实现Runnable {

静态对象Object=new Object()；//共享对象

公共静态void main(String[] args)引发InterruptedException {

syn test=new syn()；

syn test1=new syn()；

线程t1=新线程(测试)；

线程t2=新线程(test1)；

t1 . start()；

T2 . start()；

}

@覆盖

公共无效运行(){

Synchronized (object) {//代码块被静态成员变量锁定

for(int j=0；j 100j ) {

system . out . println(thread . current thread()。getname()‘第‘j’次调用’)；

}

}

}

}

同步代码块被两个实例变量共享的一个对象只有一把锁对象锁定。虽然两个线程实例化两个不同的对象，但是等对象被释放后才能调用SYN两个不同的对象对象静态方法只有一个锁。每次线程访问代码块都需要持有锁，而对象锁被其他线程持有，所以需要等待。在访问同步代码块之前，线程1需要等待线程0完成执行。

互斥

因为同步的方法或代码块只能是静态方法是依附与类，所以会产生静态成员。

尝试整个同步类来说只有一个共享的，减少互斥对程序执行的影响。

易变

对象

Volatile用于修改变量。用volatile修改的变量的值被线程修改时，会是同步的局限性：，主存中的值会更新同一时间让一个线程访问。与非易失性变量相比，其他线程可能会在更新之前读取值。

程序的执行效率降低

//现在有线程1和线程2同时执行下面的代码

int I=0；

I=I 1；

执行后的预期结果是I=2；但是可能会出现这样的情况：两个线程同时将I的值读入自己的工作内存，然后分别执行i=i 1的运算，再将结果写入主存，这样两个线程都写i=1，I的最终结果是1，而不是2。

但是，如果I是volatile修改的变量，就不一样了。一个线程修改了I的值后，会立即强制I的值在主存中更新，这会导致I的缓存值在另一个线程的工作内存中无效，于是另一个线程再次从主存中读取I的新值，从而保证I的值是最新的、正确的。

让

修饰的范围最小化:执行一个操作时，要么不间断地完成所有步骤，要么根本不执行。

x=100//是原子操作。

y=x；//它不是原子操作。可以分解为：1。首先读取x的值。2.将x的值写入主存。

x；//它不是原子操作。可以分解为：1。读取x的值；2.加一个；3.写入主存储器。

基本介绍：:多个线程对同一个变量进行操作时，一个线程修改了变量的值，其他线程可以立即看到修改后的值强制将修改的值立即写入主存中:程序执行的顺序是按照代码的顺序。

易变的意思

使得缓存中的该变量的值失效在变量被不同线程修改时保证：因为对于volatile变量，修改后的新值立即被其他线程看到，使用方法：保证：并发编程的三大概念：被volatile禁止，可以保证原子性在volatile修改的变量被操作时，其他语句的顺序不保证。

可见性挥发性

9.this

在方法中修改属性，这个理解为当前对象，用来区分成员方法和形参，通常省略修改方法，这个理解为当前对象，通常省略；不能在静态方法中使用调用构造函数，也不能在构造函数中显式调用通过使用this(参数列表)指定的其他构造函数。您必须在第一行调用其他构造函数。不能在一个构造函数中调用多个其他构造函数。不能在构造函数中调用递归调用或循环调用。

10.super

父类的有序性

可见性去父类找对应的属性，用来区分分子父类重名的属性有序性在重写前调用方法的构造函数：用super(参数列表)指定调用父类super(参数列表)的构造函数必须放在构造函数的第一行。只能选择super(参数表)和this(参数表)中的一个。如果super(参数列表)或this(参数列表)没有在构造函数的第一行显式声明，默认情况下将调用父级。

当方法和属性由静态属性修饰时，这些方法和属性在对象之前被加载到内存中，并且用类加载来加载；这是当前对象的引用，super是指父类的引用。静态方法加载到内存栈时，如果静态方法中有this和super关键字，this和super也会加载到内存中，但是这次没有对对象的引用，this和super没有初始化，所有编译都会报错。

10.1.子类对象实例化的过程

11.访问修饰符

指令重排

一个类中最多只能有一个公共类，文件名要和公共类一致。如果没有公共类，文件名可以是任意的。

以上就是本文对几个重要的Java关键词的详细分析。更多相关Java关键词，请搜索我们之前的文章或者继续浏览下面的相关文章。希望你以后能支持我们！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。