java基础-3

1. 异常
   

2. Exception 和 Error 有什么区别？

   Java 中，所有的异常都有一个共同的祖先 java.lang 包中的 Throwable 类。Throwable 类有两个重要的子类
   Exception :程序本身可以处理的异常，可以通过 catch 来进行捕获。Exception 又可以分为 Checked Exception (受检查异常，必须处理) 和 Unchecked Exception (不受检查异常，可以不处理)。
   Error ：Error 属于程序无法处理的错误 ，我们没办法通过 catch 来进行捕获不建议通过catch捕获 。例如 Java 虚拟机运行错误（Virtual MachineError）、虚拟机内存不够错误(OutOfMemoryError)、类定义错误（NoClassDefFoundError）等 。这些异常发生时，Java 虚拟机（JVM）一般会选择线程终止。

3. ClassNotFoundException 和 NoClassDefFoundError 的区别

   ClassNotFoundException 是Exception，发生在使用反射等动态加载时找不到类，是可预期的，可以捕获处理。 NoClassDefFoundError 是Error，是编译时存在的类，在运行时链接不到了（比如 jar 包缺失），是环境问题，导致 JVM 无法继续。

4. Checked Exception 和 Unchecked Exception 有什么区别？

   Checked Exception 即 受检查异常 ，Java 代码在编译过程中，如果受检查异常没有被 catch或者throws 关键字处理的话，就没办法通过编译。
   除了RuntimeException及其子类以外，其他的Exception类及其子类都属于受检查异常 。常见的受检查异常有：IO 相关的异常、ClassNotFoundException、SQLException…。

Unchecked Exception 即 不受检查异常 ，Java 代码在编译过程中 ，我们即使不处理不受检查异常也可以正常通过编译。

RuntimeException 及其子类都统称为非受检查异常，常见的有（建议记下来，日常开发中会经常用到）：

NullPointerException(空指针错误)
IllegalArgumentException(参数错误比如方法入参类型错误)
NumberFormatException（字符串转换为数字格式错误，IllegalArgumentException的子类）
ArrayIndexOutOfBoundsException（数组越界错误）
ClassCastException（类型转换错误）
ArithmeticException（算术错误）
SecurityException （安全错误比如权限不够）
UnsupportedOperationException(不支持的操作错误比如重复创建同一用户)

1. 你更倾向于使用 Checked Exception 还是 Unchecked Exception？

   默认使用 Unchecked Exception，只在必要时才用 Checked Exception。 我们可以把 Unchecked Exception（比如 NullPointerException）看作是代码 Bug。对待 Bug，最好的方式是让它暴露出来然后去修复代码，而不是用 try-catch 去掩盖它。 一般来说，只在一种情况下使用 Checked Exception：当这个异常是业务逻辑的一部分，并且调用方必须处理它时。比如说，一个余额不足异常。这不是 bug，而是一个正常的业务分支，我需要用 Checked Exception 来强制调用者去处理这种情况，比如提示用户去充值。这样就能在保证关键业务逻辑完整性的同时，让代码尽可能保持简洁。

2. Throwable 类常用方法有哪些？

   String getMessage(): 返回异常发生时的详细信息
   String toString(): 返回异常发生时的简要描述
   String getLocalizedMessage(): 返回异常对象的本地化信息。使用 Throwable 的子类覆盖这个方法，可以生成本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与 getMessage()返回的结果相同
   void printStackTrace(): 在控制台上打印 Throwable 对象封装的异常信息

3. try-catch-finally 如何使用？
   try块：用于捕获异常。其后可接零个或多个 catch 块，如果没有 catch 块，则必须跟一个 finally 块。
   catch块：用于处理 try 捕获到的异常。
   finally 块：无论是否捕获或处理异常，finally 块里的语句都会被执行。当在 try 块或 catch 块中遇到 return 语句时，finally 语句块将在方法返回之前被执行。
   注意：不要在 finally 语句块中使用 return! 当 try 语句和 finally 语句中都有 return 语句时，try 语句块中的 return 语句会被忽略。这是因为 try 语句中的 return 返回值会先被暂存在一个本地变量中，当执行到 finally 语句中的 return 之后，这个本地变量的值就变为了 finally 语句中的 return 返回值。

4. finally 中的代码一定会执行吗？

   不一定的！在某些情况下，finally 中的代码不会被执行。

   就比如说 finally 之前虚拟机被终止运行的话，finally 中的代码就不会被执行。

try{System.out.println("Try to do something");thrownewRuntimeException("RuntimeException");}catch(Exceptione){System.out.println("Catch Exception -> "+e.getMessage());// 终止当前正在运行的Java虚拟机System.exit(1);}finally{System.out.println("Finally");}

另外，在以下 2 种特殊情况下，finally 块的代码也不会被执行： 程序所在的线程死亡。 关闭 CPU。

5. 如何使用 try-with-resources 代替try-catch-finally？

   适用范围（资源的定义）： 任何实现 java.lang.AutoCloseable或者 java.io.Closeable 的对象

关闭资源和 finally 块的执行顺序： 在 try-with-resources 语句中，任何 catch 或 finally 块在声明的资源关闭后运行
《Effective Java》中明确指出：

面对必须要关闭的资源，我们总是应该优先使用 try-with-resources 而不是try-finally。随之产生的代码更简短，更清晰，产生的异常对我们也更有用。try-with-resources语句让我们更容易编写必须要关闭的资源的代码，若采用try-finally则几乎做不到这点。 Java 中类似于InputStream、OutputStream、Scanner、PrintWriter等的资源都需要我们调用close()方法来手动关闭，一般情况下我们都是通过try-catch-finally语句来实现这个需求，如下：

6. 异常使用有哪些需要注意的地方？

   不要把异常定义为静态变量，因为这样会导致异常栈信息错乱。每次手动抛出异常，我们都需要手动 new 一个异常对象抛出。
   抛出的异常信息一定要有意义。
   建议抛出更加具体的异常，比如字符串转换为数字格式错误的时候应该抛出NumberFormatException而不是其父类IllegalArgumentException。
   避免重复记录日志：如果在捕获异常的地方已经记录了足够的信息（包括异常类型、错误信息和堆栈跟踪等），那么在业务代码中再次抛出这个异常时，就不应该再次记录相同的错误信息。重复记录日志会使得日志文件膨胀，并且可能会掩盖问题的实际原因，使得问题更难以追踪和解决。
   ……

7. 什么是泛型？有什么作用？

   编译器可以对泛型参数进行检测，并且通过泛型参数可以指定传入的对象类型。比如 ArrayList persons = new ArrayList() 这行代码就指明了该 ArrayList 对象只能传入 Person 对象，如果传入其他类型的对象就会报错。

8. 泛型的使用方式有哪几种？
   泛型一般有三种使用方式:泛型类、泛型接口、泛型方法。
   1.泛型类：

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型//在实例化泛型类时，必须指定T的具体类型publicclassGeneric<T>{privateTkey;publicGeneric(Tkey){this.key=key;}publicTgetKey(){returnkey;}}//如何实例化泛型类：Generic<Integer>genericInteger=newGeneric<Integer>(123456);

2.泛型接口：

publicinterfaceGenerator<T>{publicTmethod();}//实现泛型接口，不指定类型：classGeneratorImpl<T>implementsGenerator<T>{@OverridepublicTmethod(){returnnull;}}//实现泛型接口，指定类型：classGeneratorImplimplementsGenerator<String>{@OverridepublicStringmethod(){return"hello";}}

3.泛型方法：

publicstatic<E>voidprintArray(E[]inputArray){for(Eelement:inputArray){System.out.printf("%s ",element);}System.out.println();}//使用：// 创建不同类型数组：Integer, Double 和 CharacterInteger[]intArray={1,2,3};String[]stringArray={"Hello","World"};printArray(intArray);printArray(stringArray);

1. 项目中哪里用到了泛型？

2. 什么是反射？

   Java 反射 (Reflection) 是一种在程序运行时，动态地获取类的信息并操作类或对象（方法、属性）的能力。
   通常情况下，我们写的代码在编译时类型就已经确定了，要调用哪个方法、访问哪个字段都是明确的。但反射允许我们在运行时才去探知一个类有哪些方法、哪些属性、它的构造函数是怎样的，甚至可以动态地创建对象、调用方法或修改属性，哪怕这些方法或属性是私有的。

   正是这种在运行时“反观自身”并进行操作的能力，使得反射成为许多通用框架和库的基石。它让代码更加灵活，能够处理在编译时未知的类型。

3. 反射有什么优缺点？
   优点：

灵活性和动态性：反射允许程序在运行时动态地加载类、创建对象、调用方法和访问字段。这样可以根据实际需求（如配置文件、用户输入、注解等）动态地适应和扩展程序的行为，显著提高了系统的灵活性和适应性。
框架开发的基础：许多现代 Java 框架（如 Spring、Hibernate、MyBatis）都大量使用反射来实现依赖注入（DI）、面向切面编程（AOP）、对象关系映射（ORM）、注解处理等核心功能。反射是实现这些“魔法”功能不可或缺的基础工具。
解耦合和通用性：通过反射，可以编写更通用、可重用和高度解耦的代码，降低模块之间的依赖。例如，可以通过反射实现通用的对象拷贝、序列化、Bean 工具等。
缺点：

性能开销：反射操作通常比直接代码调用要慢。因为涉及到动态类型解析、方法查找以及 JIT 编译器的优化受限等因素。不过，对于大多数框架场景，这种性能损耗通常是可以接受的，或者框架本身会做一些缓存优化。
安全性问题：反射可以绕过 Java 语言的访问控制机制（如访问 private 字段和方法），破坏了封装性，可能导致数据泄露或程序被恶意篡改。此外，还可以绕过泛型检查，带来类型安全隐患。
代码可读性和维护性：过度使用反射会使代码变得复杂、难以理解和调试。错误通常在运行时才会暴露，不像编译期错误那样容易发现。

1. 反射的应用场景？
   很多流行的框架，比如 Spring/Spring Boot、MyBatis 等，底层都大量运用了反射机制，这才让它们能够那么灵活和强大。
   1.依赖注入与控制反转（IoC）

以 Spring/Spring Boot 为代表的 IoC 框架，会在启动时扫描带有特定注解（如 @Component, @Service, @Repository, @Controller）的类，利用反射实例化对象（Bean），并通过反射注入依赖（如 @Autowired、构造器注入等）。

2.注解处理

注解本身只是个“标记”，得有人去读这个标记才知道要做什么。反射就是那个“读取器”。框架通过反射检查类、方法、字段上有没有特定的注解，然后根据注解信息执行相应的逻辑。比如，看到 @Value，就用反射读取注解内容，去配置文件找对应的值，再用反射把值设置给字段。

3.动态代理与 AOP

想在调用某个方法前后自动加点料（比如打日志、开事务、做权限检查）？AOP（面向切面编程）就是干这个的，而动态代理是实现 AOP 的常用手段。JDK 自带的动态代理（Proxy 和 InvocationHandler）就离不开反射。代理对象在内部调用真实对象的方法时，就是通过反射的 Method.invoke 来完成的。

publicclassDebugInvocationHandlerimplementsInvocationHandler{privatefinalObjecttarget;// 真实对象publicDebugInvocationHandler(Objecttarget){this.target=target;}// proxy: 代理对象, method: 被调用的方法, args: 方法参数publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{System.out.println("切面逻辑：调用方法 "+method.getName()+" 之前");// 通过反射调用真实对象的同名方法Objectresult=method.invoke(target,args);System.out.println("切面逻辑：调用方法 "+method.getName()+" 之后");returnresult;}}

4.对象关系映射（ORM）

像 MyBatis、Hibernate 这种框架，能帮你把数据库查出来的一行行数据，自动变成一个个 Java 对象。它是怎么知道数据库字段对应哪个 Java 属性的？还是靠反射。它通过反射获取 Java 类的属性列表，然后把查询结果按名字或配置对应起来，再用反射调用 setter 或直接修改字段值。反过来，保存对象到数据库时，也是用反射读取属性值来拼 SQL。

1. 如何实现动态代理？

   动态代理是一种非常强大的设计模式，它允许我们在不修改源代码的情况下，对一个类或对象的方法进行功能增强（Enhancement）。

   在 Java 中，实现动态代理最主流的方式有两种：JDK 动态代理 和 CGLIB 动态代理。
   第一种：JDK 动态代理

Java 官方提供的，其核心要求是目标类必须实现一个或多个接口。JDK 动态代理在运行时，会利用 Proxy.newProxyInstance() 方法，动态地创建一个实现了这些接口的代理类的实例。这个代理类在内存中生成，你看不到它的 .java 或 .class 文件。

当你调用代理对象的任何一个方法时，这个调用都会被转发到我们提供的一个 InvocationHandler 接口的 invoke 方法中。在 invoke 方法里，我们就可以在调用原始方法（目标方法）之前或之后，加入我们自己的增强逻辑。

第二种：CGLIB 动态代理

CGLIB 是一个第三方的代码生成库。它的原理与 JDK 完全不同，它不要求被代理的类实现接口。它在运行时，动态生成目标类的子类作为代理类（通过 ASM 字节码操作技术）。然后，它会重写父类（也就是被代理类）中所有非 final、private 和 static 的方法。

当你调用代理对象的任何一个方法时，这个调用会被 CGLIB 的 MethodInterceptor 接口的 intercept 方法拦截。和 InvocationHandler 的 invoke 方法一样，我们可以在 intercept 方法里，在调用原始的父类方法之前或之后，加入我们的增强逻辑。

1. JDK 动态代理和 CGLIB 动态代理有什么区别？

   JDK 动态代理是官方的，它要求被代理的类必须实现接口。它的原理是动态生成一个接口的实现类来作为代理。CGLIB 是第三方的，它不需要接口。它的原理是动态生成一个被代理类的子类来作为代理。但也正因为是继承，所以它不能代理 final 的类，被代理的方法也不能是 final 或 private 。
   就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。

2. 介绍一下动态代理在框架中的实际应用场景

   动态代理最典型的应用场景就是Spring AOP。

   AOP(Aspect-Oriented Programming:面向切面编程)能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

   Spring AOP 就是基于动态代理的，如果要代理的对象，实现了某个接口，那么 Spring AOP 会使用 JDK Proxy，去创建代理对象，而对于没有实现接口的对象，就无法使用 JDK Proxy 去进行代理了，这时候 Spring AOP 会使用 Cglib 生成一个被代理对象的子类来作为代理，如下图所示：

3. 何谓注解？

   Annotation （注解） 是 Java5 开始引入的新特性，可以看作是一种特殊的注释，主要用于修饰类、方法或者变量，提供某些信息供程序在编译或者运行时使用。

注解本质是一个继承了Annotation 的特殊接口：

1. 注解的解析方法有哪几种？
   编译期直接扫描：编译器在编译 Java 代码的时候扫描对应的注解并处理，比如某个方法使用@Override 注解，编译器在编译的时候就会检测当前的方法是否重写了父类对应的方法。
   运行期通过反射处理：像框架中自带的注解(比如 Spring 框架的 @Value、@Component)都是通过反射来进行处理的。

2. SPI

   SPI 即 Service Provider Interface ，字面意思就是：“服务提供者的接口”，我的理解是：专门提供给服务提供者或者扩展框架功能的开发者去使用的一个接口。

   SPI 将服务接口和具体的服务实现分离开来，将服务调用方和服务实现者解耦，能够提升程序的扩展性、可维护性。修改或者替换服务实现并不需要修改调用方。

   很多框架都使用了 Java 的 SPI 机制，比如：Spring 框架、数据库加载驱动、日志接口、以及 Dubbo 的扩展实现等等。

3. SPI 和 API 有什么区别？
   那 SPI 和 API 有啥区别？

   说到 SPI 就不得不说一下 API（Application Programming Interface） 了，从广义上来说它们都属于接口，而且很容易混淆。下面先用一张图说明一下：

4. SPI 的优缺点？

   通过 SPI 机制能够大大地提高接口设计的灵活性，但是 SPI 机制也存在一些缺点，比如：
   需要遍历加载所有的实现类，不能做到按需加载，这样效率还是相对较低的。
   当多个 ServiceLoader 同时 load 时，会有并发问题。

5. 序列化和反序列化
   什么是序列化?什么是反序列化?
   如果我们需要持久化 Java 对象比如将 Java 对象保存在文件中，或者在网络传输 Java 对象，这些场景都需要用到序列化。

简单来说：

序列化：将数据结构或对象转换成可以存储或传输的形式，通常是二进制字节流，也可以是 JSON, XML 等文本格式
反序列化：将在序列化过程中所生成的数据转换为原始数据结构或者对象的过程

1. 序列化协议对应于 TCP/IP 4 层模型的哪一层？
   我们知道网络通信的双方必须要采用和遵守相同的协议。TCP/IP 四层模型是下面这样的，序列化协议属于哪一层呢？

应用层
传输层
网络层
网络接口层

1. 如果有些字段不想进行序列化怎么办？

   对于不想进行序列化的变量，使用 transient 关键字修饰。

   transient 关键字的作用是：阻止实例中那些用此关键字修饰的变量序列化；当对象被反序列化时，被 transient 修饰的变量值不会被持久化和恢复。

   关于 transient 还有几点注意：

   transient 只能修饰变量，不能修饰类和方法。
   transient 修饰的变量，在反序列化后变量值将会被置成类型的默认值。例如，如果是修饰 int 类型，那么反序列后结果就是 0。
   static 变量因为不属于任何对象(Object)，所以无论有没有 transient 关键字修饰，均不会被序列化。

常见序列化协议有哪些？

1. JDK 自带的序列化方式一般不会用 ，因为序列化效率低并且存在安全问题。比较常用的序列化协议有 Hessian、Kryo、Protobuf、ProtoStuff，这些都是基于二进制的序列化协议。

像 JSON 和 XML 这种属于文本类序列化方式。虽然可读性比较好，但是性能较差，一般不会选择。

1. 为什么不推荐使用 JDK 自带的序列化？
   我们很少或者说几乎不会直接使用 JDK 自带的序列化方式，主要原因有下面这些原因：

   不支持跨语言调用 : 如果调用的是其他语言开发的服务的时候就不支持了。
   性能差：相比于其他序列化框架性能更低，主要原因是序列化之后的字节数组体积较大，导致传输成本加大。
   存在安全问题：序列化和反序列化本身并不存在问题。但当输入的反序列化的数据可被用户控制，那么攻击者即可通过构造恶意输入，让反序列化产生非预期的对象，在此过程中执行构造的任意代码

2. Java IO 流了解吗？

   IO 即 Input/Output，输入和输出。数据输入到计算机内存的过程即输入，反之输出到外部存储（比如数据库，文件，远程主机）的过程即输出。数据传输过程类似于水流，因此称为 IO 流。IO 流在 Java 中分为输入流和输出流，而根据数据的处理方式又分为字节流和字符流。

Java IO 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。

InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。

1. I/O 流为什么要分为字节流和字符流呢?

   问题本质想问：不管是文件读写还是网络发送接收，信息的最小存储单元都是字节，那为什么 I/O 流操作要分为字节流操作和字符流操作呢？

个人认为主要有两点原因：

字符流是由 Java 虚拟机将字节转换得到的，这个过程还算是比较耗时；
如果我们不知道编码类型的话，使用字节流的过程中很容易出现乱码问题。

1. BIO、NIO 和 AIO 的区别？
   BIO (Blocking I/O)
   BIO 属于同步阻塞 IO 模型 。

同步阻塞 IO 模型中，应用程序发起 read 调用后，会一直阻塞，直到内核把数据拷贝到用户空间

NIO (Non-blocking/New I/O)
Java 中的 NIO 于 Java 1.4 中引入，对应 java.nio 包，提供了 Channel , Selector，Buffer 等抽象。NIO 中的 N 可以理解为 Non-blocking，不单纯是 New。它是支持面向缓冲的，基于通道的 I/O 操作方法。 对于高负载、高并发的（网络）应用，应使用 NIO 。Java 中的 NIO 可以看作是 I/O 多路复用模型。也有很多人认为，Java 中的 NIO 属于同步非阻塞 IO 模型。跟着我的思路往下看看，相信你会得到答案！我们先来看看 同步非阻塞 IO 模型。

AIO (Asynchronous I/O)
AIO 也就是 NIO 2。Java 7 中引入了 NIO 的改进版 NIO 2,它是异步 IO 模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。