Java基础面试题（5.14）

1.Java语言的特点？

1.一面向对象（封装，继承，多态）；2.平台无关性（ Java 虚拟机实现平台无关性）；(类是一种定义对象的蓝图或模板)3.支持多线程（ C++ 语言没有内置的多线程机制，因此必须调用操作系统的多线程功能来进行多线程程序设计，而 Java 语言却提供了多线程支持）； 4.可靠性（具备异常处理和自动内存管理机制）5.安全性（Java 语言本身的设计就提供了多重安全防护机制如访问权限修饰符、限制程序直接访问操作系统资源）； 6.高效性（通过 Just In Time 编译器等技术的优化，Java 语言的运行效率还是非常不错的）；7.支持网络编程并且很方便；8.编译与解释并存；

(类是一种定义对象的蓝图或模板)

2.Java与C++的区别

1.Java 不提供指针来直接访问内存，程序内存更加安全。

2.Java 的类是单继承的，C++ 支持多重继承；

3.虽然 Java 的类不可以多继承，但是接口可以多继承。

4.虽然，Java 和 C++ 都是面向对象的语言，都支持封装、继承和多态，但是，它们还是有挺多不相同的地方：Java 有自动内存管理垃圾回收机制(GC)，不需要程序员手动释放无用内存。

5.C ++同时支持方法重载和操作符重载，但是 Java 只支持方法重载（操作符重载增加了复杂性，这与 Java 最初的设计思想不符）。

3.请你说说Java的特点和优点,为什么要选择Java？

（回答Java与C++的区别,Java的特点优点）1.Java是一门面向对象的编程语言,它在拥有C++语言的各种优点的同时还拥有一些其他优秀的功能。其在保证了强大的功能性的基础上,还比C++语言更为简单易用。 2.Java还拥有平台无关性,可以做到"一次编译,到处运行"。 3.java还提供了很多内置的类库,通过这些类库,简化了开发人员的程序设计工作,缩短了项目的开发时间, 4.最重要的是Java提供了垃圾回收器,不需要开发人员手动管理内存， 5.同时Java拥有良好的安全性， 6.此外,Java还支持网络编程，提供了对Web应用开发的支持：例如Applet、Servlet和JSP可以用来开发Web应用程序；Socket、RMI可以用来开发分布式应用程序的类库。

4.介绍JDK，JRE，JVM，以及java的三个版本

Java SE: Java 平台标准版，Java 编程语言的基础，它包含了支持 Java 应用程序开发和运行的核心类库以及虚拟机等核心组件。Java SE 可以用于构建桌面应用程序或简单的服务器应用程序。

Java EE：Java 平台企业版，建立在 Java SE 的基础上，包含了支持企业级应用程序开发和部署的标准和规范（比如 Servlet、JSP、EJB、JDBC、JPA、JTA、JavaMail、JMS）。 Java EE 可以用于构建分布式、可移植、健壮、可伸缩和安全的服务端 Java 应用程序，例如 Web 应用程序。（简单来说，Java SE 是 Java 的基础版本，Java EE 是 Java 的高级版本。Java SE 更适合开发桌面应用程序或简单的服务器应用程序，Java EE 更适合开发复杂的企业级应用程序或 Web 应用程序。）

Java ME 是 Java 的微型版本，主要用于开发嵌入式消费电子设备的应用程序，例如手机、PDA、机顶盒、冰箱、空调等。Java ME 无需重点关注，知道有这个东西就好了，现在已经用不上了

JDK(java开发工具包)，它是功能齐全的 Java SDK，是提供给开发者使用，能够创建和编译 Java 程序的开发套件。它包含了 JRE，同时还包含了编译 java 源码的编译器 javac 以及一些其他工具比如 javadoc（文档注释工具）、jdb（调试器）、jconsole（基于 JMX 的可视化监控⼯具）、javap（反编译工具）等等。

JRE 是 Java 运行时环境。它是运行已编译 Java 程序所需的所有内容的集合，主要包括 Java 虚拟机（JVM）、Java 基础类库（Class Library）。

Java 虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译，随处可以运行”的关键所在。

5.为什么说Java语言编译与解释并存？

这是因为 Java 语言既具有编译型语言的特征，也具有解释型语言的特征。因为 Java 程序要经过先编译，后解释两个步骤，由 Java 编写的程序需要先经过编译步骤，生成字节码（.class 文件），这种字节码必须由 Java 解释器来解释执行。

高级语言的编译运行方式都是: 编程{编写代码文件}，编译{将代码转化为机器语言的过程}，运行{让机器执行编译后的指令}

我们可以将高级编程语言按照程序的执行方式分为两种：

解释型会通过一句一句的将代码解释（interpret）为机器代码后再执行。解释型语言开发效率比较快，执行速度比较慢。常见的解释性语言有 Python、JavaScript、PHP 等等。（{不产生一个新文件}而是读一行解释一行）

编译型会通过将源代码一次性翻译成可被该平台执行的机器码。一般情况下，编译语言的执行速度比较快，开发效率比较低。常见的编译性语言有 C、C++、Go、Rust 等等。（一次编译完）

java先整体编译成字节码文件，然后再按行交给设备运行(在虚拟机中运行)

6.什么是字节码？采用字节码的好处是什么？

在 Java 中，JVM 可以理解的代码就叫做字节码（即扩展名为 .class 的文件），它不面向任何特定的处理器，只面向虚拟机。Java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以， Java 程序运行时相对来说还是高效的（不过，和 C、 C++，Rust，Go 等语言还是有一定差距的），而且，由于字节码并不针对一种特定的机器，因此，Java 程序无须重新编译便可在多种不同操作系统的计算机上运行。

7.Java的几种基本数据类型了解吗？

• Java 中有 8 种基本数据类型，分别为：1 种字符类型：char
• 6 种数字类型：4 种整数型：byte、short、int、long2 种浮点型：float、double
• 1 种布尔型：boolean。

8.比较一下包装类型和基本数据类型？

1.用途：除了定义一些常量和局部变量之外，我们在其他地方比如方法参数、对象属性中很少会使用基本类型来定义变量。并且，包装类型可用于泛型，而基本类型不可以。

2.存储方式：基本数据类型的局部变量存放在 Java 虚拟机栈中的局部变量表中，基本数据类型的成员变量（未被 static 修饰 ）存放在 Java 虚拟机的堆中。包装类型属于对象类型，我们知道几乎所有对象实例都存在于堆中。

3.占用空间：相比于包装类型（对象类型）， 基本数据类型占用的空间往往非常小。

4.默认值：成员变量包装类型不赋值就是 null ，而基本类型有默认值且不是 null。

5.比较方式：对于基本数据类型来说，== 比较的是值。对于包装数据类型来说，== 比较的是对象的内存地址。所有整型包装类对象之间值的比较，全部使用 equals() 方法。

小问：int 和 Integer 哪个会占用更多的内存？

Integer 对象会占用更多的内存，Integer 是一个对象，需要存储对象的元数据，但是 int 是一个基本数据类型的数据，所以占用的空间更少。

int 本身没有空值，定义出来时候初始值为 0，但是在数据库操作的时候，有可能数据的值是空的，因此封装为 Integer，它允许有 null 值。

9.基本数据类型是否都放在了栈中？

基本数据类型的存储位置取决于它们的作用域和声明方式。如果它们是局部变量，那么它们会存放在栈中；如果它们是成员变量，那么它们会存放在堆中

10.包装类型的缓存机制了解吗？

Java 基本数据类型的包装类型的大部分都用到了缓存机制来提升性能。

Byte,Short,Integer,Long 这 4 种包装类默认创建了数值 [-128，127] 的相应类型的缓存数据，Character 创建了数值在 [0,127] 范围的缓存数据，Boolean 直接返回 True or False。

Integer这些包装类型内部维护了一个IntegerCache（这种机制），它缓存了-128~127的数值对应的Integer类型，一旦程序调用了valueOf（）方法，若数值是在-128到127之间，就会直接从cache里面去获取Integer对象，否则就会去创建一个新的对象，所以在缓存机制内的用的其实是同一个对象实例。

11.介绍一下自动拆箱和装箱？

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

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

得分点 包装类的作用,应用场景 
1、自动装箱、自动拆箱是JDK1.5提供的功能。
2、自动装箱：把一个基本类型的数据直接赋值给对应的包装类型；
3、自动拆箱是指把一个包装类型的对象直接赋值给对应的基本类型；
4、通过自动装箱、自动拆箱功能,简化基本类型变量和包装类对象之间的转换过程

12.为什么浮点数运算的时候会有精度丢失的风险？

为什么会出现这个问题呢？

这个和计算机保存浮点数的机制有很大关系。我们知道计算机是二进制的，而且计算机在表示一个数字时，宽度是有限的，无限循环的小数存储在计算机时，只能被截断，所以就会导致小数精度发生损失的情况。这也就是解释了为什么浮点数没有办法用二进制精确表示。

13.面向对象和面向过程的区别：

两者的主要区别在于解决问题的方式不同：

面向过程把解决问题的过程拆成一个个方法，通过一个个方法的执行解决问题。（性能比面向对象高，可维护性差）

面向对象会先抽象出对象，然后用对象执行方法的方式解决问题。（易维护、易复用、易扩展，性能比面向过程低。）

14.创建一个对象用什么运算符？对象实体与对象引用的不同？

new 运算符，new 创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）

再问：Java 创建对象有哪几种方式？

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

15.对象相等和引用相等有什么区别：

引用相等一般比较的是他们指向的内存地址是否相等。

对象的相等一般比较的是内存中存放的内容是否相等。

16.如果一个类没有声明构造方法，改程序还能正确执行吗？

如果一个类没有声明构造方法，也可以执行！因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。如果我们自己添加了类的构造方法（无论是否有参），Java 就不会添加默认的无参数的构造方法了。（构造方法是一种特殊的方法，主要作用是完成对象的初始化工作）

17.构造方法有哪些特点，可否被override？

构造方法特点如下：1.名字与类名相同。2.没有返回值，但不能用 void 声明构造函数。

3.生成类的对象时自动执行，无需调用。

构造方法不能被 override（重写）,但是可以 overload（重载）,所以你可以看到一个类中有多个构造函数的情况。

18.说说你对面向对象的理解？（封装、继承、多态。）

封装：封装是指将对象的状态信息隐藏在对象内部,不允许外部程序直接访问对象内部信息,让外部程序通过该类提供的方法来实现对内部信息的操作和访问,这种做法有助于规范使用者的行为,让使用者只能通过事先预定的方法访问数据,提高了代码的可维护性；

继承：其中,继承是面向对象实现代码复用的重要手段,Java通过extends作为关键字实现类的继承,实现继承的类被称为子类,被继承的类称为父类（继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承，可以快速地创建新的类，可以提高代码的重用，程序的可维护性）

多态：多态的实现离不开继承,在设计程序时,我们可以将参数的类型定义为父类型。在调用程序时,则可以根据实际情况,传入该父类型的某个子类型的实例,这样就实现了多态。

继承特点：

• 子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问，只是拥有。
• 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。

多态特点：

• 对象类型和引用类型之间具有继承（类）/实现（接口）的关系；
• 引用类型变量发出的方法调用的到底是哪个类中的方法，必须在程序运行期间才能确定；
• 多态不能调用“只在子类存在但在父类不存在”的方法；
• 如果子类重写了父类的方法，真正执行的是子类重写的方法，如果子类没有重写父类的方法，执行的是父类的方法。

19.获取一个类对象的几种方式？

通过类对象的 getClass() 方法获取，即 A.getClass().
通过类的静态成员表示，每个类都有隐含的静态成员 class，即 A.class.
通过 Class 类的静态方法 forName() 方法获取，即 Class.forName().
通过类加载器 xxxClassLoader.loadClass() 传入类路径获取

20.接口和抽象类有什么区别？

共同点：

• 都不能被实例化。
• 都可以包含抽象方法。
• 都可以有默认实现的方法

区别：

• 接口主要用于对类的行为进行约束，你实现了某个接口就具有了对应的行为。抽象类主要用于代码复用，强调的是所属关系。
• 一个类只能继承一个类，但是可以实现多个接口。
• 接口中的成员变量只能是 public static final 类型的，不能被修改且必须有初始值，而抽象类的成员变量默认 default，可在子类中被重新定义，也可被重新赋值。

21.什么是浅拷贝与深拷贝？有什么区别？

• 浅拷贝：浅拷贝会在堆上创建一个新的对象（区别于引用拷贝的一点），不过，如果原对象内部的属性是引用类型的话，浅拷贝会直接复制内部对象的引用地址，也就是说拷贝对象和原对象共用同一个内部对象。
• 深拷贝：深拷贝会完全复制整个对象，包括这个对象所包含的内部对象。

顺便一提：引用拷贝，就是指两个不同的引用指向同一个对象。

22.Java 中的自动类型转换

自动类型转换遵循下面的规则：

若参与运算的数据类型不同，则先转换成同一类型，然后进行运算
转换按数据长度增加的方向进行，以保证精度不降低。例如 int 型和 long 型运算时，先把 int 型转成 long 型后再进行运算
所有的浮点运算都是以双精度进行的，即使仅含 float 单精度量运算的表达式，也要先转换成 double 型，再做运算
char 型和 short 型参与运算时，必须先转换成 int 型。

23.==和equals的区别？

1.== 对于基本类型和引用类型的作用效果是不同的：对于基本数据类型来说，== 比较的是值。对于引用数据类型来说，== 比较的是对象的内存地址。

2.equals() 不能用于判断基本数据类型的变量，只能用来判断两个对象是否相等。equals()方法存在于Object类中，而Object类是所有类的直接或间接父类，因此所有的类都有equals()方法因为 Java 只有值传递，所以，对于 == 来说，不管是比较基本数据类型，还是引用数据类型的变量，其本质比较的都是值，只是引用类型变量存的值是对象的地址。

（总的来说，对于引用类型，==比较的是内存地址，equals比较的是值）

24.引用类型与包装类型的关系？

引用类型不仅限于包装类型。

引用类型是Java中的一种数据类型，它包括了所有的对象类型，如数组、类实例、接口实例等。包装类型只是引用类型的一个子集，它们为Java的八种基本数据类型提供了对应的对象表示，使得基本数据类型可以拥有对象的特性，如能够被赋值给变量、作为方法参数传递、存储在对象集合中等。

具体来说，Java中的引用类型包括：

1. 数组：无论是基本数据类型的数组还是对象的数组，都是引用类型。
2. 类实例：通过new关键字创建的对象，如自定义类的实例或内置类（如String）的实例。
3. 接口实例：实现了某个接口的类的实例。
4. 包装类型：与基本数据类型对应的包装类，如Integer、Double等。

需要注意的是，引用类型在参数传递时是按引用传递的，这意味着当传递一个对象作为方法参数时，方法内部对这个对象的修改会影响到原始对象。这与基本数据类型的按值传递形成对比，基本数据类型的按值传递意味着方法内部对参数的修改不会影响原始值。

25.equals() 方法存在两种使用情况

类没有重写 equals()方法：通过equals()比较该类的两个对象时，等价于通过“==”比较这两个对象，使用的默认是 Object类equals()方法。

类重写了 equals()方法：一般我们都重写 equals()方法来比较两个对象中的属性是否相等；若它们的属性相等，则返回 true(即，认为这两个对象相等)。

26.HashCode的作用？

hashCode() 的作用是获取哈希码（int 整数），也称为散列码。这个哈希码的作用是确定该对象在哈希表中的索引位置。

hashCode() 定义在 JDK 的 Object 类中，这就意味着 Java 中的任何类都包含有 hashCode() 函数。另外需要注意的是：Object 的 hashCode() 方法是本地方法，也就是用 C 语言或 C++ 实现的。

27.为什么要有HashCode？

这个问题以Hash Set为例，

当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashCode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashCode 值作比较，如果没有相符的 hashCode，HashSet 会假设对象没有重复出现。但是如果发现有相同 hashCode 值的对象，这时会调用 equals() 方法来检查 hashCode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。

再问：hashCode() 和 equals()都是用于比较两个对象是否相等。那为什么 JDK 还要同时提供这两个方法呢？

这是因为在一些容器（比如 HashMap、HashSet）中，有了 hashCode() 之后，判断元素是否在对应容器中的效率会更高，

前面也提到了添加元素进HashSet的过程，如果 HashSet 在对比的时候，同样的 hashCode 有多个对象，它会继续使用 equals() 来判断是否真的相同。也就是说 hashCode 帮助我们大大缩小了查找成本。

再问：那为什么不只提供 hashCode() 方法呢？

这是因为两个对象的hashCode 值相等并不代表两个对象就相等。

再问：那为什么两个对象有相同的 hashCode 值，它们也不一定是相等的？

因为 hashCode() 所使用的哈希算法也许刚好会让多个对象传回相同的哈希值。越糟糕的哈希算法越容易碰撞，但这也与数据值域分布的特性有关（所谓哈希碰撞也就是指的是不同的对象得到相同的 hashCode )。

总的来说就是：

如果两个对象的hashCode 值相等，那这两个对象不一定相等（哈希碰撞）。

如果两个对象的hashCode 值相等并且equals()方法也返回 true，我们才认为这两个对象相等。

如果两个对象的hashCode 值不相等，我们就可以直接认为这两个对象不相等

28.为什么重写equals就必须重写hashCode方法？

因为两个相等的对象的 hashCode 值必须是相等。也就是说如果 equals 方法判断两个对象是相等的，那这两个对象的 hashCode 值也要相等。

如果重写 equals() 时没有重写 hashCode() 方法的话就可能会导致 equals 方法判断是相等的两个对象，hashCode 值却不相等。（这也就将导致两个相同的对象同时出现在HashSet中的情况）

思考：重写 equals() 时没有重写 hashCode() 方法的话，使用 HashMap 可能会出现什么问题。总结：equals 方法判断两个对象是相等的，那这两个对象的 hashCode 值也要相等。两个对象有相同的 hashCode 值，他们也不一定是相等的（哈希碰撞）。

29.String、StringBuffer 和 StringBuilder 区别及使用场景？

1.可变性：

String 是不可变的（String 类底层使用 final 关键字修饰的字符数组来保存字符串，private final char value[]，所以 String 对象是不可变的。）。

StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串，不过没有使用 final 和 private 关键字修饰，最关键的是这个 AbstractStringBuilder 类还提供了很多修改字符串的方法比如 append 方法

2.线程安全性

String 中的对象是不可变的，也就可以理解为常量，线程安全。

AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。

StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。

3.性能

每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。

StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。

操作少量的数据:

适用 String对于三者使用的总结：

单线程操作字符串缓冲区下操作大量数据: 适用 StringBuilder

多线程操作字符串缓冲区下操作大量数据: 适用 StringBuffer

想要效率就优先使用 StringBuilder，多线程使用共享变量时使用 StringBuffer.

30.String为什么是不可变的？

我们知道被 final 关键字修饰的类不能被继承，修饰的方法不能被重写，修饰的变量是基本数据类型则值不能改变，修饰的变量是引用类型则不能再指向其他对象。因此，final 关键字修饰的数组保存字符串并不是 String 不可变的根本原因，因为这个数组保存的字符串是可变的（final 修饰引用类型变量的情况）。

String 真正不可变有下面几点原因：

保存字符串的数组被 final 修饰且为私有的，并且String 类没有提供/暴露修改这个字符串的方法。String 类被 final 修饰导致其不能被继承，进而避免了子类破坏 String 不可变。

之所以要把 String 类设计为不可变类，主要是出于安全和性能的考虑，可归纳为如下三点：

字符串通常会用来存储敏感信息（如账号，密码等），保证字符串 String 类的安全性就尤为重要了，如果字符串是可变的，容易被篡改，那我们就无法保证使用字符串进行操作时，它是安全的，很有可能出现 SQL 注入，访问危险文件等操作。

在多线程中，只有不变的对象和值是线程安全的，可以在多个线程中共享数据。由于 String 天然的不可变，当一个线程”修改“了字符串的值，只会产生一个新的字符串对象，不会对其他线程的访问产生副作用，访问的都是同样的字符串数据，不需要任何同步操作。

当字符串不可变时，字符串常量池才有意义。字符串常量池的出现，可以减少创建相同字面量的字符串，让不同的引用指向池中同一个字符串，为运行时节约很多的堆内存。若字符串可变，字符串常量池失去意义，基于常量池的 String.intern() 方法也失效，每次创建新的字符串将在堆内开辟出新的空间，占据更多的内存。

31.String的equals和Object的equals的区别？

String 中的 equals 方法是被重写过的，比较的是 String 字符串的值是否相等。 Object 的 equals 方法是比较的对象的内存地址。

32.字符串常量池的作用了解吗？

字符串常量池 是 JVM 为了提升性能和减少内存消耗针对字符串（String 类）专门开辟的一块区域，主要目的是为了避免字符串的重复创建。

33.String str = new String(“abc”) 创建了几个对象？

会创建 1 或 2 个字符串对象。

1、如果字符串常量池中不存在字符串对象“abc”的引用，那么它会在堆上创建两个字符串对象，其中一个字符串对象的引用会被保存在字符串常量池中。

ldc 命令用于判断字符串常量池中是否保存了对应的字符串对象的引用，如果保存了的话直接返回，如果没有保存的话，会在堆中创建对应的字符串对象并将该字符串对象的引用保存到字符串常量池中。

2、如果字符串常量池中已存在字符串对象“abc”的引用，则只会在堆中创建 1 个字符串对象“abc”。

34String 的intern方法有什么作用？

String.intern() 是一个 native（本地）方法，其作用是将指定的字符串对象的引用保存在字符串常量池中，可以简单分为两种情况：

1.如果字符串常量池中保存了对应的字符串对象的引用，就直接返回该引用。

2.如果字符串常量池中没有保存了对应的字符串对象的引用，那就在常量池中创建一个指向该字符串对象的引用并返回。

36.拼接使用”+“还是StringBuilder？

Java 语言本身并不支持运算符重载，“+”和“+=”是专门为 String 类重载过的运算符，也是 Java 中仅有的两个重载过的运算符。

字符串对象通过“+”的字符串拼接方式，实际上是通过 StringBuilder 调用 append() 方法实现的，拼接完成之后调用 toString() 得到一个 String 对象 。

不过，在循环内使用“+”进行字符串的拼接的话，存在比较明显的缺陷：编译器不会创建单个 StringBuilder 以复用，会导致创建过多的 StringBuilder 对象。

StringBuilder 对象是在循环内部被创建的，这意味着每循环一次就会创建一个 StringBuilder 对象。（也可以说是多了String对象）

如果直接使用 StringBuilder 对象进行字符串拼接的话，就不会存在这个问题了。

37.泛型的介绍：

Java 泛型（Generics） 是 JDK 5 中引入的一个新特性。使用泛型参数，可以增强代码的可读性以及稳定性。

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

并且，原生 List 返回类型是 Object ，需要手动转换类型才能使用，使用泛型后编译器自动转换

泛型一般有三种使用方式:泛型类、泛型接口、泛型方法

项目中哪些地方用到了泛型？

自定义接口通用返回结果 CommonResult<T> 通过参数 T 可根据具体的返回类型动态指定结果的数据类型

定义 Excel 处理类 ExcelUtil<T> 用于动态指定 Excel 导出的数据类型

构建集合工具类（参考 Collections 中的 sort, binarySearch 方法）。

38Java 中 ++ 操作符是线程安全的吗？

不是线程安全的操作，它涉及多个指令，如读取变量值，增加，然后存储回内存，这个过程可能出现多线程交错从而导致值的不正确。

再问：Serializable 接口为什么需要定义 serialVersionUID 常量？

serialVersionUID 代表序列化的版本，通过定义类的序列化版本，在反序列化时，只要对象中所存的版本和当前类的版本一致，就允许做恢复数据的操作，否则将会抛出序列化版本不一致的错误。

如果不定义序列化版本，在反序列化时可能出现冲突的情况，如：

创建该类的实例，并将这个实例序列化，保存在磁盘上。
升级这个类，例如增加、删除、修改这个类的成员变量；
反序列化该类的实例，即从磁盘上恢复修改之前保存的数据。
在第 3 步恢复数据的时候，当前的类已经和序列化的数据的格式产生了冲突，可能会发生各种意想不到的问题。增加了序列化版本之后，在这种情况下则可以抛出异常，以提示这种矛盾的存在，提高数据的安全性。

38.异常

异常的体系结构

39.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）一般会选择线程终止。

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

Checked Exception 即 受检查异常 ，Java 代码在编译过程中，如果受检查异常没有被 catch或者throws 关键字处理的话，就没办法通过编译。

除了RuntimeException及其子类以外，其他的Exception类及其子类都属于受检查异常 。常见的受检查异常有：IO 相关的异常、ClassNotFoundException、SQLException...。

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

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

1.NullPointerException(空指针错误)

2.IllegalArgumentException(参数错误比如方法入参类型错误)

3.NumberFormatException（字符串转换为数字格式错误，IllegalArgumentException的子类）4.ArrayIndexOutOfBoundsException（数组越界错误）

5.ClassCastException（类型转换错误）

41.异常的处理方式？

1.抛出异常：遇到异常时不进行具体的处理，直接将异常抛给调用者，让调用者自己根据情况处理。抛出异常的三种形式：throws、throw 和系统自动抛出异常。其中 throws 作用在方法上，用于定义方法可能抛出的异常；throw 作用在方法内，表示明确抛出一个异常。

2.使用 try catch 捕获并处理异常：使用 try catch 捕获异常能够有针对性的处理每种可能出现的异常，并在捕获到异常后根据不同的情况做不同的处理。其使用过程比较简单：用 try catch 语句块将可能出现异常的代码包起来即可。

42.throws 和 throw的区别？

1.throws 出现在方法头，throw 出现在方法体。
2.throws 表示出现异常的一种可能性，并不一定会发生异常；throw 则是抛出了异常，执行throw 则一定抛出了某种异常。
3.两者都是消极的异常处理方式，只是抛出或者可能抛出异常，是不会由函数处理，真正的处理异常由它的上层调用处理。

43.try-catch-finally如何使用？

1.try块：用于捕获异常。其后可接零个或多个 catch 块，如果没有 catch 块，则必须跟一个 finally 块。

2.catch块：用于处理 try 捕获到的异常。

3.finally 块：无论是否捕获或处理异常，finally 块里的语句都会被执行。当在 try 块或 catch 块中遇到 return 语句时，finally 语句块将在方法返回之前被执行

4.注意：不要在 finally 语句块中使用 return! 当 try 语句和 finally 语句中都有 return 语句时，try 语句块中的 return 语句会被忽略。这是因为 try 语句中的 return 返回值会先被暂存在一个本地变量中，当执行到 finally 语句中的 return 之后，这个本地变量的值就变为了 finally 语句中的 return 返回值。

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

不一定的！在某些情况下，finally 中的代码不会被执行。就比如说 finally 之前虚拟机被终止运行的话，finally 中的代码就不会被执行。

另外，在以下 几 种特殊情况下，finally 块的代码也不会被执行：

1.程序所在的线程死亡。

2.关闭 CPU。

3.程序还没有进入到try语句块就因为异常导致程序终止，这个问题主要是开发人员在编写代码的时候，异常的捕获范围不够。

4.在try或者catch语句块中，执行了System.exit(0)语句，导致JVM直接退出.

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

不要把异常定义为静态变量，因为这样会导致异常栈信息错乱。每次手动抛出异常，我们都需要手动 new 一个异常对象抛出。

抛出的异常信息一定要有意义。

建议抛出更加具体的异常比如字符串转换为数字格式错误的时候应该抛出NumberFormatException而不是其父类IllegalArgumentException。

避免重复记录日志：如果在捕获异常的地方已经记录了足够的信息（包括异常类型、错误信息和堆栈跟踪等），那么在业务代码中再次抛出这个异常时，就不应该再次记录相同的错误信息。重复记录日志会使得日志文件膨胀，并且可能会掩盖问题的实际原因，使得问题更难以追踪和解决。

反射：

46.什么是反射？

如果说大家研究过框架的底层原理或者咱们自己写过框架的话，一定对反射这个概念不陌生。反射之所以被称为框架的灵魂，主要是因为它赋予了我们在运行时分析类以及执行类中方法的能力。通过反射你可以获取任意一个类的所有属性和方法，你还可以调用这些方法和属性。

47.反射的优缺点？

反射可以让我们的代码更加灵活、为各种框架提供开箱即用的功能提供了便利。

不过，反射让我们在运行时有了分析操作类的能力的同时，也增加了安全问题，比如可以无视泛型参数的安全检查（泛型参数的安全检查发生在编译时）。另外，反射的性能也要稍差点，不过，对于框架来说实际是影响不大的。

48.反射的应用场景？

像咱们平时大部分时候都是在写业务代码，很少会接触到直接使用反射机制的场景。但是！这并不代表反射没有用。相反，正是因为反射，你才能这么轻松地使用各种框架。像 Spring/Spring Boot、MyBatis 等等框架中都大量使用了反射机制。

这些框架中也大量使用了动态代理，而动态代理的实现也依赖反射。

为什么你使用 Spring 的时候 ，一个@Component注解就声明了一个类为 Spring Bean 呢？为什么你通过一个 @Value注解就读取到配置文件中的值呢？究竟是怎么起作用的呢？

这些都是因为你可以基于反射分析类，然后获取到类/属性/方法/方法的参数上的注解。你获取到注解之后，就可以做进一步的处理

注解

49.什么是注解？

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

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

50.注解的解析方法有几种？

注解只有被解析之后才会生效，常见的解析方法有两种：

编译期直接扫描：编译器在编译 Java 代码的时候扫描对应的注解并处理，比如某个方法使用@Override 注解，编译器在编译的时候就会检测当前的方法是否重写了父类对应的方法。

运行期通过反射处理：像框架中自带的注解(比如 Spring 框架的 @Value、@Component)都是通过反射来进行处理的。

51.什么是序列化？什么是反序列化？

简单来说：

序列化：将数据结构或对象转换成二进制字节流的过程

反序列化：将在序列化过程中所生成的二进制字节流转换成数据结构或者对象的过程

对于 Java 这种面向对象编程语言来说，我们序列化的都是对象（Object）也就是实例化后的类(Class)，但是在 C++这种半面向对象的语言中，struct(结构体)定义的是数据结构类型，而 class 对应的是对象类型。

具体的，

对象在进行网络传输（比如远程方法调用 RPC 的时候）之前需要先被序列化，接收到序列化的对象之后需要再进行反序列化；

将对象存储到文件之前需要进行序列化，将对象从文件中读取出来需要进行反序列化；

将对象存储到数据库（如 Redis）之前需要用到序列化，将对象从缓存数据库中读取出来需要反序列化；

将对象存储到内存之前需要进行序列化，从内存中读取出来之后需要进行反序列化。

（序列化在计算机科学的数据处理中，是指将数据结构或对象状态转换成可取用格式（例如存成文件，存于缓冲，或经由网络中发送），以留待后续在相同或另一台计算机环境中，能恢复原先状态的过程。依照序列化格式重新获取字节的结果时，可以利用它来产生与原始对象相同语义的副本。对于许多对象，像是使用大量引用的复杂对象，这种序列化重建的过程并不容易。面向对象中的对象序列化，并不概括之前原始对象所关系的函数。这种过程也称为对象编组（marshalling）。从一系列字节提取数据结构的反向操作，是反序列化）

综上：序列化的主要目的是通过网络传输对象或者说是将对象存储到文件系统、数据库、内存中。

52.有些对象不想被序列化怎么办？

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

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

关于 transient 还有几点注意：

transient 只能修饰变量，不能修饰类和方法。

transient 修饰的变量，在反序列化后变量值将会被置成类型的默认值。例如，如果是修饰 int 类型，那么反序列后结果就是 0。

static 变量因为不属于任何对象(Object)，所以无论有没有 transient 关键字修饰，均不会被序列化

53.常见的序列化协议有哪些？

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

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

54.为什么不推荐使用JDK自带的序列化呢？

不支持跨语言调用 : 如果调用的是其他语言开发的服务的时候就不支持了。

性能差：相比于其他序列化框架性能更低，主要原因是序列化之后的字节数组体积较大，导致传输成本加大。

存在安全问题：序列化和反序列化本身并不存在问题。但当输入的反序列化的数据可被用户控制，那么攻击者即可通过构造恶意输入，让反序列化产生非预期的对象，在此过程中执行构造的任意代码

55.什么是语法糖？java中有哪些常见的语法糖？

语法糖（Syntactic sugar） 代指的是编程语言为了方便程序员开发程序而设计的一种特殊语法，这种语法对编程语言的功能并没有影响。实现相同的功能，基于语法糖写出来的代码往往更简单简洁且更易阅读。

举个例子，Java 中的 for-each 就是一个常用的语法糖，其原理其实就是基于普通的 for 循环和迭代器。

不过，JVM 其实并不能识别语法糖，Java 语法糖要想被正确执行，需要先通过编译器进行解糖，也就是在程序编译阶段将其转换成 JVM 认识的基本语法。这也侧面说明，Java 中真正支持语法糖的是 Java 编译器而不是 JVM。如果你去看com.sun.tools.javac.main.JavaCompiler的源码，你会发现在compile()中有一个步骤就是调用desugar()，这个方法就是负责解语法糖的实现的。

Java 中最常用的语法糖主要有泛型、自动拆装箱、变长参数、枚举、内部类、增强 for 循环、try-with-resources 语法、lambda 表达式等

补充：

55.成员变量和局部变量的区别：

成员变量是在类的范围里定义的变量，局部变量是在方法中定义的变量。

成员变量有默认初始值，局部变量没有默认初始值。

未被 static 修饰的成员变量叫实例变量，它存储于对象所在的堆内存中，生命周期与对象相同；被 static 修饰的成员变量叫类变量，它存储于方法区中，生命周期与当前类相同。局部变量存储于栈内存中，作用的范围结束，变量空间会自动的释放

56.Java 对象初始化顺序

父类静态代码块，父类静态成员变量（同级，按代码顺序执行）
子类静态代码块，子类静态成员变量（同级，按代码顺序执行）
父类普通代码块，父类普通成员变量（同级，按代码顺序执行）
父类构造方法
子类普通代码块，子类普通成员变量（同级，按代码顺序执行）
子类构造方法

注意点：

静态内容只在类加载时执行一次，之后不再执行。
默认调用父类的无参构造方法，可以在子类构造方法中利用 super 指定调用父类的哪个构造方法。

Java 内部类

57.为什么使用内部类？

使用内部类最吸引人的原因是：每个内部类都能独立地继承一个接口的实现，所以无论外围类是否已经继承了某个接口的实现，对于内部类都没有影响。

使用内部类最大的优点就在于它能够非常好的解决多重继承的问题，使用内部类还能够为我们带来如下特性:

内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。
在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。
创建内部类对象的时刻并不依赖于外围类对象的创建。
内部类并没有令人迷惑的 “is-a” 关系，它就是一个独立的实体。
内部类提供了更好的封装，除了该外围类，其他类都不能访问。