java面试题详细讲解整理总结分析【java基础】

1，JDK和JRE有什么区别？

1. JRE：Java Runtime Environment（ java 运行时环境）。即java程序的运行时环境，包含了 java 虚拟机，java基础类库。
2. JDK：Java Development Kit（ java 开发工具包）。即java语言编写的程序所需的开发工具包。JDK 包含了 JRE，同时还包括 java 源码的编译器 javac、监控工具 jconsole、分析工具 jvisualvm等。

复制代码

2，==和equals的区别是什么?

1. == 是关系运算符，equals() 是方法，结果都返回布尔值
2. Object 的 == 和 equals() 比较的都是地址，作用相同
4. == 作用：
5. 基本类型，比较值是否相等
6. 引用类型，比较内存地址值是否相等
7. 不能比较没有父子关系的两个对象
9. equals()方法的作用：
10. JDK 中的类一般已经重写了 equals()，比较的是内容
11. 自定义类如果没有重写 equals()，将调用父类（默认 Object 类）的 equals() 方法，Object 的 equals() 比较使用了 this == obj
12. 可以按照需求逻辑，重写对象的 equals() 方法（重写 equals 方法，一般须重写 hashCode 方法）

复制代码

3，==和equals的区别是什么?

1. 不属于。
2. Java 中 8 种基础的数据类型：byte、short、char、int、long、float、double、boolean
3. 但是 String 类型却是最常用到的引用类型。   

复制代码

4，普通类和抽象类有哪些区别？

1. 抽象类不能被实例化
2. 抽象类可以有抽象方法，抽象方法只需申明，无需实现
3. 含有抽象方法的类必须申明为抽象类
4. 抽象类的子类必须实现抽象类中所有抽象方法，否则这个子类也是抽象类
5. 抽象方法不能被声明为静态
6. 抽象方法不能用 private 修饰
7. 抽象方法不能用 final 修饰

复制代码

5，JDK、JRE、JVM之间的关系是什么样的？

1. JDK 是 JAVA 程序开发时用的开发工具包，包含 Java 运行环境 JRE
2. JDk、JRE 内部都包含 JAVA虚拟机 JVM
3. JVM 包含 Java 应用程序的类的解释器和类加载器等

复制代码

6，讲讲面向对象三大特征

1. 封装
2. 封装：就是隐藏对象的属性和实现细节，仅对外提供公共访问方式。让使用者知道的才暴露出来，不需要让使用者知道的全部隐藏起来
3. 封装的好处：避免使用者直接操作属性值，隐藏类的实现细节；让使用者只能通过程序员规定的方法来访问数据；可以方便的加入存取控制语句，限制不合理操作，提高程序安全性。
5. 继承
6. 继承是类与类之间的关系，与现实世界中的继承（例如孩子继承父母基因）类似。
7. 继承可以理解为一个类从另一个类获取方法和属性的过程。
8. 例如：类B继承于类A，那么B就拥有A的部分方法和属性（private修饰或不在同一个包default修饰的无法访问）。
10. 3.多态
11. 多态是同一个行为具有多个不同表现形式或形态的能力。
12. 多态分类和实现
13. 编译时多态（静态多态）：方法重载实现的多态
14. 运行时多态（动态多态）：类继承/接口实现 + 重写 + 向上转型实现的多态
15. 基于继承/接口来实现的多态：面向接口的方式编程为的就是可以使用多态的特性让编程变得更加灵活。
16. 多态的优点：消除类型之间的耦合关系（可替换性，可扩充性，接口性，灵活性，简化性）

复制代码

7，什么是泛型？为什么要使用泛型？

1. 泛型：
2. "参数化类型"，将类型由具体的类型参数化，把类型也定义成参数形式（称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
3. 是 JDK 5 中引入的一个新特性，提供了编译时类型安全监测机制，该机制允许程序员在编译时监测非法的类型。
4. 泛型的本质是把参数的类型参数化，也就是所操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中。
6. 为什么要用泛型？
7. 使用泛型编写的程序代码，要比使用 Object 变量再进行强制类型转换的代码，具有更好的安全性和可读性。
8. 多种数据类型执行相同的代码使用泛型可以复用代码。
9. 比如集合类使用泛型，取出和操作元素时无需进行类型转换，避免出现 java.lang.ClassCastException 异常

复制代码

8，String、StringBuilder、StringBuffer的区别?

1. 相同点：
2. 都可以储存和操作字符串
3. 都使用 final 修饰，不能被继承
4. 提供的 API 相似
6. 区别：
7. String 是只读字符串，String 对象内容是不能被改变的
8. StringBuffer 和 StringBuilder 的字符串对象可以对字符串内容进行修改，在修改后的内存地址不会发生改变
9. StringBuilder 线程不安全；StringBuffer 线程安全
10. 方法体内没有对字符串的并发操作，且存在大量字符串拼接操作，建议使用 StringBuilder，效率较高。

复制代码

9，&和&&的作用和区别

1. &
2. 逻辑与，& 两边的表达式都会进行运算
3. 整数的位运算符
5. &&
6. 短路与，&& 左边的表达式结果为 false 时，&& 右边的表达式不参与计算

复制代码

10，说一说你的对面向过程和面向对象的理解

1.   软件开发思想，先有面向过程，后有面向对象
2.   在大型软件系统中，面向过程的做法不足，从而推出了面向对象
3.   都是解决实际问题的思维方式
4.   两者相辅相成，宏观上面向对象把握复杂事物的关系；微观上面向过程去处理
5.   面向过程以实现功能的函数开发为主；面向对象要首先抽象出类、属性及其方法，然后通过实例化类、执行方法来完成功能
6.   面向过程是封装的是功能；面向对象封装的是数据和功能
7.   面向对象具有继承性和多态性；面向过程则没有

复制代码

11，说一说你的对面向过程和面向对象的理解

1. 垃圾回收机制，简称 GC
2. Java 语言不需要程序员直接控制内存回收，由 JVM 在后台自动回收不再使用的内存
3. 提高编程效率
4. 保护程序的完整性
5. JVM 需要跟踪程序中有用的对象，确定哪些是无用的，影响性能
7. 特点
8. 回收 JVM 堆内存里的对象空间，不负责回收栈内存数据
9. 无法处理一些操作系统资源的释放，如数据库连接、输入流输出流、Socket 连接
10. 垃圾回收发生具有不可预知性，程序无法精确控制垃圾回收机制执行
11. 可以将对象的引用变量设置为 null，垃圾回收机制可以在下次执行时回收该对象。
12. JVM 有多种垃圾回收 实现算法，表现各异
13. 垃圾回收机制回收任何对象之前，会先调用对象的 finalize() 方法
14. 可以通过 System.gc() 或 Runtime.getRuntime().gc() 通知系统进行垃圾回收，会有一些效果，但系统是否进行垃圾回收依然不确定
15. 不要主动调用对象的 finalize() 方法，应该交给垃圾回收机制调用

复制代码

12，说一说你的对面向过程和面向对象的理解

1. 内存溢出(out of memory)：指程序在申请内存时，没有足够的内存空间供其使用，出现 out of memory。
2. 内存泄露(memory leak)：指程序在申请内存后，无法释放已申请的内存空间，内存泄露堆积会导致内存被占光。
3. memory leak 最终会导致 out of memory。

复制代码

13，说一说你的对面向过程和面向对象的理解

1. final 表示最终的、不可改变的。用于修饰类、方法和变量。final 修饰的类不能被继承；final 方法也同样只能使用，不能重写，但能够重载；final 修饰的成员变量必须在声明时给定初值或者在构造方法内设置初始值，只能读取，不可修改；final 修饰的局部变量必须在声明时给定初值；final 修饰的变量是非基本类型，对象的引用地址不能变，但对象的属性值可以改变
2. finally 异常处理的一部分，它只能用在 try/catch 语句中，表示希望 finally 语句块中的代码最后一定被执行（存在一些情况导致 finally 语句块不会被执行，如 jvm 结束）
3. finalize() 是在 java.lang.Object 里定义的，Object 的 finalize() 方法什么都不做，对象被回收时 finalize() 方法会被调用。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要清理工作，在垃圾收集器删除对象之前被调用的。一般情况下，此方法由JVM调用。特殊情况下，可重写 finalize() 方法，当对象被回收的时候释放一些资源，须调用 super.finalize() 。

复制代码

14，return与finally的执行顺序对返回值的影响

1. 对于 try 和 finally 至少一个语句块包含 return 语句的情况：
2. finally 语句块会执行
3. finally 没有 return，finally 对 return 变量的重新赋值修改无效
4. try 和 finally 都包含 return，return 值会以 finally 语句块 return 值为准
5. 如下面的例子

复制代码

如下面的例子

1.     public static void main(String[] args) {
2.         System.out.println(getString());
3.     }
4.            
5.     public static String getString() {
6.         String str = "A";
7.         try {
8.             str = "B";
9.             return str;
10.         } finally {
11.             System.out.println("finally change return string to C");
12.             str = "C";
13.         }
14.     }

复制代码

打印

1.     finally change return string to C
2.     B

复制代码

finally 语句块中新增 return 语句

1.      public static void main(String[] args) {
2.          System.out.println(getString());
3.      }
4.      
5.      public static String getString() {
6.          String str = "A";
7.          try {
8.              str = "B";
9.              return str;
10.          } finally {
11.              System.out.println("finally change return string to C");
12.              str = "C";
13.              return str;
14.          }
15.      }

复制代码

打印结果

1.     finally change return string to C
2.     C

复制代码

15，Math.round(-1.5) 等于多少？

1. 运行结果： -1
3. JDK 中的 java.lang.Math 类
4. ceil() ：向上取整，返回小数所在两整数间的较大值，返回类型是 double，如 -1.5 返回 -1.0
5. floor() ：向下取整，返回小数所在两整数间的较小值，返回类型是 double，如 -1.5 返回 -2.0
6. round() ：朝正无穷大方向返回参数最接近的整数，可以换算为 参数 + 0.5 向下取整，返回值是 int 或 long，如 -1.5 返回 -1

复制代码

16，抽象类能使用final修饰吗？

1. 不能，抽象类是被用于继承的，final修饰代表不可修改、不可继承的。

复制代码

17，抽象类能使用final修饰吗？

1. throw：
2. 表示方法内抛出某种异常对象(只能是一个)
3. 用于程序员自行产生并抛出异常
4. 位于方法体内部，可以作为单独语句使用
5. 如果异常对象是非 RuntimeException 则需要在方法申明时加上该异常的抛出，即需要加上 throws 语句 或者 在方法体内 try catch 处理该异常，否则编译报错
6. 执行到 throw 语句则后面的语句块不再执行
8. throws：
9. 方法的定义上使用 throws 表示这个方法可能抛出某些异常(可以有多个)
10. 用于声明在该方法内抛出了异常
11. 必须跟在方法参数列表的后面，不能单独使用
12. 需要由方法的调用者进行异常处理

复制代码

18，动态代理是什么？应用场景？

1. 动态代理：在运行时，创建目标类，可以调用和扩展目标类的方法。
2. Java 中实现动态的方式：
3. JDK 中的动态代理
4. Java类库 CGLib
6. 应用场景：
7. 统计每个 api 的请求耗时
8. 统一的日志输出
9. 校验被调用的 api 是否已经登录和权限鉴定
10. Spring的 AOP 功能模块就是采用动态代理的机制来实现切面编程

复制代码

19，动态代理是什么？应用场景？

1. final 语义是不可改变的。
2. 被 final 修饰的类，不能够被继承
3. 被 final 修饰的成员变量必须要初始化，赋初值后不能再重新赋值(可以调用对象方法修改属性值)。对基本类型来说是其值不可变；对引用变量来说其引用不可变，即不能再指向其他的对象
4. 被 final 修饰的方法不能重写

复制代码

20，finally语句块一定执行吗？

1. 答案是不一定。存在很多特殊情况导致 finally 语句块不执行。如：
2. 直接返回未执行到 try-finally 语句块
3. 抛出异常未执行到 try-finally 语句块
4. 系统退出未执行到 finally 语句块

复制代码

21，String属于基础的数据类型吗？

1. 不属于。
2. Java 中 8 种基础的数据类型：byte、short、char、int、long、float、double、boolean
3. 但是 String 类型却是最常用到的引用类型。

复制代码

22，面向对象和面向过程的区别？

1. 面向过程：
2. 优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
3. 缺点：没有面向对象易维护、易复用、易扩展。
5. 面向对象：
6. 优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护。
7. 缺点：性能比面向过程低。

复制代码

23，面向对象和面向过程的区别？

1. 方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。
2. 重写发生在子类与父类之间, 重写方法返回值和形参都不能改变，与方法返回值和访问修饰符无关，即重载的方法不能根据返回类型进行区分。即外壳不变，核心重写！
3. 重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。最常用的地方就是构造器的重载。

复制代码

24，抽象类和接口的区别是什么？

1. 语法层面上的区别：
2. 抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；
3. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；
4. 接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；
5. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
7. 设计层面上的区别：
8. 抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。
9. 设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。

复制代码

25，java 创建对象有哪几种方式？

1. java中提供了以下四种创建对象的方式:
2. new创建新对象
3. 通过反射机制
4. 采用clone机制
5. 通过序列化机制
6. 前两者都需要显式地调用构造方法。对于clone机制,需要注意浅拷贝和深拷贝的区别，对于序列化机制需要明确其实现原理，在java中序列化可以通过实现Externalizable或者Serializable来实现。

复制代码

26，为什么重写 equals 方法必须重写 hashcode 方法 ？

1. 判断的时候先根据hashcode进行的判断，相同的情况下再根据equals()方法进行判断。如果只重写了equals方法，而不重写hashcode的方法，会造成hashcode的值不同，而equals()方法判断出来的结果为true。
2. 在Java中的一些容器中，不允许有两个完全相同的对象，插入的时候，如果判断相同则会进行覆盖。这时候如果只重写了equals（）的方法，而不重写hashcode的方法，Object中hashcode是根据对象的存储地址转换而形成的一个哈希值。这时候就有可能因为没有重写hashcode方法，造成相同的对象散列到不同的位置而造成对象的不能覆盖的问题。

复制代码

27，包装类型是什么？基本类型和包装类型有什么区别？

1. Java 为每一个基本数据类型都引入了对应的包装类型（wrapper class），int 的包装类就是 Integer，从 Java 5 开始引入了自动装箱/拆箱机制，把基本类型转换成包装类型的过程叫做装箱（boxing）；反之，把包装类型转换成基本类型的过程叫做拆箱（unboxing），使得二者可以相互转换。
2. Java 为每个原始类型提供了包装类型：
3. 原始类型: boolean，char，byte，short，int，long，float，double
4. 包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double
6. 基本类型和包装类型的区别主要有以下 几点：
7. 包装类型可以为 null，而基本类型不可以。它使得包装类型可以应用于 POJO 中，而基本类型则不行。那为什么 POJO 的属性必须要用包装类型呢？《阿里巴巴 Java 开发手册》上有详细的说明， 数据库的查询结果可能是 null，如果使用基本类型的话，因为要自动拆箱（将包装类型转为基本类型，比如说把 Integer 对象转换成 int 值），就会抛出 NullPointerException 的异常。
8. 包装类型可用于泛型，而基本类型不可以。泛型不能使用基本类型，因为使用基本类型时会编译出错。
9. List<int> list = new ArrayList<>(); // 提示 Syntax error, insert "Dimensions" to complete ReferenceType
10. List<Integer> list = new ArrayList<>();
11. 因为泛型在编译时会进行类型擦除，最后只保留原始类型，而原始类型只能是 Object 类及其子类——基本类型是个特例。
12. 基本类型比包装类型更高效。基本类型在栈中直接存储的具体数值，而包装类型则存储的是堆中的引用。 很显然，相比较于基本类型而言，包装类型需要占用更多的内存空间。

复制代码

28，int 和 Integer 有什么区别?

1. Integer是int的包装类；int是基本数据类型；
2. Integer变量必须实例化后才能使用；int变量不需要；
3. Integer实际是对象的引用，指向此new的Integer对象；int是直接存储数据值 ；
4. Integer的默认值是null；int的默认值是0。   

复制代码

29，什么是反射？反射机制的优缺点有哪些？

1. 反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 Java 语言的反射机制。
2. 优点：能够运行时动态获取类的实例，提高灵活性；可与动态编译结合Class.forName('com.mysql.jdbc.Driver.class');，加载MySQL的驱动类。
3. 缺点：使用反射性能较低，需要解析字节码，将内存中的对象进行解析。其解决方案是：通过setAccessible(true)关闭JDK的安全检查来提升反射速度；多次创建一个类的实例时，有缓存会快很多；ReflflectASM工具类，通过字节码生成的方式加快反射速度。

复制代码

30，Java反射API有几类？

1. 反射 API 用来生成 JVM 中的类、接口或则对象的信息。
2. Class 类：反射的核心类，可以获取类的属性，方法等信息。
3. Field 类：Java.lang.reflec 包中的类，表示类的成员变量，可以用来获取和设置类之中的属性值。
4. Method 类：Java.lang.reflec 包中的类，表示类的方法，它可以用来获取类中的方法信息或者执行方法。
5. Constructor 类：Java.lang.reflec 包中的类，表示类的构造方法。

复制代码

31，Java序列化与反序列化是什么？

1. Java序列化是指把Java对象转换为字节序列的过程，而Java反序列化是指把字节序列恢复为Java对象的过程：
2. 序列化：序列化是把对象转换成有序字节流，以便在网络上传输或者保存在本地文件中。核心作用是对象状态的保存与重建。我们都知道，Java对象是保存在JVM的堆内存中的，也就是说，如果JVM堆不存在了，那么对象也就跟着消失了。
3. 而序列化提供了一种方案，可以让你在即使JVM停机的情况下也能把对象保存下来的方案。就像我们平时用的U盘一样。把Java对象序列化成可存储或传输的形式（如二进制流），比如保存在文件中。这样，当再次需要这个对象的时候，从文件中读取出二进制流，再从二进制流中反序列化出对象。
4. 反序列化：客户端从文件中或网络上获得序列化后的对象字节流，根据字节流中所保存的对象状态及描述信息，通过反序列化重建对象。

复制代码

32，为什么需要序列化与反序列化？

1. 简要描述：对内存中的对象进行持久化或网络传输, 这个时候都需要序列化和反序列化
2. 深入描述：
3. 对象序列化可以实现分布式对象。
4. 主要应用例如：RMI(即远程调用Remote Method Invocation)要利用对象序列化运行远程主机上的服务，就像在本地机上运行对象时一样。
5. java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。
6. 可以将整个对象层次写入字节流中，可以保存在文件中或在网络连接上传递。利用对象序列化可以进行对象的"深复制"，即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。
7. 序列化可以将内存中的类写入文件或数据库中。
8. 比如：将某个类序列化后存为文件，下次读取时只需将文件中的数据反序列化就可以将原先的类还原到内存中。也可以将类序列化为流数据进行传输。
9. 总的来说就是将一个已经实例化的类转成文件存储，下次需要实例化的时候只要反序列化即可将类实例化到内存中并保留序列化时类中的所有变量和状态。
10. 对象、文件、数据，有许多不同的格式，很难统一传输和保存。
11. 序列化以后就都是字节流了，无论原来是什么东西，都能变成一样的东西，就可以进行通用的格式传输或保存，传输结束以后，要再次使用，就进行反序列化还原，这样对象还是对象，文件还是文件。

复制代码

33，为什么需要序列化与反序列化？

1. java.lang.IllegalAccessError：违法访问错误。当一个应用试图访问、修改某个类的域（Field）或者调用其方法，但是又违反域或方法的可见性声明，则抛出该异常。
2. java.lang.InstantiationError：实例化错误。当一个应用试图通过Java的new操作符构造一个抽象类或者接口时抛出该异常.
3. java.lang.OutOfMemoryError：内存不足错误。当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误。
4. java.lang.StackOverflowError：堆栈溢出错误。当一个应用递归调用的层次太深而导致堆栈溢出或者陷入死循环时抛出该错误。
5. java.lang.ClassCastException：类造型异常。假设有类A和B（A不是B的父类或子类），O是A的实例，那么当强制将O构造为类B的实例时抛出该异常。该异常经常被称为强制类型转换异常。
6. java.lang.ClassNotFoundException：找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。
7. java.lang.ArithmeticException：算术条件异常。譬如：整数除零等。
8. java.lang.ArrayIndexOutOfBoundsException：数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
9. java.lang.IndexOutOfBoundsException：索引越界异常。当访问某个序列的索引值小于0或大于等于序列大小时，抛出该异常。
10. java.lang.InstantiationException：实例化异常。当试图通过newInstance()方法创建某个类的实例，而该类是一个抽象类或接口时，抛出该异常。
11. java.lang.NoSuchFieldException：属性不存在异常。当访问某个类的不存在的属性时抛出该异常。
12. java.lang.NoSuchMethodException：方法不存在异常。当访问某个类的不存在的方法时抛出该异常。
13. java.lang.NullPointerException：空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。
14. java.lang.NumberFormatException：数字格式异常。当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常。
15. java.lang.StringIndexOutOfBoundsException：字符串索引越界异常。当使用索引值访问某个字符串中的字符，而该索引值小于0或大于等于序列大小时，抛出该异常。

复制代码

34，try-catch-finally 中哪个部分可以省略？

1. catch 可以省略。更为严格的说法其实是：try只适合处理运行时异常，try+catch适合处理运行时异常+普通异常。也就是说，如果你只用try去处理普通异常却不加以catch处理，编译是通不过的，因为编译器硬性规定，普通异常如果选择捕获，则必须用catch显示声明以便进一步处理。而运行时异常在编译时没有如此规定，所以catch可以省略，你加上catch编译器也觉得无可厚非。
2. 理论上，编译器看任何代码都不顺眼，都觉得可能有潜在的问题，所以你即使对所有代码加上try，代码在运行期时也只不过是在正常运行的基础上加一层皮。但是你一旦对一段代码加上try，就等于显示地承诺编译器，对这段代码可能抛出的异常进行捕获而非向上抛出处理。如果是普通异常，编译器要求必须用catch捕获以便进一步处理；如果运行时异常，捕获然后丢弃并且+finally扫尾处理，或者加上catch捕获以便进一步处理。
3. 至于加上finally，则是在不管有没捕获异常，都要进行的“扫尾”处理。

复制代码

35，JVM 是如何处理异常的？

1. 在一个方法中如果发生异常，这个方法会创建一个异常对象，并转交给 JVM，该异常对象包含异常名称，异常描述以及异常发生时应用程序的状态。创建异常对象并转交给 JVM 的过程称为抛出异常。可能有一系列的方法调用，最终才进入抛出异常的方法，这一系列方法调用的有序列表叫做调用栈。
2. JVM 会顺着调用栈去查找看是否有可以处理异常的代码，如果有，则调用异常处理代码。当 JVM 发现可以处理异常的代码时，会把发生的异常传递给它。如果 JVM 没有找到可以处理该异常的代码块，JVM 就会将该异常转交给默认的异常处理器（默认处理器为 JVM 的一部分），默认异常处理器打印出异常信息并终止应用程序。   

复制代码

36，Java的IO 流分为几种？

1. 按照流的方向：输入流（inputStream）和输出流（outputStream）；
2. 按照实现功能分：节点流（可以从或向一个特定的地方读写数据，如 FileReader）和处理流（是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写， BufferedReader）；
3. 按照处理数据的单位： 字节流和字符流。分别由四个抽象类来表示（每种流包括输入和输出两种所以一共四个）:InputStream，OutputStream，Reader，Writer。Java中其他多种多样变化的流均是由它们派生出来的。

复制代码

37，字节流如何转为字符流？

1. 字节输入流转字符输入流通过 InputStreamReader 实现，该类的构造函数可以传入 InputStream 对象。
2. 字节输出流转字符输出流通过 OutputStreamWriter 实现，该类的构造函数可以传入 OutputStream 对象。

复制代码

38，字符流与字节流的区别？

1. 读写的时候字节流是按字节读写，字符流按字符读写。
2. 字节流适合所有类型文件的数据传输，因为计算机字节（Byte）是电脑中表示信息含义的最小单位。字符流只能够处理纯文本数据，其他类型数据不行，但是字符流处理文本要比字节流处理文本要方便。
3. 在读写文件需要对内容按行处理，比如比较特定字符，处理某一行数据的时候一般会选择字符流。
4. 只是读写文件，和文件内容无关时，一般选择字节流。

复制代码

39，BIO、NIO、AIO的区别？

1. BIO：同步并阻塞，在服务器中实现的模式为一个连接一个线程。也就是说，客户端有连接请求的时候，服务器就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然这也可以通过线程池机制改善。BIO一般适用于连接数目小且固定的架构，这种方式对于服务器资源要求比较高，而且并发局限于应用中，是JDK1.4之前的唯一选择，但好在程序直观简单，易理解。
2. NIO：同步并非阻塞，在服务器中实现的模式为一个请求一个线程，也就是说，客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到有连接IO请求时才会启动一个线程进行处理。NIO一般适用于连接数目多且连接比较短（轻操作）的架构，并发局限于应用中，编程比较复杂，从JDK1.4开始支持。
3. AIO：异步并非阻塞，在服务器中实现的模式为一个有效请求一个线程，也就是说，客户端的IO请求都是通过操作系统先完成之后，再通知服务器应用去启动线程进行处理。AIO一般适用于连接数目多且连接比较长（重操作）的架构，充分调用操作系统参与并发操作，编程比较复杂，从JDK1.7开始支持。

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！