Java后端面试

抽象

封装

继承

多态

单一职责原则

开放封闭原则

里氏替换原则

依赖倒置原则

接口分离原则

都包含抽象方法，且都不能被实例化

抽象类是对类的抽象，接口是对行为的抽象

抽象类由子类extends继承，接口由实现类implements实现

一个类只能继承一个抽象类，可以实现多个接口

抽象类的方法可以用任意访问修饰符，接口方法默认public，并且不允许定义为private或protected

Java在执行子类的构造方法时，默认会调用父类中“没有参数的构造方法”。因此如果父类只定义了有参数的构造方法且在子类的构造方法里没有用super指定调用，则编译时会发生错误。

内部类的分类有哪些

内部类的优点

重载：发生在同一个类中，方法名相同参数列表不同（参数类型或个数不同）

重写：发生在父子类中，方法名、参数列表全部相同

基本数据类型比较时，两者作用一样，都是比较其值是否相同

引用数据类型比较时，==比较的是其在栈内存的引用地址是否相同，equals比较的是其在堆内存的具体数值是否相同

hashCode介绍

为什么要有hashCode

为什么重写equals时必须重写hashCode方法

private：仅同一个类可访问

默认(不写): 同一个包内可访问

protected：同一个包或所有子类可访问

public：所有类可访问

用户修饰类、方法和变量

被修饰的类不可以被继承

被修饰的方法不可以被重写

被修饰的变量不可以被改变（不可变的是变量的引用，即栈内存地址）

final用于修饰类、方法和变量。修饰的类不可继承，修饰的方法不可重写，修饰的变量不可重新赋值

finally一般在处理异常时出现在try-catch代码块中，finally表示不管是否出现异常，该代码块的内容都会执行，一般用于关闭资源。

finalize是一个方法，由垃圾回收器调用。当我们调用System.gc()方法时，垃圾回收器会调用finalize()回收垃圾

super引用当前对象的直接父类中的成员

this引用当前对象的成员

作用

应用场景

注意事项

break结束当前循环体

continue结束正在执行的循环，进入下一个循环条件

return结束当前方法直接返回

按照流的流向分

按照操作单元划分

按照流的角色分

IO流的主要基类

BIO

NIO

AIO

exists

createFile

createDirectory

delete

copy

move

read

write

在运行状态下，对于任意一个类，都能知道其所有属性和方法；对于任意一个对象，都能调用其任意属性和方法。

优点：运行时可以动态 操作类，提高代码灵活性

缺点：反射相当于一些列的解释操作，性能比直接的java代码要慢很多

动态代理模式

Spring/Mybatis/Hibernate框架大量使用发射机制，通过配置/注解操作类

1. 通过new对象实现反射机制: obj.getClass()

2. 通过路径实现反射机制: Class.forName("com.reflect.Student")

3. 通过类名实现反射机制:  Student.class

字符串常量池专门存储字符串，可以提高内存的使用率，避免开辟多块空间存储相同的字符串

不是

对象不可变

常量池优化

类不可被继承

HashMap内部实现是通过key的hashCode值来确定value的存储位置，而字符串是不可变的，所以创建字符串时，它的hashCode被缓存下来不需要重新计算，所以相比于其他对象更快。

String不可变

StringBuilder可变，非线程安全

StringBuffer可变，线程安全

装箱：将基本类型用对应的引用类型包装起来

拆箱：将包装类转换成基本数据类型

Integer是int的包装类

常量池中存储-128~127的整型，因此在此范围内装箱的等值Integer对象==返回true

Error

Exception

NullPointException空指针异常

ClassCastException类转换异常

IndexOutOfBoundsException数组越界

IOException

FileNotFoundException

ClassNotFoundException

不要for循环内try-catch

通过if语句避免NPE

不要使用异常控制流程

Collection

Map

一种错误检查机制，当遍历集合时集合的结构发生变化，则会抛出CocurrentModificationException异常终止遍历

原因：迭代器在遍历过程中使用一个modCount变量，每次遍历前都会检查modCount的值，如果是期望值则继续遍历，否则终止遍历

解决方法：使用CopyOnWriteArrayList代替ArrayList

Collections.unmodifiableCollection，改变集合时会报错

使用迭代器的remove()

List：有序，可重复，允许多null元素，检索效率高，插入删除效率低

Set：无序，不可重复，只允许一个null元素，检索效率低，插入删除效率高

数组转List

List转数组

ArrayList：底层数据结构是数组，查询快插入慢

LinkedList：底层数据结构是链表，插入快查询慢

Vector：和ArrayList相似，区别是Vector线程安全而ArrayList线程不安全

Collections.synchronizedList将其转成线程安全的容器再使用

基于HashMap实现，HashSet的值存放在HashMap的key上，value统一为present，因此HashSet的操作底层都是调用HashMap的相关方法来完成。

add方法底层调用HashMap的put方法，先比较对象的hashCode值，如果相同在结合equals方法比较，都相同是用新的V覆盖旧的V而key不变。

HashSet：无序不可重复

LinkedSet：继承自HashSet，多维护一个字段记录插入顺序实现有序

TreeSet：有序的二叉树结构，检索的时间复杂度为O(logN)

数据结构：HashMap是由数组+链表/红黑树组成，数组是HashMap的主题，链表则是主要味蕾解决哈希冲突而存在的，1.8之后引入红黑树结构，在链表大于8的时候转化成红黑树以减少搜索时间 O(N) --> O(logN)。

集合操作基于Hash算法实现

1. 根据key计算hash值得到插入的数组索引

2. 如果数组索引位置的值为null，直接新建节点添加；如果有值，遍历检查key的值是否存在，已存在则覆盖原始值，不存在则执行链表插入或红黑树插入

3. 插入成功后，判断实际存在的键值对数量是否超过了最大容量threshold，如果超过执行扩容操作。

1. 每次扩容，都是原始容量的2倍

2. 根据元素的hash值重新分发位置

拉链法

引入红黑树，链表长度大于8时转成红黑树，避免链表过长而影响查询效率

优化resize扩容算法

最好使用String、Integer这样的包装类作为key，因为其不可变，不可变的类可以确保hashCode和equals在未来不会改变，这样不会存在获取hash值不同的问题。其次不可变的对象hashCode值可以被缓存起来（JVM常量池具有缓存功能），拥有更好的性能。

1. 重写hashCode因为需要计算数据的存储位置。注意不要试图在计算中排除掉对象的某些字段来提高性能，这样虽快但是会导致更多的哈希碰撞

2. 重写equals方法，需要遵守自反性、对称性、传递性、一致性以及equals(null)必须返回false的几个原则，目的是为了保证key的唯一性。

3. hashCode/equals不可被再次改变

hashCode返回的是int整型，范围很大，而HashMap的容量范围很小（16~2^30），一般取不到int的最大值。

HashMap底层数据结构是数据+链表，put时节点位置下标是根据key的hash值计算的，所以遍历时的顺序和插入顺序是不一样的。

LinkedHashMap继承自HashMap，但是它会记录节点插入的顺序，使得遍历顺序和插入顺序是一样的

TreeMap是将节点按照其key值的顺序插入的。

ConcurrentHashMap分段锁实现线程安全，相比于HashTable的synchronized锁粒度更加精细，并发性能更好

1.7：将数据分成一段一段的，每一段数据分配一个Segment锁，数据修改时需要首先获取对应的Segment锁。当一个线程占有其中一段数据时，其他段的数据仍可被其他线程访问

1.8：放弃Segment的设计，采用Node+CAS+Synchronized保证并发，synchronized只锁定当前链表或红黑树的首节点，这样只要hash不冲突，就不会产生并发，效率更高。

TreeSet要求存放的对象所属类必须实现Comparable接口，该接口提供比较元素的compareTo方法，当插入元素时会回调该方法比较元素的大小。

TreeMap要求存放的键值必须实现Comparable接口，从而可以根据键值进行排序

Collection是集合类的顶级接口

Collections是集合类的工具类，提供一系列的静态方法，常用的如sort()

Comparable出自java.lang包，有一个compareTo(Object obj)的方法用于排序

Comparator出自java.util包，有compare(Object obj1, Object obj2)方法用于排序

Collections的sort方法提供了两种重载的方式

Collections.sort(list)：一种要求待排序容器中传入的对象需要实现Comparable接口

Collections.sort(list, comparator)：另一种除了传入待排序容器外，需要额外传入比较器Comparator的实现类

原子性：一个或多个操作要么全部执行成功要么全部执行失败

可见性：一个线程对共享变量的修改，另一个线程立即可见

有序性：程序按照代码的先后顺序执行

线程切换带来的原子性问题：线程间使用同步锁（synchronized或者lock）

缓存导致的可见性问题：volatile解决可见性问题

编译优化带来的有序性问题：Happens-Before规则可以解决有序性问题

用户(User)线程：主线程，运行在前台执行具体的任务

守护(Dawmon)线程：运行在后台，为主线程服务，一旦所有用户线程结束运行守护线程会随之结束工作

线程1拥有锁A尝试获取锁B，而线程2拥有锁B尝试获取锁A

如何避免死锁？

新建状态

就绪状态

运行状态

阻塞状态

终止状态

继承Thread类

实现Runnable接口

实现Callable接口

使用匿名内部类

都是线程的接口，通过thread.start()启动线程

Runnable中run()方法无返回值；Callable中call()有返回值，和Future、FutureTask配合可以用来获取异步执行的结果

Runnable的run方法只能抛出运行时异常且无法捕获处理；Callable的call允许抛出异常，可以获取异常信息

Callable支持返回执行结果，需要调用Future.get()得到，此方法会阻塞主进程继续执行，如果不调用不会阻塞

start用于启动线程使线程进入就绪状态，run是线程的一个普通方法调用，用于执行线程运行时的代码

两者都可以暂停线程的执行

调用类不同：sleep是Thread的静态方法，wait是Object类的方法

是否释放锁：sleep()不释放锁，wait释放锁

用途不同：sleep通常用于暂停执行，wait通常用于线程间的交互/通信

用法不同：wait方法调用后，线程不会自动苏醒，需要其他线程调用同一个对象上的notify或notifyAll方法；sleep执行完成后，线程自动苏醒

因为Java所有的类都继承Object，java想让任何对象都可以成为锁，而在java的线程中没有可供所有对象使用的锁，所有任意对象都可以调用的方法需要定义在Object类中

执行sleep线程进入阻塞状态，执行yield线程进入就绪状态

sleep方法申明抛出InterruptedException，yield方法没有申明异常

sleep方法比yield方法具有更好的移植性

sleep方法给其他线程运行机会时不考虑线程的优先级；yield方法只会给相同优先级或更高优先级的线程运行机会

这两个方法只在当前正在运行的线程上运行，所以在其他处于等待线程上调用你这个方法没有意义

1. run方法完成时线程终止

2. stop方法强行终止，不推荐，stop/suspend/resume已经是过期的方法

3. interrupt方法中断线程

1. 使用安全类，比如java.util.concurrent下的类，原子类AtomicInteger

2. 使用自动锁 synchronized

3. 使用手动锁 Lock

线程类的构造方法、静态块是被new这个线程对象所在的线程调用，而run方法是被线程本身调用

共享内存模型（Java内存模型JMM）

什么是重排序？

重排序遵守的规则 as-if-serial

重排序实际执行的指令步骤

自旋：很多synchronized里的代码执行时间非常快，此时等待的线程加锁可能不太值得，可以让等待锁的线程不被阻塞，而是在synchronized的边界做忙循环，也就是自旋。如果做了多次仍未获得锁，在进入阻塞。

忙循环：不放弃CPU运行空循环

synchronized的底层实现原理

synchronized可重入的原理

synchronized三种使用方式

synchronized锁升级的原理是什么

volatile修饰变量

synchronized修饰修改变量的方法

synchronized是悲观锁，属于抢占式，会引起其他线程阻塞

volatile

CAS

volatile + CAS可实现原子性操作，可以参见AtomicInteger

提供更具扩展性的锁操作，更灵活。

整体上说Lock是synchronized的扩展版，更灵活，支持公平锁和非公平锁（默认），synchronized只支持非公平锁。但大部分情况下，非公平锁是高效的选择。

悲观锁：每次拿数据的时候都认为别人会修改，所以每次都会上锁，这样别人想拿这个数据就会阻塞。

乐观锁：每次拿数据时都认为别人不会修改，所以不上锁。但是在更新时会判断是否有其他人也在更新，可以使用版本号等机制判断。

降低资源消耗：重用存在的线程，减少对象创建销毁的开销

提高响应速度：当任务到达时，不需要等线程创建就立即执行

提高线程可管理性：线程池统一分配、优化和监控线程

附件功能：提供定时执行、定期执行、单线程、并发数控制的功能

0. 提交任务到线程池

1. 判断线程池里的核心线程是否都在执行任务，如果不是则创建新的工作线程执行任务，如果都在执行任务，进入下一步

2. 判断工作队列是否已满，如果没满则将提交的任务存入工作队列，如果已满，进入下一步

3. 判断线程池里的线程是否都处于工作状态，如果没有则创建一个新的工作线程执行任务，如果满了，更具饱和策略处理这个任务

根据实际情况来定，简单来说根据任务的CPU密集和IO密集分配

总的来说：

Executors是实现线程池功能的工厂类，提供newCachedThreadPool、newFixedThreadPool、newScheduledThreadPool、newSingleThreadExecutor等方法构建适用于不同场景的线程池。

线程池的四种创建方式

Executors工具类，提供功能创建不同类型的线程池

Executor接口对象执行线程任务，ExecutorService接口继承Executor接口并进行扩展提供更多的方法，能获取任务执行的状态并可以获取任务的返回值

使用ThreadPoolExecutor可以创建自定义线程池

RUNNING

SHUTDOWN

STOP

TIDYING

TERMINATED

相同点：都可以开启线程执行池中的任务 

不同点：

如果当前同时运行的线程数量达到最大线程数并且队列也放满了任务时，ThreadPoolExecutor定义了一些策略

1. ThreadPoolExecutor.AbortPolicy：抛出RejectedExecutionException来拒绝新任务的处理

2. ThreadPoolExecutor.CallerRunsPolicy：调用执行自己的线程运行任务

3. ThreadPoolExecutor.DiscardPolocy：不处理新任务，直接丢弃

4. ThreadPoolExecutor.DiscardOldestPolicy：将最早的未处理任务丢弃

new ThreeadPoolExecutor()

构造参数

子系统Class Loader 类加载

子系统Execution Engine 执行引擎

运行时数据区

本地接口

1. 编译器将Java代码转换成字节码

2. 由类加载器把字节码加载到内存中

3. 而字节码知识JVM的指令集规范，不能被底层系统执行。需要执行引擎将其翻译成底层系统指令，交由CPU去执行

4. CPU执行过程中有可能需要调用其他语言的本地库接口来实现整个程序的功能

线程共享的内存：数据区

线程独享的内存：指令区

只是增加一个指针，指向你存在的内存地址。

不仅增加一个指针，而且申请一个新的内存。使这个增加的指针指向这个新的内存。

内存泄漏是指不再使用的对象或者变量一直占据着内存空间

java也会出现，如长声明周期的对象持有短生命周期对象的引用时

在JVM中，有一个垃圾回收线程，它是低优先级的，在正常情况下是不会执行，只有在虚拟机空闲或者当前堆内存不足时才会触发执行，扫描那些没有被任何引用的对象，并将内存回收。

垃圾回收器从GC Root开始向下搜索，搜索的路径称之为引用链，当一个对象到GC Roots没有任何引用链路径时，则这个对象是可以被回收的。

GC Roots的引用一般有哪些？

引用计数法为什么会被淘汰？

执行System.gc()

标记-清除算法

标记-整理算法

复制算法

新生代

老年代

永久代

新生代和老年代的默认比例

Minor GC

Major GC

Full GC

回收新生代的垃圾回收器

回收老年代的垃圾回收器

G1(Garbage First)

垃圾回收器可以应用的组合有哪些

分代回收器有两个分区：新生代和老年代，其默认比例为1:2

新生代有三个分区：Eden、From Survior、To Survior，默认比例8:1:1，在新生代发生的回收机制机制使用复制算法。

新生代的回收流程如下：新对象创建之初会放置在Eden区，当Eden区空间不足时触发Minor GC，使用复制算法将活动的对象复制到From Survior区，如果触发Minor GC时 From Survior区空间也不足时，同样使用复制算法先将From Survior的活动对象复制到To Survior区，再清空From Survior区并将From Survior区和To Survior区的角色对换。每次从From Survior区复制到To Survior区的对象年龄会加一，当年龄达到15（JVM默认值）时，会晋升到老年代中。另外新创建的大对象也会直接进入到老年代。

老年代的空间占比达到一定比例时会触发Major GC，根据回收器的不同使用标记清除或标记整理算法执行回收

在JVM启动之初，收集器将整个堆内存分成大小相同的2000个区，区块的大小范围（1MB~32MB），因此老年代和新生代不再是物理连续的区域了

当一个分区空间不足时，触发Minor GC，执行复制算法将活动的对象移到另一个分区

当所有分区空间达到一定比例时触发Full GC，分为四个阶段

G1的优缺点

类型：CMS分代回收器，G1分区回收器

回收范围：CMS针对老年代，G1针对整个堆内存

回收过程：CMS在初始标记阶段和重新标记阶段都有程序停顿，G1的很多MajorGC回收阶段和MinorGC一同发生，只有在重新标记阶段有短暂程序停顿

详细的加载过程：类加载器读取class文件，将类信息、常量、静态变量存储在方法区中，并在堆中生成一个代表该类的java.lang.Class对象，封装了类在方法区的数据结构并向用户提供访问该数据结构的接口，即反射的接口

java中类的加载并不是一次性将所有的类加载，而是保证程序运行的基础类加载到jvm中，至于其他类，只有在需要时才会被加载，节省内存开支

启动类加载器

扩展类加载器

系统类加载器：根据类路径加载类。一般来说，java的类都是有它来完成加载的，可以通过ClassLoader.getSystemClassLoader()获取它

自定义类加载器

当一个类加载器收到了类加载的请求的时候，他不会直接去加载指定的类，而是把这个请求委托给自己的父加载器去加载。只有父加载器无法加载这个类的时候，才会由当前这个加载器来负责类的加载。

作用：避免类的重复加载

IDEA等编辑器的工具里设置

如果是jar包的话，通过命令java -jar 加上相应参数

如果是war包的话，可以在tomcat设置

jconsole：监控jvm中的内存、线程和类

jvisualvm：全能分析工具，可以分析内存快照、线程快照、程序死锁、监控内存的变化、gc变化等。

-Xms：初始堆的大小

-Xmx：最大堆的大小

-Xmn：堆中新生代大小

-XX:NewSize=n ：新生代初始大小

-XX:MaxNewSize=n：新生代最大值

-XX:NewRatio=n：老年代和新生代的比值，默认为2

-XX:SurviorRatio=n：新生代中Eden与Survior的比值，默认为8

-XSS：每个线程的堆栈大小。1.5后每个线程为1M

-XX:PermSize=n：永久代初始值

-XX:MaxPermSize=n：永久代最大值

-XX:+Use**GC：指定垃圾回收器，1.9之后默认G1

-XX:MaxTenuringThreshold=n：新生代晋升老年代的年龄，默认15

-XX:LargePageSizeInBytes=n：堆内存的内存页大小

-XX:+UseFastAccessorMethods：优化原始类型的getter方法性能

-XX:+DisableExplicitGC：禁止System.gc()，默认启用

一种动态编译器，全名Just In Time Compiler即时编译器。

随着程序运行的时间推移，一些运行频率高的代码（热点代码）会被JIT编译成本地机器指令，再进行一些优化后保存起来，下次执行时可以无需再翻译，提高代码执行效率。

singleton：bean在每个容器中只有一个实例

prototype：bean在每个容器中可以有多个实例

request：每次http请求都会创建一个bean

session：在一个http session中，一个bean对应一个实例

global-session：在一个全局的http session中，一个bean对应一个实例

Spring中bean默认的作用域是singleton。使用prototype需要慎重的考虑，因为频繁的创建和销毁bean会影响性能。

根据配置文件/注解将bean的类名放入容器中

需要使用该bean时，根据类名实例化对象，如果有依赖关系，通过递归调用实例化其属性完成注入

bean实例化之后会一直留在应用上下文中，直至上下文被销毁

当启动Spring IOC时，容器会自动装载一个AutowiredAnnotationBeanPostProcessor后置处理器。当容器扫描到@Autowired、@Resource或@Inject时，就会自动查找需要的bean，并装配给该对象的属性。

使用@Autowired时，首先在容器中查询对应类的bean，如果刚好查到一个直接装配给@Autowired指定的数据。如果查到的结果不止一个，就根据@Autowired的名称查找，如果为空则抛出异常，解决方法是使用required=false

@Component：Spring管理组件的通用构造型

@Controller：将此类标记为Web MVC的控制器

@Service：@Component的特化，无额外功能，指定具体的组件意图

@Repository：@Component的特化，是针对DAO的组件，可以使未经检查的异常转换成Spring DataAccessException

表明bean的该属性必须在配置时设置

都可用于构造函数、成员变量、setter方法

@Autowired默认按照类型装配，默认要求依赖对象必须存在（也可以设置required属性为false改变此默认行为）

@Resource默认按照name来装配，name不存在时才会按照类型来装配

当创建了多个相同类型的bean并希望使用属性装配其中一个bean时，可以使用@Qualifier来指定

事务传播行为指的是，当多个事务同时存在时，Spring如何处理这些事务的行为。

PROPAGATION_REQUIRED：如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务。是最常见的设置

PROPAGATION_SUPPORTS：如果当前没有事务，就以非事务执行，如果当前存在事务，就加入该事务

PROPAGATION_MANDATORY：如果当前没有事务，就抛出异常，如果当前存在事务，就加入该事务

PROPAGATION_REQUIRES_NEW：无论当前存不存在事务，都创建新事务

PROPAGATION_NOT_SUPPORTED：以非事务方式执行，如果当前存在事务，就把当前事务挂起

PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则判处异常

PROPAGATION_NESTED：如果当前没有事务，就创建一个新事务，如果当前存在事务，则嵌套事务执行

ISOLATION_DEFAULT：用底层数据库设置的隔离级别，Spring默认值

ISOLATION_READ_UNCOMMITTED：未提交读，最低隔离级别，事务未提交前就可以被其他事务读取（会出现脏读、不可重复读、幻读）

ISOLATION_READ_COMMITTED：提交读，一个事务提交后才能被其他事务读取到（会造成不可重复读、幻读）SQL Server默认级别

ISOLATION_REPEATABLE_READ：可重复读，保证多次读取同一个数据时，其值都和事务开始时内容是一致的，禁止读取别的事务未提交的数据（会造成幻读），MySQL默认级别

ISOLATION_SERIALIZABLE：序列化，代价最好最可靠的隔离级别，该级别能防止脏读、不可重复读、幻读。

数据不一致的问题

切面（Aspect）

连接点（Join Point）

通知（Advice）

切点（Pointcut）

引入（Introduction）

目标对象（Target Object）

织入（Weaving）

前置通知（Before）

后置通知（After)

返回通知（After-returning）

异常通知（After-throwing）

环绕通知（Around）