面试题总结

由于最近面试的需要，自己总结的面试题，不喜勿喷，仅供参考！！！！

1. 面向对象程序设计语言的特性是封装、继承、多态，请简要阐述一下多态
2. 集合有list、set、map，请介绍一下这三者

一、List(元素可重复性，有序性)
1.ArrayList底层是一个数组，输出时需要foreach遍历，查询快，增删慢，线层不安全,效率高
2.Vector底层是一个实现自动增长的对象数组，元素会自动添加到数组中，查询快，增删慢，线层安全，效率低
3.LinkedList底层是一个链表，查询慢，增删快，线层不安全。
二、效率高Set（具有唯一性，无序性)
1.HashSet:无序，随机输出。底层数据结构是哈希表，依赖hashCode()和equals()两个方法来保证唯一性。
2.LinkedHashSet:FIFO插入有序，先进先出。底层结构是链表和哈希表，由链表保证元素有序，哈希表保证元素唯一。
3.TreeSet：有序，唯一。底层结构是红黑树，排序采用自然排序和比较容器排序，根据比较的返回值是否为0来判断元素唯一。
三、Map（采用键值对<key,value>存储元素，key键唯一）
1.hashmap:底层结构是数组+链表(jdk1.7之前)，无序，线程不安全，效率高，允许有null（key和value都允许），父类是AbstractMap
2.treemap:底层结构是红黑树，有序，将数据按照key排序，默认是升序排序。
3.hashtable：底层结构是哈希表，无序，线程安全，效率低，不允许有null值，父类是Dictionary

https://blog.csdn.net/weixin_46014132/article/details/122175272

3. springboot和mvc的区别

Spring Boot和Spring MVC之间主要有以下区别：

目的不同：Spring Boot是一个用于快速构建现代应用程序的框架，它通过提供依赖管理、自动配置和其他高级功能来简化Spring的开发。而Spring MVC则是Spring框架的一个核心模块，它提供了一系列Web开发相关的组件，例如控制器和视图解析器等，以便于开发Web应用程序。

使用范围不同：Spring Boot可以用于创建任何类型的应用程序，从简单的命令行工具到Web应用程序和RESTful API，而Spring MVC则更适合于Web应用程序的开发。

基础设施不同：Spring Boot提供了充分的自动配置，可以使开发人员更快速地创建应用程序，而Spring MVC需要开发人员配置框架和容器。

控制反转方式不同：Spring Boot通过使用基于注解的方式来实现控制反转（IoC），而Spring MVC则使用XML或注解的方式实现。

总之，Spring Boot和Spring MVC在目的、使用场景、基础设施和控制反转方法等方面都存在差异。Spring Boot是一个用于快速构建现代应用程序的框架，而Spring MVC是一种Web应用程序开发框架。不过，Spring Boot的自动配置和依赖管理功能也可以用于简化Spring MVC的开发。

4. springbean的生命周期

Spring 中 Bean 的生命周期较复杂，可以表示为：Bean 的定义 -> Bean 的初始化 -> Bean 的使用 -> Bean 的销毁。

https://baijiahao.baidu.com/s?id=1740311397377998055&wfr=spider&for=pc

5. 都做过哪些SQL优化

1.避免使用select *
在实际业务场景中，可能我们真正需要使用的只有其中一两列。查了很多数据，但是不用，白白浪费了数据库资源，比如：内存或者cpu。

此外，多查出来的数据，通过网络IO传输的过程中，也会增加数据传输的时间。

还有一个最重要的问题是：select *不会走覆盖索引，会出现大量的回表操作，而从导致查询sql的性能很低。

=================================================================================================

2.用union all代替union
我们都知道sql语句使用union关键字后，可以获取排重后的数据。

而如果使用union all关键字，可以获取所有数据，包含重复的数据。

(select * from user where id=1) 
union 
(select * from user where id=2);

排重的过程需要遍历、排序和比较，它更耗时，更消耗cpu资源。

所以如果能用union all的时候，尽量不用union。

除非是有些特殊的场景，比如union all之后，结果集中出现了重复数据，而业务场景中是不允许产生重复数据的，这时可以使用unio

====================================================================================================

4.批量操作
如果你有一批数据经过业务处理之后，需要插入数据，该怎么办？

反例：

for(Order order: list){
   orderMapper.insert(order):
}

在循环中逐条插入数据。

insert into order(id,code,user_id) 
values(123,'001',100);

该操作需要多次请求数据库，才能完成这批数据的插入。

但众所周知，我们在代码中，每次远程请求数据库，是会消耗一定性能的。而如果我们的代码需要请求多次数据库，才能完成本次业务功能，势必会消耗更多的性能。

那么如何优化呢？

正例：

orderMapper.insertBatch(list)；

提供一个批量插入数据的方法。

insert into order(id,code,user_id) 
values(123,'001',100),(124,'002',100),(125,'003',101);

这样只需要远程请求一次数据库，sql性能会得到提升，数据量越多，提升越大。

但需要注意的是，不建议一次批量操作太多的数据，如果数据太多数据库响应也会很慢。批量操作需要把握一个度，建议每批数据尽量控制在500以内。如果数据多于500，则分多批次处理。

https://blog.csdn.net/weixin_43431218/article/details/129429287

6. redis的原理，怎么用的，如何把redis放到缓存中

点击查看代码

深入理解Redis缓存的原理及应用步骤

Redis是一款非关系型的高性能key-value数据库，被广泛应用于缓存、计数器、消息队列等领域。本文将深入探讨Redis缓存的原理及应用步骤。

一、Redis缓存工作原理

Redis缓存工作原理主要分为以下几个部分：

1. Redis内存数据存储方式

Redis是一种基于内存的数据存储系统，其通过将数据存储在内存中来加快数据访问速度。同时，为了防止数据丢失，Redis还提供了持久化存储机制，通过将内存数据写入磁盘中来保证数据的安全性。

2. Redis数据结构支持

Redis支持多种数据类型，包括字符串、哈希表、列表、集合、有序集合等。每种数据类型都有自己的操作命令，可以满足不同场景的数据处理需求。

3. Redis数据的过期策略

Redis采用了惰性删除和定时删除两种策略来处理过期数据。惰性删除是指在Redis客户端发起数据访问请求时，Redis会检查数据是否过期，如果过期则进行删除操作。定时删除则是Redis会定期检查所有的数据是否过期，并进行删除操作。

4. Redis缓存清理策略

Redis通过LRU（Least Recently Used，最近最少使用）算法来进行缓存清理。当缓存空间不足时，Redis会将最长时间没有访问过的数据从缓存中清除，以保证缓存空间的有效利用。

https://www.dbs724.com/321289.html

7. rabbitmq

点击查看代码

MQ 全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于系统之间的异步通信。

消息，两台计算机间传送的数据单位。可以非常简单，也可以更复杂。

队列，数据结构中概念。在队列中，数据先进先出，后进后出。

1. MQ优缺点
优点：

应用解耦
生产者（客户端）发送消息到消息队列中去，接受者（服务端）处理消息，需要消费的系统直接去消息队列取消息进行消费即可，而不需要和其他系统有耦合，这显然也提高了系统的扩展性。

异步提速
将用户的请求数据存储到消息队列之后就立即返回结果。随后，系统再对消息进行消费。

削峰限流
先将短时间内高并发产生的事务消息存储在消息队列中，然后后端服务再慢慢根据自己的能力去消费这些消息，这样就避免直接把后端服务打垮掉。

缺点：

系统可用性降低

系统引入的外部依赖越多，系统稳定性越差。一旦 MQ 宕机，就会对业务造成影响。

系统复杂度提高

MQ 的加入大大增加了系统的复杂度，以前系统间是同步的远程调用，现在是通过 MQ 进行异步调用。

一致性问题

A 系统处理完业务，通过 MQ 给 B、C、D 三个系统发消息数据，如果 B 系统、C 系统处理成功，D 系统处理失败，则会造成数据处理的不一致。

http://wed.xjx100.cn/news/165090.html?action=onClick

8. springboot一些常用注解，每个注解的底层原理

启动注解 @SpringBootApplication
@SpringBootConfiguration 注解，继承@Configuration注解，主要用于加载配置文件
@EnableAutoConfiguration 注解，开启自动配置功能
@Controller 控制器，处理http请求。
@RestController 前后端分离注解
@RequestBody 通过HttpMessageConverter读取Request Body并反序列化为Object（泛指）对象

@RequestMapping 是 Spring Web 应用程序中最常被用到的注解之一。这个注解会将 HTTP 请求映射到 MVC 和 REST 控制器的处理方法上

@GetMapping用于将HTTP get请求映射到特定处理程序的方法注解
注解简写：@RequestMapping(value = “/say”,method = RequestMethod.GET)等价于：@GetMapping(value = “/say”)

@PostMapping用于将HTTP post请求映射到特定处理程序的方法注解
@PathVariable:获取url中的数据
@PathVariable:获取url中的数据
@Repository DAO层注解，DAO层中接口继承JpaRepository,需要在build.gradle中引入相关jpa的一个jar自动加载。
@Service
@Service是@Component注解的一个特例，作用在类上
@Service注解作用域默认为单例
使用注解配置和类路径扫描时，被@Service注解标注的类会被Spring扫描并注册为Bean
@Service用于标注服务层组件,表示定义一个bean，使用时没有传参数，Bean名称默认为当前类的类名，首字母小写
@Service(“serviceBeanId”)或@Service(value=”serviceBeanId”)使用时传参数，使用value作为Bean名
@Entity实体类注解
@Table(name =“数据库表名”)，这个注解也注释在实体类上，对应数据库中相应的表。
@Id、@Column注解用于标注实体类中的字段，pk字段标注为@Id，其余@Column。
@Bean产生一个bean的方法，明确地指示了一种方法，产生一个bean的方法，并且交给Spring容器管理。支持别名@Bean(“xx-name”)
@Autowired 自动导入  注解作用在构造函数、方法、方法参数、类字段以及注解上  注解可以实现Bean的自动注入
@Component 把普通pojo实例化到spring容器中，相当于配置文件中的
@PropertySource注解
@ImportResource导入xml配置文件
@Import 导入额外的配置信息
六、事务注解 @Transactional
@ControllerAdvice 统一处理异常
@ControllerAdvice 注解定义全局异常处理类‘

https://blog.csdn.net/haohaoxuexiyai/article/details/116695978

9. hashtable和hashmap的区别

1、继承的父类不同
Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。但二者都实现了Map接口。

2、线程安全性不同
javadoc中关于hashmap的一段描述如下：此实现不是同步的。如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。

Hashtable 中的方法是Synchronize的，而HashMap中的方法在缺省情况下是非Synchronize的。在多线程并发的环境下，可以直接使用Hashtable，不需要自己为它的方法实现同步，但使用HashMap时就必须要自己增加同步处理。（结构上的修改是指添加或删除一个或多个映射关系的任何操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射进行意外的非同步访问，如下所示

https://blog.csdn.net/u011441473/article/details/122536939

10. Oracle

oracle是一个关系型数据库，它有一个大的数据库，大的数据库下由一个或多个实例组成，每个实例由后台进程和逻辑数据组成，一个实例下可以创建多个表空间和多个用户，每个用户都有一个默认表空间，每个表空间都可以成为某个用户的默认表空间，同一个表空间下用户的数据不会互相干扰，他们的数据存在隔离。表空间由逻辑数据结构和物理文件组成，物理文件负责存储数据，逻辑数据结构负责操作数据。要删除物理文件需要先删除表空间。逻辑数据内含有表结构。表的具体定位是：用户名.表名。在oracle中表是隶属于用户之下的

https://blog.csdn.net/weixin_50799927/article/details/122941564

11. 谈谈你对集合的理解

集合分为两大类：

Conllection集合(单例集合)
List集合 (里面的元素可以重复)
ArrayList集合 ：底层是数组存储，特点是查询快，增删慢
LinkedList集合 ：底层是链表存储，特点是增删快，查询慢
Set集合 (里面的元素不可重复)
HashSet:
LinkedHashSet
TreeSet
Map集合　(双列集合)
HashMap集合
LinkedHashMap集合
TreeMap集合
HashTable集合

https://blog.csdn.net/weixin_46002359/article/details/125211166

12. 说说MySQL常用函数，除了sum这些

LENGTH	计算字符串长度函数，返回字符串的字节长度
CONCAT	合并字符串函数，返回结果为连接参数产生的字符串，参数可以使一个或多个
INSERT	替换字符串函数
LOWER	将字符串中的字母转换为小写
UPPER	将字符串中的字母转换为大写
LEFT	从左侧字截取符串，返回字符串左边的若干个字符
RIGHT	从右侧字截取符串，返回字符串右边的若干个字符
TRIM	删除字符串左右两侧的空格
REPLACE	字符串替换函数，返回替换后的新字符串
SUBSTRING	截取字符串，返回从指定位置开始的指定长度的字符换
REVERSE	字符串反转（逆序）函数，返回与原始字符串顺序相反的字符串

https://c.biancheng.net/mysql/function/

13. mysql如果让你对当前时间加一年具体怎么操作

SELECT DATE_ADD(NOW(), INTERVAL 1 YEAR);

14. 线程池分几种，怎么实现的

 1、FixedThreadPool
这个线程池的核心线程数和最大线程数是一样的,所以可以看作是固定线程数的线程池

特点是当线程达到核心线程数后,如果任务队列满了,也不会创建额外的非核心线程去执行任务,而是执行拒绝策略.

2、CachedThreadPool
这个线程池叫做缓存线程池,

特点是线程数几乎是可以无限增加的(最大值是Integer.MAX_VALUE,基本不会达到),当线程闲置时还可以进行回收,而且它采用的存储任务的队列是SynchronousQueue队列,队列容量是0,实际不存储任务,只负责对任务的中转和传递,所以来一个任务线程池就看是否有空闲的线程,有的话就用空闲的线程去执行任务,否则就创建一个线程去执行,效率比较高.

3、ScheduledThreadPool
通过这个线程池的名字可以看出,它支持定时或者周期性执行任务,实现这种功能的方法主要有三种:

ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
service.schedule(new Task(), 10, TimeUnit.SECONDS);
service.scheduleAtFixedRate(new Task(), 10, 10, TimeUnit.SECONDS);
service.scheduleWithFixedDelay(new Task(), 10, 10, TimeUnit.SECONDS);
 第一种是schedule,通过延迟指定时间后执行一次任务,代码中设置的是10秒,所以10秒后执行一次任务就结束.
第二种是scheduleAtFixedRate,通过名称我们可以看出,第二种是以固定频率去执行任务,它的第二个参数initialDelay表示第一次延迟时间,第三个参数period表示周期,总体按照上面的代码意思就是,第一次延迟10秒后执行任务,然后,每次延迟10秒执行一次任务.
第三种方法是scheduleWithFixeddelay这种与第二种方法类似,也是周期执行任务,不同的是对周期的定义,之前的scheduleAtFixedRate是以任务的开始时间为起点开始计时,时间到了就开始执行第二次任务,而不管任务需要多久执行,而scheduleWithFixeddelay是以任务结束的时间作为下一次循环开始的时间起点.
4、SingleThreadExecutor
第四种线程池中只有一个线程去执行任务,如果执行任务过程中发生了异常,则线程池会创建一个新线程来执行后续任务,这个线程因为只有一个线程,所以可以保证任务执行的有序性.

5、SingleThreadScheduleExecutor
这个线程池它和ScheduledThreadPool很相似,只不过它的内部也只有一个线程,他只是将核心线程数设置为了1,如果执行期间发生异常,同样会创建一个新线程去执行任务.

6、ForkJoinPool
最后一种线程池是ForkJoinPool,这个线程池是来支持将一个任务拆分成多个“小任务”并行计算，这个线程池是在jdk1.7之后加入的,它主要用于实现“分而治之”的算法，特别是分治之后递归调用的函数，这里只是对ForkJoinPool做了一个简单的介绍,我们先来介绍一下ForkJoinPool和之前的线程池主要的两个特点。

15. ioc、aop是什么，底层工作原理是什么

IOC：

控制反转：把对象的创建和对象之间的调用过程，从程序员手里转交给Spring进行管理。
使用IOC的目的：为了降低耦合度

底层原理：xml解析、工厂模式、反射

AOP：
1.面向切面编程（面向方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高开发效率

2.通俗描述：不通过修改源代码方式，在主干功能里添加新功能1.面向切面编程（面向方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高开发效率

1.AOP底层使用到了动态代理

1.两种情况动态代理
JDK的动态代理：针对实现接口的类产生代理
Cglib的动态代理：针对没有实现接口的类产生代理

https://www.cnblogs.com/qihaokuan/p/17420057.html

16. 线程都有哪些状态，wait和sleep有什么区别

1、创建状态
使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。
2、就绪状态
当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。
3、运行状态
如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
4、堵塞状态
如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。
可以分为三种：
等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
同步阻塞：线程在获取 synchronized同步锁失败(因为同步锁被其他线程占用)。
其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。
5、死亡状态
一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

========================================================================================================
1、sleep()
使当前线程（即调用该方法的线程）暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。注意该方法要捕捉异常。
例如有两个线程同时执行(没有synchronized)一个线程优先级为MAX_PRIORITY，另一个为MIN_PRIORITY，如果没有Sleep()方法，只有高优先级的线程执行完毕后，低优先级的线程才能够执行；但是高优先级的线程sleep(500)后，低优先级就有机会执行了。
总之，sleep()可以使低优先级的线程得到执行的机会，当然也可以让同优先级、高优先级的线程有执行的机会。

2、join()
join()方法使调用该方法的线程在此之前执行完毕，也就是等待该方法的线程执行完毕后再往下继续执行。注意该方法也需要捕捉异常。

3、yield()
该方法与sleep()类似，只是不能由用户指定暂停多长时间，并且yield（）方法只能让同优先级的线程有执行的机会。

4、wait()和notify()、notifyAll()

这三个方法用于协调多个线程对共享数据的存取，所以必须在synchronized语句块内使用。synchronized关键字用于保护共享数据，阻止其他线程对共享数据的存取，但是这样程序的流程就很不灵活了，如何才能在当前线程还没退出synchronized数据块时让其他线程也有机会访问共享数据呢？此时就用这三个方法来灵活控制。
wait()方法使当前线程暂停执行并释放对象锁标示，让其他线程可以进入synchronized数据块，当前线程被放入对象等待池中。当调用notify()方法后，将从对象的等待池中移走一个任意的线程并放到锁标志等待池中，只有锁标志等待池中线程能够获取锁标志；如果锁标志等待池中没有线程，则notify()不起作用。
notifyAll()则从对象等待池中移走所有等待那个对象的线程并放到锁标志等待池中。
注意 这三个方法都是java.lang.Object的方法。

https://www.cnblogs.com/miniSimple/p/12269950.html

17. spring原理是什么，了解动态代理么

Spring框架是一个开源的Java框架，它主要用于构建企业级应用程序。Spring的原理基于以下几个核心概念：

控制反转（IoC）：

Spring通过控制反转实现了对象的创建和管理。传统的应用程序中，对象的创建由程序员手动完成，而在Spring中，对象的创建和依赖关系的管理交由Spring容器负责。
IoC通过使用Bean容器（ApplicationContext）来管理和组织Java对象（Beans），并通过依赖注入来解决对象之间的依赖关系。
依赖注入（DI）：

依赖注入是IoC的一种具体实现，它通过将依赖关系从程序代码中分离出来，将它们配置到外部的配置文件中或通过注解来实现。
Spring容器负责将依赖关系注入到相应的Bean中，使得对象之间的关系更加灵活、可维护。
面向切面编程（AOP）：

AOP是Spring框架的另一个关键特性，它允许在程序的执行过程中，通过将横切关注点（cross-cutting concerns）从主要的业务逻辑中分离出来，实现对这些关注点的集中管理。
通过AOP，可以将日志、事务管理等横切关注点￥￥出来，提高了代码的模块化和可维护性。
模块化设计：

Spring框架采用模块化设计，将不同的功能拆分成￥￥的模块，使得开发者可以选择性地使用其中的某些模块，而不必引入整个框架。
这种设计使得Spring具有很好的可扩展性和灵活性。
总体而言，Spring框架的原理包括IoC容器、依赖注入、AOP等关键概念，通过这些特性，Spring提供了一种灵活、可维护、可测试的开发方式，使得企业级应用程序的开发更加简便和高效

========================================================================================================
JDK 动态代理：

屏幕截图 2023-06-12 103510.png

基于接口来创建被代理对象的代理实例。当对象要被代理时，它必须实现一个或多个接口并依赖JDK库。JDK动态代理利用反射机制生成一个包含被代理对象的所有接口的代理类，并覆盖接口中的所有方法，可以对目标对象进行代理。

优点：无需引用第三方库，在JRE运行环境中就可以运行，生成代理对象更加简单、快捷；缺点：仅支持基于接口进行代理，无法对类进行代理，所以它的作用有限。

2.、Cglib 代理：

屏幕截图 2023-06-12 103555.png

基于继承的方式对被代理类生成子类，从而添加代理逻辑。因为它是继承了被代理类，所以它会受到final类、private、static等不可继承属性的影响。

优点：Cglib支持对类进行代理，即使没有接口，也可通过设置回调接口间接地实现。性能比JDK动态代理更高，能够代理那些没有实现任何接口的目标对象。

https://www.php.cn/faq/558933.html

18. fetch和pull的区别

1、 fetch： fetch能够直接更改远端跟踪分支。

2、 pull： pull无法直接对远程跟踪分支操作，我们必须先切回本地分支然后创建一个新的commit提交。

二、拉取后的操作不同
1、fetch：fetch会将数据拉取到本地仓库 - 它并不会自动合并或修改当前的工作。

2、 pull： pull是从远程获取最新版本并merge到本地，会自动合并或修改当前的工作。

三.使用后commitID不同。
1、fetch：使用fetch更新代码，本地的库中master的commitID不变，还是等于1。

2、pull：使用pull更新代码，本地的库中master的commitID发生改变，变成了2。

https://blog.csdn.net/fortyman/article/details/126274721

19. springMVC的简单理解

M：Model，模型层，指工程中的javaBean，作用是处理数据
V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据
C：Controller，控制层，指工程中的servlet，作用是接受请求和响应浏览器

MVC的工作流程：
用户通过视图层发送请求到服务器，在服务器中请求被Controller接受，Controller调用响应的Model层处理请求，处理完毕将结果返回到Controller，Controller再根据请求处理的结果找到相应的View视图，渲染数据后最终响应给浏览器。

原文链接：https://blog.csdn.net/qq_53906246/article/details/124097588

20. Java中interface接口的使用

Java中在接口的应用中，要注意一下几点：

<1>接口一般定义的是常量和一些抽象方法。抽象类中可以包含抽象方法，也可以有非抽象方法，但是有抽象方法的类一定是抽象类。抽象方法不能有方法体。

<2>在引用接口时，接口的引用指向实现的对象，尽量定义为接口或父类的引用。这其中有可能用到多态的知识。引用接口用implements。

<3>接口（interface）只能定义抽象方法而且默认为是Public。常量是public static final 修饰的

<4>通过implements来引用接口。例：Class runnrtmp inplements runner.

<5>多个无关类可以实现一个接口，!!!!接口的引用指向实现的对象。

<6>一个类可以实现多个无关的接口（这点和继承要有所区别）

<7>和继承一样，接口与实现类之间存在多态性。

<8>接口可以继承其他的接口，并添加新的属性和抽象方法。

<9>在类中实现接口的方法时必须加上public修饰符

21. 简单介绍一下vue

Vue (读音 /vjuː/，类似于 view) 是一套用于构建用户界面的渐进式框架。与其它大型框架不同的是，Vue 被设计为可以自底向上逐层应用。Vue 的核心库只关注视图层，不仅易于上手，还便于与第三方库或既有项目整合。另一方面，当与现代化的工具链以及各种支持类库结合使用时，Vue 也完全能够为复杂的单页应用提供驱动。

https://v2.cn.vuejs.org/v2/guide/index.html

22. 单链表与双链表的区别

1、指向不同：单向链表只有一个指向下一结点的指针，双向链表除了有一个指向下一结点的指针外，还有一个指向前一结点的指针。
2、功能不同：单向链表只能next ，双向链表可以return。
3、单双向不同：单链表只能单向读取，双向链表可以通过prev()快速找到前一结点

https://www.jianshu.com/p/bcf2437389d0

23. Java是面向对象的编程语言，简单说一下什么是面向对象

24.什么是SpringBoot？

SpringBoot是一个快速开发的框架，能过快速整合第三方框架，他是如何快速整合的呢？其实他是的基本原来是Maven依赖关系，Maven的集成，完全采用注解化，简化XML配置，内嵌HTTP服务器（Tomcate，jetty），默认嵌入Tomcat，最终以Java应用程序进行执行。

https://blog.csdn.net/u012206617/article/details/109010102

25.hashmap在JDK1.7和1.8的区别？

https://learn.skyofit.com/archives/382

26.java中==和equals的区别

区别是：一个是运算符，一个是方法。

==
比较变量的值是否相同。

如果比较的对象是基本数据类型，则比较数值是否相等；
如果比较的是引用数据类型，则比较的是对象的内存地址是否相等。
因为Java只有值传递，对于==来说，不管是比较基本数据类型，还是引用数据类型的变量，其比较的都是值，只是引用类型变量存的值是对象的地址。引用类型对象变量其实是一个引用，它们的值是指向对象所在的内存地址。

equals方法
比较对象的内容是否相同。
equals()方法存在于Object类中，而Object类是所有类的父类。在Object类中定义了equals方法
如果类未重写equals方法
调用equals时，会调用Object中的equals方法（实际使用的也是==操作符）
如果类重写了equals方法
调用equals时，会调用该类自己的equals方法（一般是比较对象的内容是否相同）。比如：
String：比较字符串内容是否相同；
Integer：比较对应的基本数据类型int的值是否相同。

27.String,StringBuffer,StringBuilder区别

https://knife.blog.csdn.net/article/details/121437388

28.Java中怎样创建线程？

一、继承Thread，重写run方法

二、实现Runnable接口，重写run方法

三、使用匿名内部类创建 Thread 子类对象

四、使用匿名内部类，实现Runnable接口

五、lambda表达式

六、实现Callable接口

七、使用线程池创建线程

29.Spring--循环依赖的解决

方案1. Feild注入单例（@AutoWired）
方案2. 构造器注入+@Lazy
方案3. Setter/Field注入单例
方案4. 实现ApplicationContextAware与InitializingBean

面试题库链接：
Java后端真实面试题大全(有详细答案)--高频/真题
10万字208道Java经典面试题总结(附答案)