Java二轮复习

Java二轮复习

跟着牛客的高频问题

Java基础知识

1、说说多线程

  • 线程和进程的区别
    • 进程是程序执行的基本单位,线程是程序执行的最小单位,一个进程包括多个线程
    • 多个线程共享进程的资源(堆、方法区),线程又有一些自己的资源(程序计数器、本地方法栈、虚拟机栈)
  • 多线程的优势
    • 多核优势,可以在多个cpu上运行
    • 减少了响应时间,多线程执行不同任务
    • 提高cpu的利用率,一个线程阻塞另外的线程可以继续运行
    • 总之:提高了系统的并发能力和性能
  • 多线程的缺点
    • 死锁问题:两个及以上线程相互请求对方的资源
    • 内存泄漏:ThreadLocal(Value的强引用)
    • 线程安全(同步问题):锁

2、说说怎么保证线程安全

  • java在juc下提供很多种方式来保证线程安全,较为常用的有
    • 原子类
      • 保证原子性,通过无锁机制实现(比较并替换,CAS),具体是调用了unsafe类,用c++实现的
    • Volatile关键字
      • 保证有序性和可见性,具体实现是依赖于java的内存模型(JMM)
      • 可见性是应用了cpu的缓存一致性原则,当一个cpu上的变量发生改变,将他置为M(修改)并刷回内存,其他cpu置为I,不可用,重新从内存种读取该变量
      • 有序性是用了读写屏障实现,避免指令重排
      • synchronized
        • 关键字,本来是重量级锁,后面做了锁的优化(锁升级),依赖与对象头中的markword字段
      • Lock
        • api,AQS实现,双向阻塞队列
    • ThreadLocal
      • 线程单独存储,变量隔离
    • 并发工具
      • Semaphore
      • countdownlatch
      • cyclebarrier

3、请说说你对反射的了解

  • 反射是什么:在程序运行期间可以获取任意一个类的方法和属性信息
  • 实现原理:类在加载时创建了Class的对象,存储了类的信息
  • 优缺点
    • 优点是使程序更加灵活
    • 缺点是破坏了程序的封装性
  • 方式
    • 对象.getClass()
    • 类.class
    • Class.forName()
  • 场景:string aop中利用的动态代理模式

4、请你说说ArrayList和LinkedList的区别

  • 数据结构方面:数组、双向链表
  • 存储:要存后面扩容的部分、要存前后指针
  • 查找:随机查找、中间和头尾
  • 插入和删除:移动/扩容、直接插入

5、你知道哪些线程安全的集合?

  • vector、hashtable:synchronized实现的,性能比较差
  • Collections.synchronizedXXX():用的也不多
  • CopyOnWriteArrayList、ConcurrentHashMap、BlockingQueue:lock

6、ConcurrentHashMap

  • 数据结构:
    • jdk1.8前:segment分段数组+hashentry数组+链表
    • jdk1.8后,node数组+链表,链表数量>8会转成红黑树
  • 锁的实现
    • 1.8前是分段锁,用的reentrantlock
    • 1.8后是通过cas+syn锁头节点的形式
  • 多线程的扩容
    • 先扩容,再插入;每个线程承担一部分工作

7、说说你了解的线程同步方式

  • 通过锁来同步,往底层讲:互斥量、信号量、事件;在java中实现同步通过:锁、volatile关键字、并发组件、并发容器
  • 锁的分类:乐观和悲观
  • 两种不同的锁:syn和lock
    • syn锁的升级,对象头的markword
      • 无锁01
      • 偏向锁01,偏向锁位置1
      • 轻量级00:双向绑定+自旋
      • 重量级10:object Monitor
    • reentrantlock:aqs,双向阻塞队列
  • 其他分类:按功能
    • 公平、非公平
    • 可重入
    • 读写

8、String、StringBuffer、StringBuilder有什么区别

  • 是否可变
    • string是final修饰的数组,不可变长,类也是被final修饰不可继承
  • 是否是线程安全的:stringbuffer线程安全
  • 效率

9、请你说说HashMap底层原理

  • 数据结构:node数组+链表/红黑树
  • 扩容
    • 三大参数
    • 2^n

10、说说你了解的JVM内存模型

  • 类的加载子系统
    • 根据类的限定名加载
      • 类的加载:双亲委派机制,将二进制流转为方法区的数据结构并在堆创建class对象
      • 类的连接:准备(静态变量初始值)、验证(格式)、解析(符号引用转为直接引用)
      • 类的初始化:静态变量的赋值
  • 字节码执行引擎:执行加载类方法中的指令
  • 运行时数据区
    • 进程
      • 堆:gc堆、字符串常量池、静态变量
      • 方法区:类元信息、运行时常量池、JIT缓存
    • 线程
      • 程序计数器:用于线程上下文切换和命令的执行
      • 虚拟机栈:栈帧(动态链接、方法返回地址、操作数栈、局部变量表)
      • 本地方法栈
    • 直接内存(元空间)

11、说说JVM的垃圾回收机制

  • 分代收集
    • 建立在3个分代假说上
      • 弱分代假说:绝大多数对象生命周期很短
      • 强分代:经历过多次垃圾收集的越难消亡
      • 跨代引用:跨代引用的占少数
    • 分类
      • 部分收集
        • 新生代
          • 标记复制:对象生命周期通常很短
          • 分代年龄> 15进入老生代,但要先做分配担保
          • 垃圾收集器:serial、ParNew、Parallel Scavenge
        • 老生代
          • 标记清除、标记整理:存活的对象比较多
          • 垃圾收集器:serial old、Parallel Old、cms
      • 混合收集
        • G1,新生代和老生代一起收集
        • 因为堆的划分是以逻辑划分的,每个区域成region
      • 整堆收集
        • 收集堆和方法区
        • 场景
          • 调用system.gc()
          • 分配担保失败
  • 收集器的组合
    • Serial + Serial Old,是客户端模式下常用的收集器
    • ParNew+CMS是服务器端
    • Parallel Scavenge + Parallel Old (吞吐量,jdk1.8默认)

12、说说类加载机制

  • 类加载
    • 二进制流转为方法区的数据结构,在堆中创建class对象
    • 双亲委派机制
      • 防止类的重复加载,保证了java包中的类不被破坏
      • 先交给父类去加载
      • BootstrapClassLoader、ExtensionClassLoader、AppClassLoader
  • 类连接
    • 验证:格式
    • 准备:静态变量分配内存设置初始值
    • 解析:符号引用转直接引用
  • 类的初始化:静态变量赋值
  • 这两个不是但也属于类的生命周期(使用、卸载)

13、请你说一下抽象类和接口的区别

  • 强调的概念不一样
    • 接口是对对象行为的约束,抽象类是对对象特征的概述
  • 抽象类中可以定义各种变量,但接口中只能定义不能修改的静态常量
  • 单继承多实现
  • 方法上,接口没有构造方法抽象函数有(jdk1.8后接口也有默认方法和静态方法,所以这个不算)

14、==与equals()的区别

  • 基本数据类型:==比值,equals不行
  • 引用数据类型
    • ==比较的是地址
    • equals没重写前是地址,重写后是值(重写是不是要写hashcode)

15、说说synchronize的用法及原理

  • 作用位置
    • 方法上(Acc_synchronized)
    • 代码块上(monitor enter、monitor exit)
    • 本质:作用在对象上
  • 锁升级
    • 原理是利用对象头mark word字段
    • 无锁01,用cas来获取变量
    • 偏向锁01,偏向位1,对象头保存经常获取/访问的线程id
    • 轻量级锁00,当有两个以上的线程进行竞争的时候升级,利用mark word存储线程的栈中的lock record,然后线程指向对象,实现双向绑定,取余线程自旋
    • 重量级锁10,当自旋的数量超过1个的时候升级成重量级锁,原理是创建对象的objectMonitor对象,并在markword中指向他。维护了两个队列,一个是等待队列,一个是阻塞队列,这也是为什么wait和notify为什么要放在同步代码块,因为也是借助objectmonitor实现的

16、说说你对AQS的理解

  • AQS队列同步器,是用来构建锁的基础框架。Lock锁基本是都是用AQS实现的
  • 运用了设计模式中模板方法的思想,锁的实现需要继承并重写对应的方法
  • 实现原理上
    • 维护了一个FIFO的队列(双线链表),线程来了之后如果是公平锁就加入阻塞队列,非公平锁就先看当前锁是否可以获取,可以就用否则加入阻塞队列
    • 使用一个volatile关键字表示锁的状态,0表示可以获取,线程通过CAS获取锁

17、Java哪些地方使用了CAS

  • 原子类、AQS、并发容器(ConcurrentHashMap)

18、说说JVM的垃圾回收算法

  • 标记清除:内存碎片
  • 标记复制:内存开销大
  • 标记整理:stw

19、说说static修饰符的用法

  • 修饰的对象:类、方法、变量和代码块
    • 静态内部类,可以通过外部类.内部类的方法访问
    • 静态方法,只能访问静态变量和方法
    • 静态代码块,类加载时执行,可以访问静态变量
      • 静态代码块在类加载时执行,并且只执行一次
      • 直接放在类中,不放方法里面
    • 静态变量,属于类

20、说说线程的状态

  • 创建、就绪、运行、阻塞、等待、等待超时、终止
  • 创建的方式
    • 继承Thread类
    • 实现Runnable接口
    • 实现Callable接口

21、说说你对ThreadLocal的理解

  • 作用:每个线程有自己单独的资源,避免多线程间共享
  • 原理:
    • 每个线程中有一个ThreadLocalMap,key就为ThreadLocal,value为存储的具体的值
    • key为弱引用,避免线程结束后因强引用无法回收ThreadLocal造成内存泄漏
    • value为强引用,所以用完要及时进行remove,否则会造成内存泄漏

22、synchronized和Lock有什么区别

  • syn是关键字,lock是接口
  • 使用方式:
    • syn是隐式锁,自动释放,可以作用于方法、同步代码块
    • lock是显示锁,需要手动加锁和释放
  • lock可以获取锁的状态、等待可中断
  • 实现方式:ObjectMonitor、AQS

23、说说volatile的用法及原理

  • 并发特性
    • 原子性(×)
    • 可见性(√)
    • 有序性(√)
  • JMM:java内存模型
    • 线程将变量拷到本地进行操作(read、load)(store、write)(lock、unlock)(use、assign)
  • volatile关键字
    • 可见性:CPU的缓存一致原则,当一个变量发生改变就置为(M修改),其余置为(I无效),当其他线程使用时需要重新从内存中加载
    • 有序性:禁止指令重排,指令执行时编译器会根据指令的相关性进行重排序,java中通过读写屏障来保证指令的有序性,既在读操作后加(loadload和loadstore),在写操作前后加(storestore和storeload)

24、请你说一下final关键字

  • 作用地方
    • 类:类不能继承
    • 方法:方法不能重写
    • 引用变量:不能重新指向(地址不能变)
    • 基本变量:不能改变值

25、请你说说重载和重写的区别,构造方法能不能重写

  • 重载:方法名相同,返回值、参数类型、参数数量都可能不一样
  • 重写:子类重写父类的方法,方法内容可以不同其余都相同
  • 构造方法不能重写

26、请说说你对Java集合的了解

  • Collection
    • List
    • Set
    • Queue
  • Map
    • HashMap
    • TreeMap
    • HashTable

27、请你说说IO多路复用

  • 定义:单个进程或者线程可以处理多个IO请求
  • 实现原理
    • Linux提供了3种方式:select、poll、epoll,本质上是让操作系统内核缓冲IO数据,让单个进程/线程监视这些文件描述符
    • select通过将文件描述符的数组拷贝到内核态,然后轮询的方式查看是否有数据返回
      • 缺点
        • 每次将文件描述符拷到内核态,开销大
        • 轮询的方式查看
        • 支持的文件描述符个数有限
    • poll将底层数据结构改成了链表,解决了文件描述符个数/重用的问题
      • 缺点:轮询、内核切换
    • epoll:直接在内核中创建一个结构体eventpoll,当有数据来的时候内核会将数据放入就绪队列并通知进程/线程进行读取
      • 数据结构:
        • rbr:红黑树构建的文件描述符
        • rdlist:就绪队列
        • wq:等待队列
      • 命令
        • epoll_create:创建结构体
        • epoll_ctrl:将文件描述符(红黑树)添加/删除/修改
        • epoll_wait:内核返回就绪事件
      • 模式
        • 水平触发LT:一次没拿完就会再通知
        • 边缘触发ET:一次没拿完就下次有数据来了再通知

28、Java 8的新特性

  • lambda表达式:结合函数式接口,简化了代码,将函数作为参数进行传递
  • stream流式计算:将元素或者集合转换成流进行运算
  • datetime时间类:时区问题、格式化问题(日期与时间分离)
  • optional:Optional 类已经成为 Java 8 类库的一部分,用来解决空指针异常。
  • 允许在接口中定义默认的方法,用default修饰

29、请你说说泛型、泛型擦除

  • java中的泛型属于伪泛型,主要的作用是在编译的时候进行类型检查,并且可以将类型自动转换;
  • 在编译期间所有的范型信息会被擦除,被称为泛型擦除
  • 泛型是可以通过反射机制破坏的

30、说说你了解的线程通信方式

  • Monitor
    • 如果是采用synchronized关键字进行同步,则需要依赖Monitor(同步监视器)实现线程通信
    • 由于Monitor实现了等待队列,所以可以使用wait、notify、notifyAll来通信
  • Condition
    • 如果是采用Lock对象进行同步,则需要依赖Condition实现线程通信
    • Lock锁使用Condition可以创建多个等待队列,所以可以做到选择通知,await、signal、signalAll

31、请你说说JUC

  • java.uilt.concurrent包,下面包含一系列的并发相关的工具,比如:原子类、锁(Lock)、并发容器、并发工具、线程池(ThreadPoolExecutor)等

32、请你说说HashMap和Hashtable的区别

  • 数据结构上的区别:hashmap使用node数组+链表+红黑树的方式进行存储,hashtable使用的是node数组+链表的方式
  • 扩容时的区别:hashmap默认是16,如果有设置初始值,默认扩到2^n大小;hashtable默认是11,每次扩到2n+1大小
  • 线程安全:hashmap是线程不安全的,hashtable用syn锁整张表是线程安全的,但效率比较低
  • 存储:hashmap对null进行了特殊处理,key可以有一个为null,value可以为null;hashtable key和value都不能为null(value为null会报空指针)

33、HashMap是线程安全的吗?如果不是该如何解决?

  • HashMap不是线程安全的,多线程在put的时候可能会发生冲突
  • 线程安全的几种方式
    • hashtable:锁表,古老api不建议使用
    • Collections.synchronizedMap():锁表
    • ConcurrentHashMap:锁头节点,效率高
    • Lock,手动加锁

34、请你说说Java的四种引用方式

  • 强引用:任何时候都不会回收
  • 软引用:空间不够就回收
  • 弱引用:一旦发现就回收
  • 虚引用:任何时候都可能回收

35、请你讲下G1垃圾回收器

  • G1面向服务器的垃圾回收器,与CMS注重停顿时间不同,G1更注重cpu的吞吐量,所以适用于服务器的垃圾回收
  • 原理:三色标记+SATB(原始快照)
  • 特点
    • 并发与并行:可以并发的标记,又因为用在服务器中,可以用服务器中多核的优势做到并行运行,可以使用其中一个cpu进行gc其余进行运行
    • 可预测的停顿时间:G1将堆中物理的分区转换为逻辑上的分区,将region做为每次回收的最小单位,可以通过region计算出所需要的时间
    • 分代收集:G1不仅局限于某个分区,可以进行部分收集、混合收集
      • 过程:初始标记(STW)、并发标记、最终标记(STW)、筛选回收(STW)(按照成本、价值、停顿时间来回收)
    • 空间整合:整体是标记整理,局部是标记复制

36、请你说说内存溢出

  • 内存溢出:申请的内存大于系统能够提供的内存
  • 可能出问题的地方:除了线程虚拟机栈中的程序计数器,其他部分都可能会引发OOM
  • 排查方法
    • 思路
      • 查看jvm的参数是否正常
      • 分析堆的内存占用情况
      • 查看那个地方的gc除了问题
    • 过程
      • jps或者top或者ps -ef | grep java查进程id
      • jinfo pid:查看jvm的参数
      • jstat -gc pid:查看gc情况
      • jmap -heap pid:查看堆信息
      • jmap histo:live pid:查看存活的对象
      • jmap -F -dump:format=b,file=file.phrof pid:保存堆信息

37、请你说说内存泄漏

  • 不再使用的对象仍然被引用,导致垃圾收集器无法回收它们的内存,会进一步导致内存溢出(OOM)
  • 排查方式见内存溢出(看jvm参数、看堆信息、看gc信息)

38、请你说说String类,以及new和直接创建的区别

  • string类,提供了很多方法的api,重写了equals方法,本身类和数组是由final修饰的,所以不能改变
  • 直接创建的字符串是由字符串常量池管理的,通过new创建会先在字符串常量池中添加,再在堆中创建对象
  • 可以调用intern方法在字符串常量池中创建,如果有就返回

39、请你说说hashCode()和equals()的区别,为什么重写equals()就要重写hashcode()

  • hashcode()是获取对象的hash码,equals是判断对象是否相等
  • 当放入需要散列的集合类的时候,会优先比较hashcode,如果不等就说明对象不同,如果相等再根据equals进行判断

40、说说线程的创建方式

  • 继承Thread类重写start方法
  • 实现Runnable接口,重写run方法,并将对象作为Thread的参数
  • 实现Callable接口,重写call方法,并将对象作为FutureTask的参数

41、说说你对ArrayList的理解

  • 数据结构:数组
  • 扩容:初始为0,第一次插入时扩为10,每次扩1.5倍,用了System.arraycopy()拷贝新数组中

42、请你说说BIO、NIO、AIO

  • BIO:阻塞IO,线程io请求时会等待
  • NIO:非阻塞IO,和多路复用很像,一个线程监听多个请求
    • select,多路复用器,查看各个通道的状态
    • channel,通道,连接具体的实体(套接字)
    • buffer,缓存,存接受/发送的数据
  • AIO:异步IO

43、说说垃圾收集器

  • Serial、Serial Old、PawNew、CMS、Parallel Scavenge、Parallel Old、G1

44、请你说说Java的特点和优点,为什么要选择Java?

  • 特点
    • 面向对象
    • 简单易学,丰富的类库
    • 平台无关
    • 安全可靠,不直接操作内存管理内存空间
    • 多线程
  • 与c++的区别
    • 内存、继承、重载

45、介绍一下包装类的自动拆装箱与自动装箱

  • 自动装箱是指把一个基本类型的数据直接赋值给对应的包装类型;自动拆箱是指把一个包装类型的对象直接赋值给对应的基本类型;
  • 通过自动装箱、自动拆箱功能,可以大大简化基本类型变量和包装类对象之间的转换过程

46、说说wait()和sleep()的区别

  • 作用位置不同:sleep可以作用在任意位置,wait必须在同步代码块中
  • 唤醒条件不同:sleep会进入超时等待,一会自动唤醒,wait需要手动notify
  • 锁的处理不同:sleep不会释放锁,wait会释放锁
  • 所属的类型不同:sleep是Thread类,wait是object

47、说说你对线程池的理解

  • 作用:方便管理,减少开销,提高响应速度
  • 7大参数
    • 核心线程数:最小存活/同时运行的线程数
    • 最大线程数:当等待队列满了最大同时运行的线程数
    • 等待队列:阻塞队列,当达到核心线程数后加入队列
    • 存活时间:队列中的线程存活时间
    • 时间单位
    • 线程池创建方式:默认
    • 拒绝策略:
      • 直接丢弃
      • 抛出异常
      • 交给原线程
      • 丢弃等待队列中的第一个

48、简单说下你对JVM的了解

  • JDK:java开发工具包(包含jre、编译器javac和调试工具)——JRE:java运行时环境(包含jvm和类库)——jvm:java虚拟机(JIT编译器、解释器)
  • hotspot:openjdk、OracleJdk
  • jvm的内存模型:类的加载子系统、执行引擎、运行时的数据区

49、说说Java运行时数据区

  • 进程
    • 堆:
      • gc堆
      • 字符串常量池
      • 静态变量
    • 方法区:
      • 类元信息:类的基本信息,版本,方法
      • 运行时常量池:字面量、符号引用
      • JIT缓存
  • 线程
    • 程序计数器:用于线程上下文切换和命令的执行
    • 虚拟机栈:栈帧(动态链接、方法返回地址、操作数栈、局部变量表)
    • 本地方法栈
  • 直接内存:元空间、直接内存

50、请你讲下CMS垃圾回收器

  • 老年代垃圾回收器,与pawnew(新生代)一起工作,注重停顿时间(用户体验),标记清除
  • 原理:三色标记+增量更新
  • 过程
    • 初始标记 stw——并发标记——重新标记 stw——并发清除
  • 缺点
    • cpu敏感,和其他线程一起工作
    • 浮动垃圾,并发标记阶段产生的垃圾(多标问题)
    • 并发失败,浮动垃圾太多预留内存不够,stw启用serial old进行收集
    • 内存碎片

51、说说JVM的双亲委派模型

  • 原理:子类交给父加载器去加载
  • 作用:保证类不会被重复加载,保护java中自带类
  • 加载器:
    • BootstrapClassLoader:加载java的类 \lib
    • ExtensionClassLoader:拓展类的加载器 \lib\ext
    • AppClassLoader:用户的和第三方的类加载器

52、请你说说Java基本数据类型和引用类型

  • 8大基本数据类型
  • 引用数据类型存在堆中,基本数据类型存在栈中

53、请你说说Java的异常处理机制

  • 错误:OOM
  • 异常
    • 受检查的异常:可以捕获的异常(IO相关的错误)
    • 不受检查的异常(运行时异常):不可以捕获的异常(空指针异常、数组越界)

54、说说你对面向对象的理解

  • 特征:
    • 继承
    • 封装
    • 多态:父类指向子类实例,子类重写父类的方法
  • 类之间的关系
    • 依赖:一个类作为另一个的参数
    • 关联:一个类作为另一个的属性
      • 组合:总体消失分的也要消失
      • 聚合:总的消失分的还在
    • 继承
    • 实现

55、请介绍一下访问修饰符

  • 访问级别控制从小到大为: private->default->protected->public
    • private:类中被private修饰的成员只能在当前类的内部被访问
    • default:如果类中的成员或者一个外部类不使用任何访问修饰符来进行修饰,那么他就是default级别的,default访问控制的类成员或者外部类可以被相同包下的其他类访问
    • protected:类中被protected修饰的可以被当前类和当前类所在的包的其他类以及子类访问
    • public:这是Java中最宽松的访问级别,如果类成员被这个修饰符修饰,那么无论访问类和被访问类在不在一个包下,有没有父子关系,这个类成员都可以被访问到

56、说说Java中常用的锁及原理

  • 乐观锁:CAS(版本号)
  • 悲观锁:
    • Synchronized:ObjectMonitor
      • 等待队列、阻塞队列、锁升级、markword
    • Lock:AQS
      • 模板方法、FIFO的双线链表队列、volatile state

57、请你说说List与Set的区别

  • 集合类,是否可以重复
  • ArrayList、LinkedList
  • HashSet、TreeSet

58、请你讲一下Java NIO

  • Not Block IO/New IO,和Linux中的多路复用很像,通过多路复用器Select监听多个通道,当数据来时通过将数据读/写道缓冲区再执行进一步的操作
  • 组件
    • select:多路复用器,监听多个channel
    • channel:通道,连接具体的实体(文件描述符/socket)
    • buffer:缓冲区,存放读写的数据

59、说说GC的可达性分析

  • 判断对象是否可达有两种方式:引用计数法和可达性分析
  • 可达性分析:通过确定一个GC Roots,从root开始搜索将可以到达的对象加入引用链中,判断对象是否引用链中即是否可达
  • GC root
    • 虚拟机栈中引用的对象:局部变量、中间结果
    • 本地方法栈中引用的对象
    • 方法区常量引用的对象
    • 方法区静态变量引用的对象
  • 对象死亡(不可达一定被回收吗)
    • 第一次标记,判断对象不可达,进行筛选,如果没有覆盖finalize方法或者finalize方法已经被调用回收;或者加入队列,然后启动一个线程调用对象的finalize
    • 第二次标记,如果对象依旧不可达就回收,除非这个对象调用finalize方法时与引用链上的任何一个对象建立关联

60、类的实例化过程——对象的创建

  • 加载类信息:去方法区加载类的信息
  • 分配内存:堆上开辟空间
    • 分配方式
      • 空闲列表:找一个空的分配
      • 指针碰撞:先整理再分配
    • 并发
      • CAS+自旋
      • TLAB
  • 初始化零值
  • 设置对象头
  • 执行init方法

61、对象的内存布局

  • 对象头:
    • mark word:分代年龄、锁、hashcode
    • 类指针:class point
    • 数组长度(如果是数组的话)
  • 实例数据
  • 对齐填充

62、创建对象的方式

  • 使用 new 关键字调用对象的构造器;
  • 使用 Java 反射的 newInstance() 方法;
  • 使用 Object 类的 clone() 方法;
  • 使用对象流 ObjectInputStream的readObject()方法读取序列化对象;

Spring

1、说说你对MVC的理解

  • MVC是一种设计模式,在这种模式下软件被分为三层,即Model(模型)、View(视图)、Controller(控制器)
    • M:数据
    • V:视图/页面
    • C:控制,业务逻辑
  • 优点:采用分离的思想,降低了代码的耦合度,提高了代码的复用率
  • 缺点:增加了代码量
  • Spring MVC是spring框架中的一个模块,web模块提供了spring对MVC的实现

2、说说你对AOP的理解

  • 定义:AOP面向切面编程,是一种编程的思想,通过在编译时或者是运行时动态添加的方式,将一些重复的业务代码独立出来,减少代码的冗余
  • 方式
    • SpringAOP:运行期间通过动态代理的方式进行添加代码
      • JDK Proxy:通过实现接口(InvocationHeadle)的代理类实现
      • Cglib Proxy:通过继承/子类实例实现代理
    • AspectJ AOP:在编译期间动态织入

3、说说你对IoC的理解

  • IoC控制反转,是一种编程思想,用户将对象的创建和管理交给容器/框架来维护,DI依赖注入是实现IoC的一种方式,通过DI获取对象,不用手动维护对象之间依赖的关系,减少了代码的耦合
  • DI的几种方式
    • 属性注入(常用、不推荐)
    • set注入
    • 构造方法注入
  • springboot注解:@Autowired、@Resource

4、说说Spring Boot常用的注解

  • 注册为Bean:@Component、@Repository、@Service、@Controller、@Configure+@Bean
  • 依赖注入:@Autowired、@Resource
  • 自动装配:@Spring Boot Application
    • @SpringBootConfiguration、@ComponentScan、@EnableAutoConfiguration
      • @Import、@AutoConfigurationImportSelect——selectImport

5、说说Bean的生命周期

  • 生命周期

    • 扫描:将xml、注解中的对象封装成Bean Definition
    • class中包含的信息太少,还要包含一些类的信息、是否延迟加载、自动绑定模式
    • 注册:将BeanDefinition注册到BeanDefinitionMap中,key就是BeanDefinition的名字,value是BeanDefinition
    • 获取:BeanFactory的doGetBean()方法,如果没有就开始下面的过程
    • 实例化:
      • 前置函数postProcess函数
      • 执行doCreateBean方法,创建Bean的实例,加入三级缓存
      • 后置函数
    • 依赖注入/属性填充
      • 循环依赖问题——三级缓存
        • singletonObjects——earlySingletonObjects——singletonFactory
        • a依赖b,b依赖a,实例化a注入b时先创建b,b在依赖注入时从3级缓存中找到a,放入2级缓存,完成b后,a再进行依赖注入,初始化完成将2级缓存删了放1级缓存中
        • 为什么2级缓存不行
          • 因为当有代理出现时,b放的是代理对象,a在初始化完成后查看有无代理对象,有的话就直接用代理对象,否则再创建代理对象放1级
          • 如果去掉3级缓存,a在实例化后需要将代理对象放入2级缓存
          • 如果去掉2级缓存,b、c都依赖a,但会依赖不同的代理对象
    • 初始化
      • 是否实现了aware方法
      • 前置函数
      • 是否有自定义的初始化方法
      • 后置函数:产生代理对象放入1级缓存
    • 销毁
      • 是否有自定义的destroy方法
      • DisposableBean的destroy方法
  • 作用域

    • singleton
    • prototype
    • session
    • request
    • globalsession

6、简单介绍Spring

  • spring是一种轻量级的java开发框架,其中包括很多模块(web模块、data模块、core模块、Aop模块、test模块)
  • 特点:AOP、IoC

7、介绍一下MyBatis的缓存机制

  • 生命周期
    • sqlsessionFactory:全局唯一
    • sqlSession:每个语句
  • 一级缓存(默认开启)会将查询的结果存入sqlSession缓存中,当遇到更新/删除操作的时候就清除缓存,当sqlSession会话关闭时存入二级缓存(手动开启)中(sqlSessionFactory)
  • 先查二级缓存,再查一级,再查数据库
  • 过期用lru

8、说说你对Spring Boot的理解,以及它和Spring的区别?

  • springboot是对spring的简化,通过约定大于配置的思想简化了spring中的很多配置
    • 优点
      • 快速构建项目
      • 无需配置继承框架
      • 独立运行不需要serlvet容器(tomcat)
      • 提供实时监控
    • 核心功能
      • 自动化配置:很多spring配置不用自己来了
      • 起步依赖:特殊的maven(spring-boot-starter-XXX),将依赖功能聚合
      • 端点监控:可以监控程序运行

9、说说Spring Boot的自动装配

  • SpringBootApplication注解含以下3个注解:
    • ComponentScan,扫描包下所有的bean并加载
    • SpringBootConfiguration:原配置类,相当于@Configuration
    • EnableAutoConfiguration:通过@import的方式导入了@AutoConfigurationImportSelect类,并调用selectImports方法,从META-INF路径下的spring.factories中 加载spring.factories中的AutoConfiguration 类,满足@conditional注解条件时,就实例化该AutoConfiguration类中定义的组件bean,并再次根据扫描到bean中的import方法进行加载,最终完成自动装配。

10、说说@Autowired和@Resource注解的区别

  • @Autowired是Spring提供的注解,@Resource是JDK提供的注解
  • @Autowired是只能按类型注入,@Resource默认按名称注入,也支持按类型注入
  • @Autowired也可以通过@Qualifier指定名称
  • @Resource有两个中重要的属性:name和type
    • 如果同时指定了name和type,则从Spring上下文中找到唯一匹配的bean进行装配,找不到则抛出异常
    • 如果指定了name,则从上下文中查找名称(id)匹配的bean进行装配,找不到则抛出异常
    • 如果指定了type,则从上下文中找到类型匹配的唯一bean进行装配,找不到或者找到多个,都会抛出异常
    • 如果既没有指定name,又没有指定type,则自动按照byName方式进行装配;如果没有匹配,则回退为一个原始类型进行匹配,如果匹配则自动装配;

11、说说Spring Boot的启动流程

  • run方法:获取监听器参数配置-》打印banner-》创建并初始化容器-》监听发送通知

12、介绍一下Spring MVC的执行流程

  • https://blog.csdn.net/qq_39543984/article/details/111132789

img

  • 1、用户点击某个请求路径,发起一个 HTTP request 请求,该请求会被提交到 DispatcherServlet(前端控制器);
  • 2、由 DispatcherServlet 请求一个或多个 HandlerMapping(处理器映射器),并返回一个执行链(HandlerExecutionChain)。
  • 3、DispatcherServlet 将执行链返回的 Handler 信息发送给 HandlerAdapter(处理器适配器);
  • 4、HandlerAdapter 根据 Handler 信息找到并执行相应的 Handler(常称为 Controller);
  • 5、Handler 执行完毕后会返回给 HandlerAdapter 一个 ModelAndView 对象(Spring MVC的底层对象,包括 Model 数据模型和 View 视图信息);
  • 6、HandlerAdapter 接收到 ModelAndView 对象后,将其返回给 DispatcherServlet ;
  • 7、DispatcherServlet 接收到 ModelAndView 对象后,会请求 ViewResolver(视图解析器)对视图进行解析;
  • 8、ViewResolver 根据 View 信息匹配到相应的视图结果,并返回给 DispatcherServlet;
  • 9、DispatcherServlet 接收到具体的 View 视图后,进行视图渲染,将 Model 中的模型数据填充到 View 视图中的 request 域,生成最终的 View(视图);
  • 10、视图负责将结果显示到浏览器(客户端)。
  • 记忆:请求——前端控制器——映射器(找handler执行链)——适配器(执行handle/controller)——视图解析器(解析视图)——填充渲染

13、在MyBatis中$和#有什么区别

  • #{}相当于使用PreparedStatement ,会将sql中的特殊字符进行转义;${}是字符串替换,有sql注入的风险

14、说说Spring Boot的起步依赖

  • 约定大于配置的思想,springboot将各种场景下的依赖做成starter,用户只需要在maven中引入starter依赖springboot就可以自动的扫描加载信息并启动默认的配置。

15、说说Spring事务管理

  • 编程式事务:TransactionTemplate,可以将事务管理的范围控制的更为精确
  • 声明式事务:@Transactional
    • 作用范围:方法、类(所有方法都开启)、接口(不建议)
    • 参数:事务的传播级别、事务的隔离级别等

16、说说Bean的作用域,以及默认的作用域

  • singleton :在Spring容器中仅存在一个实例,即Bean以单例的形式存在
  • prototype :每次调用getBean()时,都会执行new操作,返回一个新的实例
  • request :每次HTTP请求都会创建一个新的Bean
  • session :同一个HTTP Session共享一个Bean,不同的HTTP Session使用不同的Bean
  • globalSession:同一个全局的Session共享一个Bean,一般用于Portlet环境

17、说说BeanFactory和FactoryBean的区别

  • Bean Factory是一个IoC容器用来产生Bean
  • FactoryBean是一个Bean对象,可以产生或者修饰bean

18、BeanFactory和ApplicationContext

  • 相同点:都是IoC容器
  • 不同点
    • 功能:ApplicationContext是BeanFactory的子类,具有BeanFactory的功能外还有一些附加的功能,例如国际化什么的
    • 加载方式:BeanFactory是延迟加载,需要的时候才加载,ApplicationContext是开始时全部加载
    • 创建方式:BeanFactory是编程创建,ApplicationContext是声明创建
    • (BeanPostProcessor)注册方式:BeanFactory手动,ApplicationContext自动注册
  • 所以更建议用ApplicationContext

你可能感兴趣的:(面试复习,java,jvm,开发语言)