java基础知识漏洞记录一

编程小猹

已于 2024-06-12 20:39:59 修改

阅读量725

点赞数 19

分类专栏：面试 java基础文章标签： java 开发语言

于 2024-06-12 20:39:32 首次发布

本文链接：https://blog.csdn.net/m0_74229735/article/details/139580476

版权

面试同时被 2 个专栏收录

47 篇文章 1 订阅

订阅专栏

java基础

15 篇文章 0 订阅

订阅专栏

下面是我在阅读JavaGuide面试资料时遇到的不熟悉的知识点总结

JDK9中JRE与JDK新关系

从 JDK 9 开始，就不需要区分 JDK 和 JRE 的关系了，取而代之的是模块系统（JDK 被重新组织成 94 个模块）+ jlink 工具 (随 Java 9 一起发布的新命令行工具，用于生成自定义 Java 运行时映像，该映像仅包含给定应用程序所需的模块) 。并且，从 JDK 11 开始，Oracle 不再提供单独的 JRE 下载。

在 Java 9 新特性概览这篇文章中，我在介绍模块化系统的时候提到：

在引入了模块系统之后，JDK 被重新组织成 94 个模块。Java 应用可以通过新增的 jlink 工具，创建出只包含所依赖的 JDK 模块的自定义运行时镜像。这样可以极大的减少 Java 运行时环境的大小。

也就是说，可以用 jlink 根据自己的需求，创建一个更小的 runtime（运行时），而不是不管什么应用，都是同样的 JRE。

定制的、模块化的 Java 运行时映像有助于简化 Java 应用的部署和节省内存并增强安全性和可维护性。这对于满足现代应用程序架构的需求，如虚拟化、容器化、微服务和云原生开发，是非常重要的。

什么是字节码?采用字节码的好处是什么?

在 Java 中，JVM 可以理解的代码就叫做字节码（即扩展名为 .class 的文件），它不面向任何特定的处理器，只面向虚拟机。Java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以， Java 程序运行时相对来说还是高效的（不过，和 C、 C++，Rust，Go 等语言还是有一定差距的），而且，由于字节码并不针对一种特定的机器，因此，Java 程序无须重新编译便可在多种不同操作系统的计算机上运行。

Java 程序从源代码到运行的过程如下图所示：

我们需要格外注意的是 .class->机器码 这一步。在这一步 JVM 类加载器首先加载字节码文件，然后通过解释器逐行解释执行，这种方式的执行速度会相对比较慢。而且，有些方法和代码块是经常需要被调用的(也就是所谓的热点代码)，所以后面引进了 JIT（Just in Time Compilation） 编译器，而 JIT 属于运行时编译。当 JIT 编译器完成第一次编译后，其会将字节码对应的机器码保存下来，下次可以直接使用。而我们知道，机器码的运行效率肯定是高于 Java 解释器的。这也解释了我们为什么经常会说 Java 是编译与解释共存的语言 。

🌈 拓展：有关 JIT 的实现细节: JVM C1、C2 编译器

HotSpot 采用了惰性评估(Lazy Evaluation)的做法，根据二八定律，消耗大部分系统资源的只有那一小部分的代码（热点代码），而这也就是 JIT 所需要编译的部分。JVM 会根据代码每次被执行的情况收集信息并相应地做出一些优化，因此执行的次数越多，它的速度就越快。

JDK、JRE、JVM、JIT 这四者的关系如下图所示。

下面这张图是 JVM 的大致结构模型。

为什么说 Java 语言“编译与解释并存”？

其实这个问题我们讲字节码的时候已经提到过，因为比较重要，所以我们这里再提一下。

我们可以将高级编程语言按照程序的执行方式分为两种：

编译型：编译型语言会通过编译器将源代码一次性翻译成可被该平台执行的机器码。一般情况下，编译语言的执行速度比较快，开发效率比较低。常见的编译性语言有 C、C++、Go、Rust 等等。
解释型：解释型语言会通过解释器一句一句的将代码解释（interpret）为机器代码后再执行。解释型语言开发效率比较快，执行速度比较慢。常见的解释性语言有 Python、JavaScript、PHP 等等。

根据维基百科介绍：

为了改善解释语言的效率而发展出的即时编译技术，已经缩小了这两种语言间的差距。这种技术混合了编译语言与解释型语言的优点，它像编译语言一样，先把程序源代码编译成字节码。到执行期时，再将字节码直译，之后执行。Java与LLVM是这种技术的代表产物。

相关阅读：基本功 | Java 即时编译器原理解析及实践

为什么说 Java 语言“编译与解释并存”？

这是因为 Java 语言既具有编译型语言的特征，也具有解释型语言的特征。因为 Java 程序要经过先编译，后解释两个步骤，由 Java 编写的程序需要先经过编译步骤，生成字节码（.class 文件），这种字节码必须由 Java 解释器来解释执行。

AOT 有什么优点？为什么不全部使用 AOT 呢？

JDK 9 引入了一种新的编译模式 AOT(Ahead of Time Compilation) 。和 JIT 不同的是，这种编译模式会在程序被执行前就将其编译成机器码，属于静态编译（C、 C++，Rust，Go 等语言就是静态编译）。AOT 避免了 JIT 预热等各方面的开销，可以提高 Java 程序的启动速度，避免预热时间长。并且，AOT 还能减少内存占用和增强 Java 程序的安全性（AOT 编译后的代码不容易被反编译和修改），特别适合云原生场景。

JIT 与 AOT 两者的关键指标对比:

可以看出，AOT 的主要优势在于启动时间、内存占用和打包体积。JIT 的主要优势在于具备更高的极限处理能力，可以降低请求的最大延迟。

提到 AOT 就不得不提 GraalVM 了！GraalVM 是一种高性能的 JDK（完整的 JDK 发行版本），它可以运行 Java 和其他 JVM 语言，以及 JavaScript、Python 等非 JVM 语言。 GraalVM 不仅能提供 AOT 编译，还能提供 JIT 编译。感兴趣的同学，可以去看看 GraalVM 的官方文档：GraalVM。如果觉得官方文档看着比较难理解的话，也可以找一些文章来看看，比如：

既然 AOT 这么多优点，那为什么不全部使用这种编译方式呢？

我们前面也对比过 JIT 与 AOT，两者各有优点，只能说 AOT 更适合当下的云原生场景，对微服务架构的支持也比较友好。除此之外，AOT 编译无法支持 Java 的一些动态特性，如反射、动态代理、动态加载、JNI（Java Native Interface）等。然而，很多框架和库（如 Spring、CGLIB）都用到了这些特性。如果只使用 AOT 编译，那就没办法使用这些框架和库了，或者说需要针对性地去做适配和优化。举个例子，CGLIB 动态代理使用的是 ASM 技术，而这种技术大致原理是运行时直接在内存中生成并加载修改后的字节码文件也就是 .class 文件，如果全部使用 AOT 提前编译，也就不能使用 ASM 技术了。为了支持类似的动态特性，所以选择使用 JIT 即时编译器。

Oracle JDK vs OpenJDK

可能在看这个问题之前很多人和我一样并没有接触和使用过 OpenJDK 。那么 Oracle JDK 和 OpenJDK 之间是否存在重大差异？下面我通过收集到的一些资料，为你解答这个被很多人忽视的问题。

首先，2006 年 SUN 公司将 Java 开源，也就有了 OpenJDK。2009 年 Oracle 收购了 Sun 公司，于是自己在 OpenJDK 的基础上搞了一个 Oracle JDK。Oracle JDK 是不开源的，并且刚开始的几个版本（Java8 ~ Java11）还会相比于 OpenJDK 添加一些特有的功能和工具。

其次，对于 Java 7 而言，OpenJDK 和 Oracle JDK 是十分接近的。 Oracle JDK 是基于 OpenJDK 7 构建的，只添加了一些小功能，由 Oracle 工程师参与维护。

下面这段话摘自 Oracle 官方在 2012 年发表的一个博客：

问：OpenJDK 存储库中的源代码与用于构建 Oracle JDK 的代码之间有什么区别？

答：非常接近 - 我们的 Oracle JDK 版本构建过程基于 OpenJDK 7 构建，只添加了几个部分，例如部署代码，其中包括 Oracle 的 Java 插件和 Java WebStart 的实现，以及一些闭源的第三方组件，如图形光栅化器，一些开源的第三方组件，如 Rhino，以及一些零碎的东西，如附加文档或第三方字体。展望未来，我们的目的是开源 Oracle JDK 的所有部分，除了我们考虑商业功能的部分。

最后，简单总结一下 Oracle JDK 和 OpenJDK 的区别：

是否开源：OpenJDK 是一个参考模型并且是完全开源的，而 Oracle JDK 是基于 OpenJDK 实现的，并不是完全开源的（个人观点：众所周知，JDK 原来是 SUN 公司开发的，后来 SUN 公司又卖给了 Oracle 公司，Oracle 公司以 Oracle 数据库而著名，而 Oracle 数据库又是闭源的，这个时候 Oracle 公司就不想完全开源了，但是原来的 SUN 公司又把 JDK 给开源了，如果这个时候 Oracle 收购回来之后就把他给闭源，必然会引起很多 Java 开发者的不满，导致大家对 Java 失去信心，那 Oracle 公司收购回来不就把 Java 烂在手里了吗！然后，Oracle 公司就想了个骚操作，这样吧，我把一部分核心代码开源出来给你们玩，并且我要和你们自己搞的 JDK 区分下，你们叫 OpenJDK，我叫 Oracle JDK，我发布我的，你们继续玩你们的，要是你们搞出来什么好玩的东西，我后续发布 Oracle JDK 也会拿来用一下，一举两得！）OpenJDK 开源项目：https://github.com/openjdk/jdk 。
是否免费：Oracle JDK 会提供免费版本，但一般有时间限制。JDK17 之后的版本可以免费分发和商用，但是仅有 3 年时间，3 年后无法免费商用。不过，JDK8u221 之前只要不升级可以无限期免费。OpenJDK 是完全免费的。
功能性：Oracle JDK 在 OpenJDK 的基础上添加了一些特有的功能和工具，比如 Java Flight Recorder（JFR，一种监控工具）、Java Mission Control（JMC，一种监控工具）等工具。不过，在 Java 11 之后，OracleJDK 和 OpenJDK 的功能基本一致，之前 OracleJDK 中的私有组件大多数也已经被捐赠给开源组织。
稳定性：OpenJDK 不提供 LTS 服务，而 OracleJDK 大概每三年都会推出一个 LTS 版进行长期支持。不过，很多公司都基于 OpenJDK 提供了对应的和 OracleJDK 周期相同的 LTS 版。因此，两者稳定性其实也是差不多的。
协议：Oracle JDK 使用 BCL/OTN 协议获得许可，而 OpenJDK 根据 GPL v2 许可获得许可。

既然 Oracle JDK 这么好，那为什么还要有 OpenJDK？

答：

OpenJDK 是开源的，开源意味着你可以对它根据你自己的需要进行修改、优化，比如 Alibaba 基于 OpenJDK 开发了 Dragonwell8：https://github.com/alibaba/dragonwell8

OpenJDK 是商业免费的（这也是为什么通过 yum 包管理器上默认安装的 JDK 是 OpenJDK 而不是 Oracle JDK）。虽然 Oracle JDK 也是商业免费（比如 JDK 8），但并不是所有版本都是免费的。

OpenJDK 更新频率更快。Oracle JDK 一般是每 6 个月发布一个新版本，而 OpenJDK 一般是每 3 个月发布一个新版本。（现在你知道为啥 Oracle JDK 更稳定了吧，先在 OpenJDK 试试水，把大部分问题都解决掉了才在 Oracle JDK 上发布）

基于以上这些原因，OpenJDK 还是有存在的必要的！

Oracle JDK 和 OpenJDK 如何选择？

建议选择 OpenJDK 或者基于 OpenJDK 的发行版，比如 AWS 的 Amazon Corretto，阿里巴巴的 Alibaba Dragonwell。

🌈 拓展一下：

BCL 协议（Oracle Binary Code License Agreement）：可以使用 JDK（支持商用），但是不能进行修改。
OTN 协议（Oracle Technology Network License Agreement）：11 及之后新发布的 JDK 用的都是这个协议，可以自己私下用，但是商用需要付费。

Java 和 C++ 的区别?

我知道很多人没学过 C++，但是面试官就是没事喜欢拿咱们 Java 和 C++ 比呀！没办法！！！就算没学过 C++，也要记下来。

虽然，Java 和 C++ 都是面向对象的语言，都支持封装、继承和多态，但是，它们还是有挺多不相同的地方：

Java 不提供指针来直接访问内存，程序内存更加安全
Java 的类是单继承的，C++ 支持多重继承；虽然 Java 的类不可以多继承，但是接口可以多继承。
Java 有自动内存管理垃圾回收机制(GC)，不需要程序员手动释放无用内存。
C ++同时支持方法重载和操作符重载，但是 Java 只支持方法重载（操作符重载增加了复杂性，这与 Java 最初的设计思想不符）。
……

final关键字

在Java中，final关键字是一个非访问修饰符，它可以用来修饰类、方法和变量。final关键字的主要作用是表示一旦某个对象被初始化后，它就不能被改变。下面是final关键字在不同场景下的应用和含义：

final变量：
- 局部变量：当一个局部变量被声明为final时，这意味着一旦该变量被初始化后，它的值就不能被改变。
- 成员变量（实例变量和类变量）：当一个成员变量被声明为final时，这意味着它必须被初始化，并且在对象的整个生命周期内它的值不能被改变。对于实例变量，每个对象都有一个独立的副本，且在对象的构造过程中必须被初始化。对于类变量（静态变量），必须在声明时或者在静态代码块中初始化。
- 常量：当final关键字与static关键字结合使用时，它可以用来定义常量。这样的常量在类中只有一个副本，并且在整个应用程序中都是相同的。
final方法：
- 当一个方法被声明为final时，这意味着这个方法不能被它的子类覆盖（override）。如果一个类不希望它的方法被任何继承它的类改变，那么可以将这些方法声明为final。
final类：
- 当一个类被声明为final时，这意味着这个类不能被继承。任何试图继承final类的操作都会导致编译错误。

使用final关键字的优点包括：

提高性能：对于频繁访问的final变量，Java虚拟机（JVM）可能会进行优化，因为它知道这些变量的值不会改变。
安全性：final关键字可以防止意外修改，确保数据的完整性。
清晰性：final关键字可以作为一个文档，告诉其他开发者某些事物是不应该被改变的。

需要注意的是，final关键字并不保证对象的不可变性。例如，一个final数组或final对象引用本身不能被重新赋值，但是数组或对象的内部状态是可以改变的。如果需要确保对象的不可变性，那么对象内部的所有状态也必须是final的，并且对象本身必须通过恰当的构造方法或工厂方法来确保其不可变性。

继承和聚合都是用来描述类与类之间的关系。他们两者有什么区别？在代码实现上又有什么不同？

继承（Inheritance）和聚合（Aggregation）是面向对象编程中两种不同的关系，它们用于描述类与类之间的关系和交互方式。

继承

继承是一种“is-a”关系，其中一个类（子类）继承另一个类（父类）的属性和方法。子类是父类的一种特殊化，它扩展了父类的功能或者行为。

继承的特点：

单一继承：在大多数面向对象语言中，一个类只能继承一个父类。
类型兼容：子类对象可以被视为父类对象。
行为继承：子类继承父类的所有公有和受保护的方法和属性。
代码复用：继承允许子类复用父类的代码。

代码实现：

java

复制

class Parent {
    public void doSomething() {
        System.out.println("Parent doing something");
    }
}

class Child extends Parent {
    // 子类可以添加新的方法或覆盖父类的方法
}

聚合

聚合是一种“has-a”关系，其中一个类包含另一个类的对象，但被包含的对象可以独立于包含它的对象存在。聚合是一种弱拥有关系，表示整体与部分的关系，但部分可以脱离整体单独存在。

聚合的特点：

部分独立性：被包含的类可以独立于包含它的类存在。
多对多关系：一个类可以是多个类的部分，一个类也可以包含多个其他类的对象。
生命周期独立性：被包含对象的生命周期不一定与包含对象相同。

代码实现：

class Car {
    private Engine engine;
    
    public Car(Engine engine) {
        this.engine = engine;
    }
}

class Engine {
    // 引擎可以独立于汽车存在
}

区别

关系类型：继承是“is-a”关系，聚合是“has-a”关系。
复用方式：继承是通过扩展来复用代码，聚合是通过组合来复用代码。
灵活性：聚合比继承更加灵活，因为它不依赖于类的层次结构。
耦合度：继承通常会导致较高的耦合度，而聚合的耦合度较低。
适用场景：继承适用于当两个类之间有明确的层次关系时，聚合适用于当整体与部分关系不是必须的时。

在设计软件时，应该根据具体的需求和场景来选择使用继承还是聚合。过度使用继承可能导致类层次结构复杂和难以维护，而适当的聚合则可以提高代码的模块化和灵活性。

访问修饰符

Java中的访问修饰符（Access Modifiers）是用来控制类、方法、变量和构造器的访问级别。Java提供了四种不同的访问修饰符，它们分别是：

private：
- 当成员（字段、方法、构造器）被声明为private时，它只能在定义它的类内部访问。
- 这意味着private成员对外部和子类都是不可见的。
- 使用private可以隐藏类的实现细节，从而提高封装性。
default（默认）：
- 当成员没有指定访问修饰符时，它有一个默认的访问级别。
- 默认访问级别通常被称为包私有（package-private），因为这意味着成员可以在同一个包内的任何类中访问，但对包外的类不可见。
- 默认访问修饰符不使用关键字，只是省略了其他访问修饰符。
protected：
- 当成员被声明为protected时，它可以在同一个包内的任何类中访问，以及在不同包中的子类中访问。
- protected允许子类访问父类的某些成员，以实现继承和扩展。
public：
- 当成员被声明为public时，它可以在任何地方被访问，没有任何限制。
- public是访问级别最宽松的修饰符，通常用于API的公开接口。