【后端】Java面试题体系

Java面试题体系

一、面向对象

1. 面向过程与面向对象

• 面向过程：注重事情的每一个步骤及顺序
• 面向对象：更注重事情有哪些参与者（对象）、及各自需要做什么
• 比如：洗衣机洗衣服
  • 面向过程会将任务拆解成一系列的步骤（函数）
    • 打开洗衣机
    • 放衣服
    • 放洗衣粉
    • 清洗
    • 烘干
  • 面向对象会拆出人和洗衣机两个对象
    • 人：打开洗衣机 放衣服 放洗衣粉
    • 洗衣机：清洗 烘干
• 面向过程比较直接高效，面向对象更易于复用、扩展和维护

2. 面向对象三大特性

• 封装
  • 明确标识出允许外部使用的所有成员函数和数据项
  • 内部细节对外部调用透明，外部调用无需修改或者关心内部实现
    • javabean的属性私有，提供getset对外访问，因为属性的赋值或者获取逻辑只能由javabean本身觉得。而不能由外部胡乱修改。
    • orm 框架
      • 操作数据库，不需要关心连接如何建立、sql是如何执行的，只需要引入mybatis，调方法即可
• 继承
  • 继承基类的方法，并做出自己的改变和/或扩展
  • 子类共性的方法或者属性直接使用父类的，而不需要自己再定义，只需扩展自己个性化的
• 多态
  • 基于对象所属类的不同，外部对同一个方法的调用，实际执行的逻辑不同。
  • 继承，方法重写，父类引用指向子类对象
  • 父类类型 变量名 = new 子类对象;
  • 无法调用子类特有的功能

二、JDK、JRE、JVM 三者区别和联系

• JDK：
  • Java Development Kit
  • Java开发工具
• JRE：
  • Java Runtime Environnement
  • Java 运行时环境
• JVM：
  • Java Virtual Machine
  • Java 虚拟机
    

三、==和equals

• ==
  • 对比的是栈中的值，基本数据类型是变量值，引用类型是堆中内存对象的地址
• equals
  • object中默认也是采用==比较，通常会重写
    
• ==必须是同一个房子，equals房子长得一样就行

四、final

1. 简述 final 作用

• 最终的
  • 修饰类：表示类不可被继承
  • 修饰方法：表示方法不可被子类覆盖（重写），但是可以重载
  • 修饰变量：表示变量一旦被赋值就不可以更改它的值
• 修饰成员变量
  • 如果final修饰的是类变量，只能在静态初始化块中指定初始值或者声明该类遍历时指定初始值
  • 如果final修饰的是成员变量，可以在非静态初始化块、声明该变量或者构造器中执行初始值
• 修饰局部变量
  • 系统不会为局部变量进行初始化，局部变量必须由程序员显示初始化。因此使用final修饰局部变量时，即可以在定义时指定默认值（后面的代码不能对变量再赋值），也可以不指定默认值，而在后面的代码中对final变量赋处置（仅一次）
• 修饰基本类型数据和引用类型数据
  • 如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改
  • 如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。但是引用的值是可变的。

public class FinalReferenceTest {
	public static void main() {
		final int[] iArr = {1, 2, 3, 4};
		iArr[2] = -3;	// 合法
		iArr = null;	// 非法，对iArr不能重新赋值

		final Person p = new Person(25);
		p.setAge(24);	// 合法
		p = null;		// 非法
	}
}

2. 为什么局部内部类和匿名内部类只能访问局部 final 变量?

• 局部内部类和匿名内部类只能访问局部final变量

public class Test {
	public static void main(String[] args) {

	}
	// 局部final变量a,b
	public void test(final int b) {
		final int a = 10;
		// 匿名内部类
		new Thread() {
			public void run() {
				System.out.println(a);
				System.out.println(b);
			};
		}.start();
	}
}

• 编译之后会生成两个class文件，Test.class，Test1.class
• 内部类和外部类是处于同一个级别的，内部类不会因为定义在方法中就会随着方法的执行完毕就被销毁。
• 这里就会产生问题：当外部类的方法结束时，局部变量就会被销毁了，但是内部类对象可能还存在（只有没有人再引用它时，才会死亡）。这里就出现了一个矛盾：内部类对象访问了一个不存在的变量。为了解决这个问题，就将局部变量复制了一份作为内部类的成员变量，这样当局部变量死亡后，内部类仍可以访问它，实际访问的是局部变量的"copy"，这样就好像延长了局部变量的生命周期。
• 将局部变量复制为内部类的成员变量时，必须保证这两个变量是一样的，也就是如果我们在内部类中修改了成员变量，方法中的局部变量也得跟着改变，怎么解决问题呢？
• 就将局部变量设置为final，对它初始化后，我就不让你再去修改这个变量，就保证了内部类的成员变量和方法的局部变量的一致性。这实际上也是一种妥协。使得局部变量与内部类内建立的拷贝保持一致。

五、String、StringBuffer、StringBuilder区别及使用场景

• String是final修饰的，不可变，每次操作都会产生新的String对象
• StringBuffer和StringBuilder都是在原对象上操作
• StringBuffer是线程安全的，StringBuilder是线程不安全的
• StringBuffer方法都是synchronized修饰的
• 性能：StringBuilder > StringBuffer > String
• 场景：经常需要改变字符串内容时使用后面两个
• 优先使用StringBuilder，多线程使用共享变量时使用StringBuffer

六、重载和重写的区别

• 重载：发生在同一个类中，方法名必须相同，参数类型不同、个数不同，顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。
• 重写：发生在子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为private则子类就不能重写该方法。

public int add(int a, String b）
public String add(int a, String b)
// 编译报错

七、接口和抽象类的区别

• 抽象类可以存在普通成员函数，而接口中只能存在 public abstract 方法。
• 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
• 抽象类只能继承一个，接口可以实现多个。
• 接口的设计目的，是对类的行为进行约束（更准备的说是一种“有”约束，因为接口不能规定类不可以有什么行为），也就是提供一种机制，可以强制要求不同的类具有相同的行为。它只约束了行为的有无，但不对如何实现行为进行限制。
• 而抽象类的设计目的，是代码复用。当不同的类具有某些相同的行为（记为行为集合A），且其中一部分行为的实现方式一致时（A的非真子集，记为B），可以让这些类都派生于一个抽象类。在这个抽象类中实现了B，避免让所有的子类来实现B，这就达到了代码复用的目的。而A减B的部分，留给各个子类自己实现。正是因为A-B在这里没有实现，所以抽象类不允许实例化出来（否则当调用到A-B时，无法执行）。
• 抽象类是对类本质的抽象，表达的是 is a 的关系，比如：BMW is a Car。抽象类包含并实现子类的通用特性，将子类存在差异化的特性进行抽象，交由子类去实现。
• 而接口是对行为的抽象，表达的是 like a 的关系。比如：Bird like a Aircraft（像飞行器一样可以飞），但其本质上 is a Bird。接口的核心是定义行为，即实现类可以做什么，至于实现类主体是谁，是如何实现的，接口并不关心。
• 使用场景：当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。
• 抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度。

八、List 和 Set 的区别

• List：有序，按对象进入的顺序保存对象，可重复，允许多个Null元素对象，可以使用Iterator取出所有元素，再逐一遍历，还可以使用get(int index) 获取指定下标的元素
• Set：无序，不可重复，最多允许有一个Null元素对象，取元素时只能用Iterator接口取得所有元素，再逐一遍历各个元素

九、hashCode 与 equals

1. hashCode 介绍

• hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表的索引位置。hashCode()定义在JDK的Object.java中，Java中的任何类都包含由hashCode()函数。散列表存储的是键值对（key-value），它的特点是：能根据“键”快速地检索出对应的“值”。这其中就利用到了散列码（可以快速找到所需要的对象）

2. 为什么要有hashCode

• 以“HashSet如何检查重复”为例子来说明为什么要有hashCode：
  • 对象加入HashSet时，HashSet会先计算对象的hashCode值来判断对象加入的位置，看该位置是否有值，如果没有，HashSet会假设对象没有重复出现。但是如果发现有值，这时会调用equals()方法来检查两个对象是否真的相同。如果两者相同，HashSet就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样就大大减少了equals的次数，相应就大大提高了执行速度。
• 如果两个对象相等，则hashCode一定是相同的
• 两个对象相等，对两个对象分别调用equals方法都返回true
• 两个对象有相同的hashCode值，它们也不一定是相等的
• 因此，equals方法被覆盖过，则hashCode方法也必须被覆盖
• hashCode()的默认行为是对堆上的对象产生独特值，如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

十、ArrayList 和 LinkedList 区别

• ArrayList：基于动态数组，连续内存存储，适合下标访问（随机访问），扩容机制：因为数组长度固定，超出长度存数据时需要新建数组，然后将老数组的数据拷贝到新数组，如果不是尾部插入数据还会涉及到元素的移动（往后复制一份，插入新元素），使用尾插法并指定初始容量可以极大提升性能，甚至超过LinkedList（需要创建大量的node对象）
• LinkedList：基于链表，可以存储在分散的内存中，适合做数据插入及删除操作，不适合查询：需要逐一遍历
• 遍历LinkedList必须使用iterator，不能使用for循环，因为每次for循环体内通过get(i)取得某一元素时都需要对list重新进行遍历，性能消耗极大
• 另外不要试图使用indexOf等返回元素索引，并利用其进行遍历，使用indexOf对list进行了遍历，当结果为空时会遍历整个列表

十一、HashMap 和 HashTable 底层实现是什么？

1. 区别

• HashMap 方法没有 synchronized 修饰，线程非安全，HashTable 线程安全；
• HashMap 允许 key 和 value 为 null，而 HashTable 不允许

2. 底层实现：数组 + 链表实现

• jdk8 开始链表高度到8，数组长度超过64，链表转变为红黑树，元素以内部类Node节点存在
  • 计算 key 的 hash 值，二次 hash 然后对数组长度取模，则直接创建 Node 存入数组
  • 如果没有产生 hash 冲突（下标位置没有元素），则直接创建 Node 存入数组
  • 如果产生 hash 冲突，先进行 equal 比较，相同则取代该元素，不同，则判断链表高度插入链表，链表高度达到8，并且数组长度到64则转变为红黑树，长度低于6则将红黑树转回链表
  • key 为 null，存在下标0的位置

3. 数组扩容

• 和 ArrayList 数组扩容一样
• HashMap 是可以一直往里面放值的，但是不能超过 int 的最大值
• 重新 new 一个数组，把数组的长度变大，基于 HashMap 底层的扩容因子给它一个新的长度，把老的数组数据移到新数组，把新的元素放到新数组的后面

十二、ConcurrentHashMap 原理，jdk7和jdk8版本的区别

1. jdk7

• 数据结构：ReentrantLock + Segment + HashEntry，一个Segment中包含一个HashEntry数组，每个HashEntry是一个链表结构
• 元素查询：二次hash，第一次Hash定位到Segment，第二次Hash定位到元素所在的链表的头部
• 锁：Segment分段锁，Segment继承了ReentrantLock，锁定操作的Segment，其他的Segment不受影响，并发度为segment个数，可以通过构造函数指定，数组扩容不会影响其他的segment
• get方法无需加锁，volatile保证

2. jdk8

• 数据结构：synchronized + CAS + Node + 红黑树，Node的val和next都用volatile修饰，保证可见性
• 查找，替换，赋值操作都使用CAS
• 锁：锁链表的head节点，不影响其他元素的读写，锁粒度更细，效率更高，扩容时，阻塞所有的读写操作、并发扩容
• 读操作无锁：
  • Node的val和next使用volatile修饰，读写线程对该变量互相可见
  • 数组用volatile修饰，保证扩容时被读线程感知

十三、如何实现一个 IOC 容器

1. 配置文件配置包扫描路径

2. 递归包扫描获取 .class 文件

3. 反射、确定需要交给 IOC 管理的类

4. 对需要注入的类进行依赖注入

• 配置文件中指定需要扫描的包路径
• 定义一些注解，分别表示访问控制层、业务服务层、数据持久层、依赖注入注解、获取配置文件注解
• 从配置文件中获取需要扫描的包路径，获取到当前路径下的文件信息，我们将当前路径下所有以 .class 结尾的文件添加到一个 Set 集合中进行存储
• 遍历这个 set 集合，获取在类上有指定注解的类，并将其交给 IOC 容器，定义一个安全的 Map 用来存储这些对象
• 遍历这个 IOC 容器，获取到每一个类的实例，判断里面是否有依赖其他的类的实例，然后进行递归注入

十四、什么是字节码？采用字节码的好处是什么？

1. java 中的编译器和解释器

• java 中引入了虚拟机的概念，即在机器和编译程序之间加入了一层抽象的虚拟的机器。这台虚拟的机器在任何平台上都提供给编译程序一个共同的接口。
• 编译程序只需要面向虚拟机，生成虚拟机能够理解的代码，然后由解释器来将虚拟机代码转换为特定系统的机器码执行。在java中，这种供虚拟机理解的代码叫做字节码（即扩展名为.class的文件），它不面向任何特定的处理器，只面向虚拟机。
• 每一种平台的解释器是不同的，但是实现的虚拟机是相同的。java源程序经过编译器编译后变成字节码，字节码由虚拟机解释执行，虚拟机将每一条要执行的字节码送给解释器，解释器将其翻译成特定机器上的机器码，然后在特定的机器上运行。这也就解释了java的编译和解释并存的特点。
• java源代码 -> 编译器 -> jvm可执行的java字节码（即虚拟指令）-> jvm -> jvm中解释器 -> 机器可执行的二进制机器码 -> 程序运行

2. 采用字节码的好处

• java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以java程序运行时比较高效，而且，由于字节码并不专对一种特定的机器，因此，java程序无需重新编译便可在多种不同的计算机上运行。

十五、Java 类加载器有哪些

• JDK自带有三个类加载器：BootStrapClassLoader、EXTClassLoader、AppClassLoader。
• BootStrapClassLoader 是 EXTClassLoader 的父类加载器，默认负责加载%JAVA_HOME%/lib下的 jar 包和 class 文件。
• EXTClassLoader 是 AppClassLoader 的父类加载器，负责加载%JAVA_HOME%/lib/ext文件夹下的 jar 包和 class 类。
• AppClassLoader 是自定义类加载器的父类，负责加载 classpath 下的类文件。系统类加载器，线程上下文加载器
• 继承 ClassLoader 实现自定义类加载器。

十六、双亲委托模型

• 双亲委派模型的好处：
  • 主要是为了安全性，避免用户自己编写的类动态替换Java的一些核心类，比如 String。
  • 同时也避免了类的重复加载，因为 JVM 中区分不同类，不仅仅是根据类名，相同的 class 文件被不同的 ClassLoader 加载就是不同的两个类。

十七、Java 中的异常体系

• Java 中的所有异常都来自顶级父类 Throwable。
• Throwable 下有两个子类 Exception 和 Error。
• Error 是程序无法处理的错误，一旦出现这个错误，则程序则被迫停止运行。
• Exception 不会导致程序停止，又分为两个部分 RunTimeException 运行时异常和 CheckedException 检查异常。
• RunTimeException 常常发生在程序运行过程中，会导致程序当前线程执行失败。CheckedException 常常发生在程序编译过程中，会导致程序编译不通过。

十八、GC 如何判断对象可以被回收

1. 引用计数法

• 每个对象有一个引用计数属性，新增一个引用时计数加1，引用释放时计数减1，计数为0时可以回收。
• 引用计数法，可能会出现A引用了B，B又引用了A，这时候就算他们都不再使用了，但因为相互引用计数器=1永远无法被回收。

2. 可达性分析法

• 从 GC Roots 开始向下搜索，搜索所走过的路径称为引用链。当一个对象到 GC Roots 没有任何引用链相连时，则证明此对象是不可用的，那么虚拟机就判断是可回收对象。
• GC Roots 的对象有
  • 虚拟机栈（栈帧中的本地变量表）中引用的对象
  • 方法区中类静态属性引用的对象
  • 方法区中常量引用的对象
  • 本地方法栈中JNI（即一般说的Native方法）引用的对象
• 可达性算法中的不可达对象并不是立即死亡的，对象拥有一次自我拯救的机会。对象被系统宣告死亡至少要经历两次标记过程：第一次是经过可达性分析发现没有与 GC Roots 相连接的引用链，第二次是在由虚拟机自动建立的 Finalizer 队列中判断是否需要执行 finalize() 方法。
• 当对象变成（GC Roots）不可达时，GC 会判断该对象是否覆盖了 finalize 方法，若未覆盖，则直接将其回收。否则，若对象未执行过 finalize 方法，将其放入 F-Queue 队列，由一低优先级线程执行该队列中对象的 finalize 方法。执行 finalize 方法完毕后，GC 会再次判断该对象是否可达，若不可达，则进行回收，否则，对象“复活”
• 每个对象只能触发一个 finalize() 方法
• 由于 finalize() 方法运行代价高昂，不确定性大，无法保证各个对象的调用顺序，不推荐大家使用，建议遗忘它。