面试直击之JavaSE高级复习

最新推荐文章于 2024-06-21 21:10:44 发布

Doris-wr

最新推荐文章于 2024-06-21 21:10:44 发布

阅读量192

点赞数

本文链接：https://blog.csdn.net/Amanda_wr/article/details/107186270

版权

1、Java中的反射
1）说说你对Java反射的理解
Java反射说的是在运行状态中，对于任何一个类，我们都能够知道这个类有哪些方法和属性。对于任何一个对象，我们都能够对它的方法和属性进调用。我们把这种动态获取对象信息和调用对象方法的功能成为反射机制。
2）反射机制的功能

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的方法
生成动态代理

3）反射的具体实现
想要实现反射，就必须先拿到该类的字节码文件对象(.class)，通过字节码文件对象，就能够通过该类中的方法获取到我们想要的所有信息，每一个类对应着一个字节码文件，也就对应着一个Class类型的对象。获取字节码文件对象有三种方式：
方式一：用对象调用getClass()方法来获得该类对应的Class对象，即"对象.getClass()"。该方法是Object类中的一个方法，因此所有对象调用该方法都可以返回所属类对应的Class对象。
方式二：使用Class类的静态方法forName（String className），其中参数className表示所需类的全名。如：Class cobj=Class.forName(java.lang.String），forName()方法声明抛出ClassNotFoundException异常，因此调用该方法时必须捕获或抛出异常。
方式三：用类名调用该类的class属性来获得该类对应的Class对象，即类名.class。
通过方式三获得该类所对应的Class对象，会使代码更安全，程序性能更好，因此大部分情况下建议使用第三种方式。但是如果只获得String类对应的Class对象，则不能使用String.class方式，而是使用Class.forName("java.lang.String”)；如果要想获得基本数据类型的Class对象，可以使用对应的打包类加上.TYPE，例如，Integer.TYPE可获得int的Class对象，但要获得Integer.class的Class对象，则必须使用Integer.class。
2.Java中的设计模式
常见的设计模式有单例模式，代理模式，工厂模式，
1）单例设计模式：简单来说，就是一个应用程序中，某一个类的实例对象只有一个，你没有办法去new，一般通过getInstance()方法来获取该类的实例。单例设计模式有两种，分为懒汉式和饿汉式。
饿汉式：

1. public class Singleton {
2. // 直接创建对象
3. public static Singleton instance = new Singleton();
4.
5. // 私有化构造函数
6. private Singleton() {
7. }
8.
9. // 返回对象实例
10. public static Singleton getInstance() {
11.     return instance;
12.  }
13.}

懒汉式：

1. public class Singleton {
2. // 声明变量
3. private static volatile Singleton singleton = null;
4.
5. // 私有构造函数
6. private Singleton() {
7. }
8.
9. // 提供对外方法
10. public static Singleton getInstance() {
11.	 if (singleton == null) {
12.		 synchronized (Singleton.class) {
13. 		if (singleton == null) {
14. 		singleton = new Singleton();

2）工厂设计模式：工厂模式分为工厂方法模式和抽象工厂模式。
3.JVM垃圾回收机制和常见算法
GC（Garbage Collector)在回收对象前首先必须发现无用的对象，如何去发现定位这些无用的对象？常用的搜索算法如下：
1）引用计数器算法（废弃）
引用计数器算法是给每个对象设置一个计数器，当有地方引用这个对象的时候，计数器+1，当引用失效的时候，计数器-1，当计数器为0的时候，JVM就认为对象不再被使用，是“垃圾”了。
引用计数器实现简单，效率高，但是不能解决循环引用问题（A对象引用B对象，B对象引用A对象，但是A，B对象已不被任何其他对象引用），同时每次计数器的增加和减少都带来了很多额外的开销，所有JDK1.3之后，这个算法就不再使用了。
2）跟搜索算法（使用）
根搜索算法通过一些“GC Roots”对象作为起点，从这些节点开始往下搜索，搜索通过的路径成为引用链，当一个对象没有被GC Roots的引用链连接的时候，说明这个对象是不可用的。
GC Roots对象包括：
a）虚拟机栈(栈帧中的本地变量表)中引用的对象。
b)方法区域中的类静态属性引用的对象。
c)方法区域中常量引用的对象。
d)本地方法栈中native的方法引用的对象。
通过上面的搜索算法得到无用对象之后，就是回收过程，回收算法如下：
1）标记-清除算法
标记-清除算法包括两个阶段：“标记”和“清除”。在标记阶段，确定要回收的对象，并作标记。清楚阶段紧随标记阶段，将标记阶段确定不可用的对象清除。标记-清除算法是基础的收集算法，标记和清除阶段的效率不高，而且清楚后回收大量的不连续空间，这用当程序员需要分配大内存对象时，可能无法找到足够的连续空间。在这里插入图片描述
2）复制算法
复制算法是把内存分成大小相等的两块，每次使用其中一块，当垃圾回收的时候，把存活的对象复制到另一块上，然后把这块内存整个清理掉。复制算法实现简答，运行效率高，但是由于每次只能使用其中的一半，造成内存的使用率不高。现在的JVM用复制方法收集新生代，由于新生代中大部分对象（98%）都是朝生西死的，所以两块内存的比例不是1：1（大概是8:1）
在这里插入图片描述
3）标记-整理算法
标记-整理算法和标记-清除算法一样，但是标记-整理算法不是把存活对象复制到另一块，而是把存活对象王内存的一端移动，然后直接回收边界以外的内存。标记-整理算法提高了内存的利用率，并且它适合在收集对象存活时间较长的老年代。
在这里插入图片描述
4）分代收集
分代收集是根据对象的存活时间把内存分为新生代和老年代，根据各个代对象的存活特点，每个代采用不同的垃圾回收算法。新生代采用复制法，老年代采用标记-整理算法。垃圾算法的实现涉及大量的程序细节，而且不同的虚拟机平台实现的方法也各不相同。

4.JVM的内存结构和内存分配
1）java内存模型：java虚拟机将其管辖的内存大致分为三个逻辑部分：方法区，Java栈和Java堆。
①方法区是静态分配的，编译器将变量绑定在某个存储位置上，而且这些绑定都不会在运行时改变。常量池，源代码中的命名常量，String常量和static变量保存在方法区。
②Java 栈是一个逻辑概念，特点是先进后出。一个栈的的空间可能是连续的，也可能是不连续的。
最典型的Stack应用是方法的调用，java虚拟机每调用一次方法就创建一个方法帧，让推出该方法则对应的方法帧被弹出。栈中的数据也是运行时确定的。
③Java堆分配意味着以随意的的顺序，在运行时进行存储空间分配和回收的内存管理模型。
堆中存储的数据常常是大小，数量，和生命周期在编译时无法确定的。Java对象的内存总是在堆中分配。
2）Java内存分配
1）基础数据类型直接在栈中分配；
2）方法的形式参数，直接在栈空间分配，当方法调用完成后从栈空间回收；
3）引用数据类型，需要用new来创建，既在栈空间分配一个地址空间，又在堆空间分配对象的类变量；
4）方法的引用参数，在栈空间分配一个地址空间，并指向堆空间的对象区，当方法调用完成后从栈空间回收。
5）局部变量new出来时，在栈空间和堆空间中分配空间，当局部变量生命周期结束后，栈空间立刻被回收，堆空间区域等待GC回收。
6）.方法调用时传入的实际参数，先在栈空间分配，在方法调用完成后从栈空间释放；
7).字符串常量在DATA区域分配，this在堆空间分配；
8).数组既在栈空间分配数组名称，又在堆空间分配数组实际的大小

5.Java中引用类型有哪些？
Java中对象的引用分为四种级别，这四种由高到低依次为：强引用，软引用，弱引用和虚引用。

强引用：我们平常写代码在用的就是强引用。如果一个对象拥有强引用，那么垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题
软引用：如果一个对象具有软引用，那么如果内存空间充足，垃圾回收器就不会回收它，如果内存不足了，就会回收这些对象的内存。只要垃圾回收器没回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存，在jvm报告内存不足之前会清除所有的软引用，这样以来gc就有可能收集软可及的对象，可能解决内存吃紧问题，避免内存溢出。什么时候会被收集取决于gc的算法和gc的运行时可用内存的大小。
弱引用
如果一个对象具有弱引用，那该类就是可有可无的对象，因为只要该对象被gc扫描到了随时都会把它回收掉。弱引用和软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的对象。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定很快发现那些只具有弱引用的对象。
虚引用："虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回
收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

6.java内存中的栈，堆和方法区的用法
通常我们定义一个基本数据类型的变量，一个对象的引用，还有就是函数调用的现场保存都使用 JVM 中的栈空间；而通过 new 关键字和构造器创建的对象则放在堆空间，堆是垃圾收集器管理的主要区域，由于现在的垃圾收集器都采用分代收集算法，所以堆空间还可以细分为新生代和老生代，再具体一点可以分为 Eden、Survivor（又可分为From Survivor 和 To Survivor）、Tenured；方法区和堆都是各个线程共享的内存区域，用于存储已经被 JVM 加载的类信息、常量、静态变量、JIT 编译器编译后的代码等数据；程序中的字面量（literal），如直接书写的 100、"hello"和常量都是放在常量池中，常量池是方法区的一部分。栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。
String str = new String(“hello”);
上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而"hello"这个字面量是放在方法区
的。

7.Java的类加载器
1）Java的类加载器的种类都有哪些？

根类加载器(Bootstrap) --C++写的，看不到源码
扩展类加载器（Extension） --加载位置：jre\lib\ext 中
系统(应用)类加载器(System\App) --加载位置：classpath 中
自定义加载器(必须继承 ClassLoader)
2）类什么时候被初始化
①创建类的时候，也就是new一个对象
②访问某个类或接口的静态变量，或者该静态变量赋值
③调用类的静态方法
④反射（class.forName(“com.lyj.load”))
⑤初始化一个类的子类，即文件名和类名相同的哪个类
只有这六种情况才会导致类的初始化
3）类的初始化步骤
①如果这个类还没有被加载和链接，那么先加载和链接
②假如这个类存在直接父类，并且这个类还没有被初始化*注意：一个类加载器中，类只能初始化依次），那就是初始化直接的父类（不适用于接口）
③加入类中存在的初始化语句（如static变量和static块），那就依次执行这些初始化语句，
4）Java类加载体系之ClassLoader双亲委托机制
Java是一种类型安全的语言，它有四类称为安全沙箱机制的安全机制来保证语言的安全性，这四类安全沙箱分别是：a)类加载体系 b) .class文件检测器 c)内置java虚拟机（及语言）的安全性 d)安全管理器及javaAPI
主要讲解类的加载体系：
Java程序中的.java文件编译完会生成.class文件，而.class文件就是通过被称为类加载器的ClassLoader加载的，而ClassLoader在加载过程中会使用“双亲委派行机制” 来加载.class文件，如下图：
BootStrapClassLoader ：启动类加载器，该 ClassLoader 是 jvm 在启动时创建的，用于加载 JAVA_HOME$/jre/lib 下面的类库（或者通过参数-Xbootclasspath 指定）。由于启动类加载器涉及到虚拟机本地实现细节，开发者无法直接获取到启动类加载器的引用，所以不能直接通过引用进行操作。
ExtClassLoader：扩展类加载器，该ClassLoader是在sun.misc.Launcher里作为一个内部类ExtClassLoader定义的（即sun.misc.Launcher$ExtClassLoader）ExtClassLoader 会加载 $JAVA_HOME/jre/lib/ext 下的类库（或者通过参数-Djava.ext.dirs 指定）。
AppClassLoader：应用程序类加载器，该 ClassLoader 同样是在 sun.misc.Launcher 里作为一个内部类AppClassLoader 定义的（即 sun.misc.Launcher$AppClassLoader）,AppClassLoader 会加载 java 环境变量,CLASSPATH 所指定的路径下的类库，而 CLASSPATH 所指定的路径可以通过,System.getProperty(“java.class.path”)获取；当然，该变量也可以覆盖，可以使用参数-cp，例如：java -cp 路径（可以指定要执行的 class 目录）。
CustomClassLoader：自定义类加载器，该 ClassLoader 是指我们自定义的 ClassLoader，比如 tomcat 的StandardClassLoader 属于这一类；当然，大部分情况下使用 AppClassLoader 就足够了。

那么什么是双亲委派机制呢？
1）当 AppClassLoader 加载一个 class 时，它首先不会自己去尝试加载这个类，而是把类加载请求委派给父类加载器 ExtClassLoader 去完成。
2）当 ExtClassLoader 加载一个 class 时，它首先也不会自己去尝试加载这个类，而是把类加载请求委派给BootStrapClassLoader 去完成。
3）如果 BootStrapClassLoader 加载失败（例如在 JAVA_HOME$/jre/lib 里未查找到该 class），会使用ExtClassLoader 来尝试加载；
4）若 ExtClassLoader 也加载失败，则会使用 AppClassLoader 来加载，如果 AppClassLoader 也加载失败，则会报出异常 ClassNotFoundException。

8.JVM怎么加载class
JVM 中类的装载是由类加载器（ClassLoader）和它的子类来实现的，Java 中的类加载器是一个重要的 Java 运
行时系统组件，它负责在运行时查找和装入类文件中的类。
由于 Java 的跨平台性，经过编译的 Java 源程序并不是一个可执行程序，而是一个或多个类文件。当 Java 程序需要使用某个类时,JVM 会确保这个类已经被加载、连接（验证、准备和解析）和初始化。类的加载是指把类的.class 文件中的数据读入到内存中，通常是创建一个字节数组读入.class 文件，然后产生与所加载类对应的 Class 对象。加载完成后，Class 对象还不完整，所以此时的类还不可用。当类被加载后就进入连接阶段，这一阶段包括验证、准备（为静态变量分配内存并设置默认的初始值）和解析（将符号引用替换为直接引用）三个步骤。最后 JVM 对类进行初始化，包括：
1）如果类存在直接的父类并且这个类还没有被初始化，那么就先初始化父类；
2）如果类中存在初始化语句，就依次执行这些初始化语句。类的加载是由类加载器完成的，类加载器包括：根加载器（BootStrap）、扩展加载器（Extension）、系统加载器（System）和用户自定义类加载器（java.lang.ClassLoader 的子类）。从 Java 2（JDK 1.2）开始，类加载过程采取了父亲委托机制（PDM）。PDM 更好的保证了 Java 平台的安全
性，在该机制中，JVM 自带的 Bootstrap 是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。JVM 不会向 Java 程序提供对 Bootstrap 的引用。
下面是关于几个类加载器的说明：
• Bootstrap：一般用本地代码实现，负责加载 JVM 基础核心类库（rt.jar）；
• Extension：从 java.ext.dirs 系统属性所指定的目录中加载类库，它的父加载器是 Bootstrap；
• System：又叫应用类加载器，其父类是 Extension。它是应用最广泛的类加载器。它从环境变量 classpath
或者系统属性 java.class.path 所指定的目录中记载类，是用户自定义加载器的默认父加载器。

9.JVM基础知识
1）既然有GC机制，为什么还会有内存泄露的情况？
理论上 Java 因为有垃圾回收机制（GC）不会存在内存泄露问题（这也是 Java 被广泛使用于服务器端编程的一个重要原因）。然而在实际开发中，可能会存在无用但可达的对象，这些对象不能被 GC 回收，因此也会导致内存泄露的发生。
2）Java中为什么会有GC机制呢？
• 安全性考虑；
• 减少内存泄露；
• 减少程序员工作量。
3）对于Java的GC哪些内存需要回收？
内存运行时 JVM 会有一个运行时数据区来管理内存。它主要包括 5 大部分：程序计数器(Program Counter Register)、虚拟机栈(VM Stack)、本地方法栈(Native Method Stack)、方法区(Method Area)、堆(Heap).而其中程序计数器、虚拟机栈、本地方法栈是每个线程私有的内存空间，随线程而生，随线程而亡。例如栈中每一个栈帧中分配多少内存基本上在类结构确定是哪个时就已知了，因此这 3 个区域的内存分配和回收都是确定的，无需考虑内存回收的问题。但方法区和堆就不同了，一个接口的多个实现类需要的内存可能不一样，我们只有在程序运行期间才会知道会创建哪些对象，这部分内存的分配和回收都是动态的，GC 主要关注的是这部分内存。
总而言之，GC 主要进行回收的内存是 JVM 中的方法区和堆。
4）Java的GC什么时候回收垃圾
在面试中经常会碰到这样一个问题：如何判断一个对象已经死去？
很容易想到的一个答案是：对一个对象添加引用计数器。每当有地方引用它时，计数器值加 1；当引用失效时，计数器值减 1.而当计数器的值为 0 时这个对象就不会再被使用，判断为已死。是不是简单又直观。然而，很遗憾。这种做法是错误的！为什么是错的呢？事实上，用引用计数法确实在大部分情况下是一个不错的解决方案，而在实际的应用中也有不少案例，但它却无法解决对象之间的循环引用问题。比如对象 A 中有一个字段指向了对象 B，而对象 B 中也有一个字段指向了对象 A，而事实上他们俩都不再使用，但计数器的值永远都不可能为 0，也就不会被回收，然后就发生了内存泄露。
所以，正确的做法应该是怎样呢？
在 Java，C#等语言中，比较主流的判定一个对象已死的方法是：可达性分析(Reachability Analysis).所有生成的对象都是一个称为"GC Roots"的根的子树。从 GC Roots 开始向下搜索，搜索所经过的路径称为引用链(Reference Chain)，当一个对象到 GC Roots 没有任何引用链可以到达时，就称这个对象是不可达的（不可引用的），也就是可以被 GC 回收了。
无论是引用计数器还是可达性分析，判定对象是否存活都与引用有关！那么，如何定义对象的引用呢？我们希望给出这样一类描述：当内存空间还够时，能够保存在内存中；如果进行了垃圾回收之后内存空间仍旧非常紧张，则可以抛弃这些对象。所以根据不同的需求，给出如下四种引用，根据引用类型的不同，GC 回收时也会有不同的操作：
1)强引用(Strong Reference):Object obj = new Object();只要强引用还存在，GC 永远不会回收掉被引用的对象。
2)软引用(Soft Reference)：描述一些还有用但非必需的对象。在系统将会发生内存溢出之前，会把这些对象列入回收范围进行二次回收（即系统将会发生内存溢出了，才会对他们进行回收。）
弱引用(Weak Reference):程度比软引用还要弱一些。这些对象只能生存到下次 GC 之前。当 GC 工作时，无论内存是否足够都会将其回收（即只要进行 GC，就会对他们进行回收。）
虚引用(Phantom Reference):一个对象是否存在虚引用，完全不会对其生存时间构成影响。

关于方法区中需要回收的是一些废弃的常量和无用的类。
1.废弃的常量的回收。这里看引用计数就可以了。没有对象引用该常量就可以放心的回收了。
2.无用的类的回收。什么是无用的类呢？
A.该类所有的实例都已经被回收。也就是 Java 堆中不存在该类的任何实例；
B.加载该类的 ClassLoader 已经被回收；
C.该类对应的 java.lang.Class 对象没有任何地方被引用，无法在任何地方通过反射访问该类的方法。
总而言之:对于堆中的对象，主要用可达性分析判断一个对象是否还存在引用，如果该对象没有任何引用就应该被回收。而根据我们实际对引用的不同需求，又分成了 4 中引用，每种引用的回收机制也是不同的。对于方法区中的常量和类，当一个常量没有任何对象引用它，它就可以被回收了。而对于类，如果可以判定它为无用类，就可以被回收了。

10.引起内存溢出的原因及解决方案
1）引起内存溢出的原因有很多种，常见的有以下几种：
①内存中加载的数据量过于庞大，如依次从数据库取出过多数据；
②集合类有对象的引用，使用完后未清空，使得JVM不能回收；
③代码中存在死循环或循环产生过多重复的对象实体；
④使用的第三方软件中的BUG；
⑤启动参数内存值设定的大小。
内存溢出的解决方案：
第一步，修改JVM启动参数，直接增加内存
第二部，检查错误日志，查看“OutOfMemory“错误是否有其他异常或错误。
第三步，堆代码进行走查和分析，找出可能发生内存进溢出的位置
重点排查以下几点：
Ⅰ 检查对数据库查询中，是否有一次获得全部数据的查询。一般来说，如果一次取十万条记录到内存，就可能引起内存溢出。这个问题比较隐蔽，在上线前，数据库中数据较少，不容易出问题，上线后，数据库中数据多了，一次查询就有可能引起内存溢出。因此对于数据库查询尽量采用分页的方式查询。
Ⅱ 检查代码中是否有死循环或递归调用。
Ⅲ 检查是否有大循环重复产生新对象实体。
Ⅳ检查对数据库查询中，是否有一次获得全部数据的查询。一般来说，如果一次取十万条记录到内存，就可能引起内存溢出。这个问题比较隐蔽，在上线前，数据库中数据较少，不容易出问题，上线后，数据库中数据多了，一次查询就有可能引起内存溢出。因此对于数据库查询尽量采用分页的方式查询。
Ⅴ.检查 List、MAP 等集合对象是否有使用完后，未清除的问题。List、MAP 等集合对象会始终存有对对象的引用，使得这些对象不能被 GC 回收。
第四步，使用内存查看工具动态查看内存使用情况。