java基础

合集 - 面试题(15)
1.Java集合2.JVM3.多线程4.IO5.web编程6.Spring7.面试真题8.SpringBoot9.Spring Cloud10.MySQL（数据库）11.Redis（缓存）12.分布式13.MyBatis14.Linux
15.java基础
收起

Java 基础

1、面向对象编程有哪些特征？

面向对象编程（Object-Oriented Programming，OOP）具有以下几个主要特征：

  1. 封装（Encapsulation）：封装是指将数据（属性）和操作（方法）封装在一个类中，对外部隐藏对象的内部实现细节，只暴露必要的接口供其他对象进行访问。这样可以提高代码的安全性和可维护性。
  2. 继承（Inheritance）：继承是指一个类（子类）可以从另一个类（父类）继承属性和方法，并且可以在此基础上进行扩展或修改。通过继承，可以实现代码的重用性和扩展性。
  3. 多态（Polymorphism）：多态是指同一个方法可以在不同的对象上表现出不同的行为。通过方法的重载（Overloading）和重写（Override），可以实现多态性，提高代码的灵活性和可扩展性。
  4. 抽象（Abstraction）：抽象是指将对象的共同特征提取出来形成抽象类或接口，隐藏具体实现细节，只展示必要的接口。通过抽象，可以实现对对象的抽象描述，提高代码的可读性和理解性。

这些特征共同构成了面向对象编程的基础，使得代码更加模块化、可维护和可扩展。

2、JDK 与 JRE 的区别是什么？

JDK（Java Development Kit）和JRE（Java Runtime Environment）是Java开发中常用的两个组件，它们之间的区别主要体现在以下几个方面：

  1. JDK（Java Development Kit）：
    • JDK是Java开发工具包，包含了Java编译器（javac）、Java运行时环境（JRE）、Java程序打包工具（jar）、调试器（jdb）等工具和库。
    • JDK适合用于Java开发人员进行Java程序的编写、编译、调试和打包等工作。
    • JDK中包含了完整的JRE，因此在安装JDK后，可以直接运行Java程序。
  2. JRE（Java Runtime Environment）：
    • JRE是Java运行时环境，包含了Java虚拟机（JVM）和Java类库等运行时必要组件。
    • JRE适合用于普通用户或者运维人员，在没有进行Java开发的情况下，可以使用JRE来运行Java程序。

总的来说，JDK包含了完整的Java开发工具和运行环境，适合用于Java程序的开发、调试和打包；而JRE只包含了Java运行时环境，适合用于普通用户或者运维人员来运行Java程序。在开发Java程序时，通常需要安装JDK；而在只需要运行Java程序而无需进行开发时，可以安装JRE。

3、Java 有哪几种基本数据类型？

Java有以下几种基本数据类型：

  1. 整数类型（Integer Types）：
    • byte：字节型，占用1个字节，取值范围为-128到127。
    • short：短整型，占用2个字节，取值范围为-32768到32767。
    • int：整型，占用4个字节，取值范围为-2147483648到2147483647。
    • long：长整型，占用8个字节，取值范围为-9223372036854775808到9223372036854775807。
  2. 浮点类型（Floating-Point Types）：
    • float：单精度浮点型，占用4个字节，表示小数，精度约为6-7位有效数字。
    • double：双精度浮点型，占用8个字节，表示小数，精度约为15-16位有效数字。
  3. 字符类型（Character Type）：
    • char：字符型，占用2个字节，表示单个字符，可以是Unicode字符。
  4. 布尔类型（Boolean Type）：
    • boolean：布尔型，占用1个字节，表示逻辑值，只能取true或false两个值。

这些基本数据类型是Java中用于存储基本数据的基础，可以用于声明变量、定义方法参数等。在实际编程中，根据数据的不同需求选择合适的数据类型来存储和处理数据。

4、== 和 equals 比较有什么区别？

在Java中，==和equals()是用来比较对象的两种不同方法，它们之间有以下区别：

  1. ==比较运算符：
    • ==用于比较两个对象的内存地址是否相同，即判断两个对象是否是同一个对象的引用。
    • 如果两个对象的地址相同，则==返回true；否则返回false。
    • 对于基本数据类型（如int、double等），==比较的是值是否相等；而对于引用类型（如String、对象等），==比较的是引用是否相同。
  2. equals()方法：
    • equals()是Object类的方法，用于比较两个对象的内容是否相同。
    • 默认情况下，equals()方法与==运算符功能相同，即比较对象的内存地址是否相同。
    • 但是，可以通过在类中重写equals()方法来改变比较的方式，使其比较对象的内容而不是内存地址。
    • 通常情况下，如果想要比较两个对象的内容是否相同，应该使用equals()方法而不是==运算符。

总的来说，==运算符比较的是对象的引用是否相同，而equals()方法比较的是对象的内容是否相同。在比较对象的内容时，应该使用equals()方法，并根据实际需求来决定是否需要重写equals()方法。

5、public,private,protected,默认的区别？

在Java中，public、private、protected和默认（没有显式声明访问修饰符）是用来控制类的成员（字段、方法、构造方法等）的访问权限的关键字，它们之间的区别如下：

  1. public（公有的）：
    • public修饰的成员可以被任何其他类访问，无论是否属于同一个包。
    • 其他类可以通过对象访问public修饰的成员。
  2. private（私有的）：
    • private修饰的成员只能在所属的类内部访问，其他类无法直接访问。
    • private修饰符用于隐藏类的内部实现细节，提高类的封装性。
  3. protected（受保护的）：
    • protected修饰的成员可以被同一个包内的其他类访问，也可以被不同包中的子类访问。
    • 在不同包中的非子类无法访问protected修饰的成员。
  4. 默认访问修饰符（没有显式声明访问修饰符）：
    • 如果一个成员没有使用任何访问修饰符，则默认为包内可见（同一包内的其他类可以访问）。
    • 在不同包中的类无法访问默认修饰的成员。
访问修饰符 可见范围 继承性 用途
public 所有类都可见 可继承 用于指定公共可访问的成员，任何类都可以访问到
private 仅所属类内部可见 不可继承 用于隐藏类的内部实现细节，提高封装性
protected 同一包内和子类可见 可继承 用于允许子类访问父类的成员，同时在同一包内部也可访问
默认 同一包内可见 不可继承 用于定义包内的默认可见性，只有同一包内的类可以访问

这些访问修饰符用于控制类的成员对其他类的可见性，提供了对类的封装性和安全性的支持。正确使用这些修饰符可以帮助我们设计出更加合理、安全和易于维护的Java程序。

6、this 和 super 有什么区别？

this和super是Java中两个关键字，用于不同的情况，它们之间的区别如下：

  1. this关键字：
    • this关键字用于引用当前对象的实例。
    • 在类的方法中，this表示当前对象的引用，可以用来访问当前对象的成员变量和方法。
    • 通常用于区分局部变量和成员变量名相同的情况，以及在构造方法中调用其他构造方法。
    • 例如：this.variable表示当前对象的成员变量，this.method()表示当前对象的方法。
  2. super关键字：
    • super关键字用于引用父类的实例或者父类的成员。
    • 在子类中，super可以调用父类的构造方法、成员变量和方法。
    • 在构造方法中，可以使用super()来调用父类的构造方法。
    • 例如：super.variable表示父类的成员变量，super.method()表示调用父类的方法。

总的来说，this关键字用于引用当前对象的实例，而super关键字用于引用父类的实例或者父类的成员。它们在面向对象编程中有着不同的应用场景和作用。

7、short s1 = 1; s1 += 1;有错吗？

在Java中，short s1 = 1; s1 += 1;这段代码没有语法错误，但是可能会导致类型转换的问题。具体来说，这段代码涉及到了自增运算符+=，它会隐式进行类型转换。

让我们来看一下这段代码的执行过程：

  1. 首先，声明并初始化了一个short类型的变量s1，赋值为1。
  2. 然后，使用自增运算符+=对s1进行操作，等价于s1 = (short)(s1 + 1)。

在这个过程中，由于Java中的数值计算默认是以int类型进行的，因此在执行s1 + 1时，会将s1隐式转换为int类型进行计算，得到的结果也是int类型。然后将结果再次转换为short类型，赋值给s1。

因此，虽然没有语法错误，但需要注意可能发生的类型转换问题。如果s1的值超出了short类型的取值范围，在执行过程中可能会导致数据溢出或者不符合预期的结果。

9、float n = 1.8 有错吗？

在Java中，float n = 1.8;这段代码会产生编译错误，因为1.8是一个double类型的字面值，而float类型的变量需要用f或F后缀来表示。因此，正确的写法应该是：

float n = 1.8f;

或者

float n = 1.8F;

这样才能将1.8作为float类型的值进行赋值。

10、i++ 和 ++i 的区别？

i++和++i都是Java中的自增运算符，它们之间的区别主要在于操作的顺序和返回值：

  1. i++（后自增）：
    • i++表示先使用变量i的当前值，然后再对i进行自增操作。
    • 例如：int i = 1; int j = i++;，这时候j的值是1，而i的值是2。
    • 也可以写成i = i + 1;。
  2. ++i（前自增）：
    • ++i表示先对变量i进行自增操作，然后再使用变量i的值。
    • 例如：int i = 1; int j = ++i;，这时候j的值是2，而i的值也是2。
    • 也可以写成i = i + 1;。

总的来说，i++和++i的区别在于自增的顺序不同：i++是先使用当前值再自增，而++i是先自增再使用值。在大多数情况下，这两者的结果是相同的，但在表达式中可能会产生不同的效果。

11、while 和 do while 有啥区别？

while循环和do-while循环都是Java中用于执行重复操作的循环结构，它们之间的主要区别在于循环条件的判断时机：

  1. while循环：

    • while循环在执行循环体之前先判断循环条件，如果条件为真则执行循环体，然后再次判断条件，以此类推。

    • 如果初始时条件为假，则while循环将不会执行循环体。

    • 例如：

      int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}

      这段代码会输出0到4，因为在每次循环开始前都会先判断

      i < 5

      的条件是否成立。

  2. do-while循环：

    • do-while循环先执行循环体，然后再判断循环条件是否成立，如果条件为真则继续执行循环体，以此类推。

    • 即使初始时条件为假，do-while循环也会执行至少一次循环体。

    • 例如：

      int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 5);

      这段代码也会输出0到4，但是与

      while

      循环不同的是，无论初始条件是否满足，

      do-while

      循环都会执行至少一次。

总的来说，while循环在执行循环体之前判断条件，可能一次都不执行循环体；而do-while循环先执行一次循环体再判断条件，至少会执行一次循环体。选择使用哪种循环取决于具体的需求和逻辑。

12、如何跳出 Java 中的循环？

在Java中，可以使用break语句来跳出循环。break语句用于跳出最内层的循环，可以在for循环、while循环、do-while循环以及switch语句中使用。以下是几种情况下如何使用break语句跳出循环：

  1. 在for循环中跳出：

    for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // 跳出循环
    }
    System.out.println(i);
}

  2. 在while循环中跳出：

    int i = 0;
while (i < 10) {
    if (i == 5) {
        break; // 跳出循环
    }
    System.out.println(i);
    i++;
}

  3. 在do-while循环中跳出：

    int i = 0;
do {
    if (i == 5) {
        break; // 跳出循环
    }
    System.out.println(i);
    i++;
} while (i < 10);

  4. 在switch语句中跳出：

    int num = 2;
switch (num) {
    case 1:
        System.out.println("Case 1");
        break;
    case 2:
        System.out.println("Case 2");
        break; // 跳出switch语句
    default:
        System.out.println("Default case");
}

break语句在执行时会立即跳出当前循环或者switch语句，继续执行循环或者switch语句后面的代码。因此，使用break语句可以在满足特定条件时提前结束循环的执行。

13、如何跳出 Java 中的多层嵌套循环？

要在Java中跳出多层嵌套循环，可以使用带有标签（label）的break语句。标签是一个标识符，用于标记循环语句，然后在break语句中指定标签，即可跳出带有该标签的循环。以下是使用标签跳出多层嵌套循环的示例：

outerLoop:
for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 5; j++) {
        if (i == 2 && j == 2) {
            break outerLoop; // 跳出带有outerLoop标签的外层循环
        }
        System.out.println("i: " + i + ", j: " + j);
    }
}

在这个示例中，outerLoop是一个标签，它标记了外层的for循环。当内层循环满足条件时，使用break outerLoop;语句可以直接跳出外层循环，不再执行后续的循环体。

需要注意的是，在使用标签跳出多层嵌套循环时，要确保标签名称在当前作用域中是唯一的，否则会导致编译错误。此外，过度使用标签可能会使代码难以理解和维护，因此建议在确实需要跳出多层循环时才使用标签。

14、& 和 && 的区别？

在Java中，&和&&都是用于逻辑与（AND）操作的运算符，它们之间的区别主要在于运算规则和应用场景：

  1. &运算符：
    • &运算符是按位与（Bitwise AND）运算符，用于对两个操作数的每一位进行与操作。
    • 当使用&运算符时，无论左边的表达式是否为真（true）或者右边的表达式是否为真，都会对两个表达式进行计算，然后返回结果。
    • 例如：true & false，结果为false，因为按位与运算的结果是0001 & 0000 = 0000。
  2. &&运算符：
    • &&运算符是逻辑与（Logical AND）运算符，用于对两个布尔表达式进行逻辑与操作。
    • 当使用&&运算符时，如果左边的表达式为假（false），则右边的表达式不会进行计算，直接返回结果为假；只有左边的表达式为真时，才会计算并返回右边的表达式的结果。
    • 例如：true && false，结果为false，因为左边的表达式为真，但是右边的表达式为假，所以整个逻辑与表达式的结果为假。

总的来说，&运算符是按位与运算，无论左右表达式的结果如何都会计算；而&&运算符是逻辑与运算，只有左边的表达式为真时才会计算右边的表达式。通常情况下，在逻辑判断时常用&&运算符，因为它具有短路特性，可以提高程序执行效率。

15、2 * 8 最有效率的计算方法是什么？

对于整数乘法运算，通常情况下，编译器和计算机硬件会对常量表达式进行优化，因此在代码中直接写2 * 8是最有效率的计算方法之一，因为它是一个简单的常量表达式，可以在编译时就被优化为结果16。

如果需要进一步优化，可以使用位运算来进行乘法运算。对于2的乘法，可以使用左移运算来实现。因为左移运算相当于对原数乘以2的幂次方，所以对于2乘以任意整数，都可以通过左移运算来实现。例如，2 * 8可以写成(1 << 3)，其中<<表示左移运算，3表示左移3位，即乘以2的3次方，结果为8。

综上所述，最有效率的计算方法可以是直接写常量表达式2 * 8，或者使用位运算(1 << 3)来实现乘法运算。值得注意的是，在实际开发中，应根据具体情况选择更易读和维护的代码形式。

16、数组有没有 length 方法？String 呢？

在Java中，数组和String都有length属性而不是方法。

  1. 数组的长度获取：数组在Java中可以通过array.length来获取数组的长度，这是一个属性而不是方法。例如：

    int[] array = {1, 2, 3, 4, 5};
int length = array.length; // 获取数组的长度

  2. String的长度获取：String类在Java中也有length属性来获取字符串的长度，同样也是一个属性而不是方法。例如：

    String str = "Hello, world!";
int length = str.length(); // 获取字符串的长度

注意，数组的长度属性是一个固定的值，表示数组中元素的个数；而String的长度属性是一个方法，用于获取字符串的长度，即字符串中字符的个数。

17、怎么理解值传递和引用传递？

理解值传递和引用传递涉及到Java中方法参数的传递方式：

  1. 值传递（Pass by Value）：
    • 值传递是指将实际参数的值复制一份传递给形式参数，方法中对形式参数的修改不会影响到实际参数的值。
    • 在值传递中，传递的是变量的值，而不是变量本身。
    • Java中的基本数据类型（如int、float、boolean等）采用值传递的方式传递参数。
  2. 引用传递（Pass by Reference）：
    • 引用传递是指将实际参数的地址（引用）传递给形式参数，方法中对形式参数的修改会影响到实际参数的值。
    • 在引用传递中，传递的是变量的地址，即变量在内存中的位置。
    • Java中的引用类型（如数组、对象等）采用引用传递的方式传递参数。

在Java中，实际上只有值传递一种方式，无论是传递基本数据类型还是引用类型的参数，都是将值（基本数据类型的值或者引用类型的地址）传递给方法的形式参数。但需要注意的是，对于引用类型的参数，传递的是对象的地址，因此在方法中对对象的操作可能会影响到对象的实际值。

举例来说：

public class Main {
    public static void main(String[] args) {
        int a = 10;
        changeValue(a);
        System.out.println("a after method call: " + a); // 输出：a after method call: 10
        
        int[] arr = {1, 2, 3};
        changeArray(arr);
        System.out.println("arr[0] after method call: " + arr[0]); // 输出：arr[0] after method call: 100
    }
    
    public static void changeValue(int x) {
        x = 20;
    }
    
    public static void changeArray(int[] array) {
        array[0] = 100;
    }
}

在上面的例子中，对于基本数据类型的参数a，传递的是值，方法内修改形式参数x不会影响到实际参数a的值；而对于数组类型的参数arr，传递的是引用，方法内修改形式参数array会影响到实际参数arr中元素的值。

18、Java 到底是值传递还是引用传递？

在 Java 中，参数传递是按值传递（Pass by Value）的。这意味着当你将一个参数传递给一个方法时，实际上是传递了该参数的副本，而不是参数本身。无论是基本数据类型还是引用类型，都是按值传递的。

对于基本数据类型（如 int、double、char 等），传递的是它们的值的副本，因此在方法内部修改形式参数的值不会影响到实际参数的值。

对于引用类型（如对象、数组等），传递的是对象的引用的副本，也就是说，实际参数和形式参数都指向同一个对象。因此，在方法内部修改引用类型的形式参数会影响到实际参数所指向的对象，但修改形式参数指向另一个对象则不会影响到实际参数。

这种行为可以理解为传递了一个指针的副本，而不是传递了指针所指向的对象本身。

举个例子来说明：

public class Main {
    public static void main(String[] args) {
        // 基本数据类型
        int a = 10;
        changeValue(a);
        System.out.println("a after method call: " + a); // 输出：a after method call: 10
        
        // 引用类型
        int[] arr = {1, 2, 3};
        changeArray(arr);
        System.out.println("arr[0] after method call: " + arr[0]); // 输出：arr[0] after method call: 100
    }
    
    public static void changeValue(int x) {
        x = 20; // 修改形式参数的值，不会影响实际参数
    }
    
    public static void changeArray(int[] array) {
        array[0] = 100; // 修改形式参数指向的对象，会影响实际参数
    }
}

因此，Java 是按值传递的，但对于引用类型，传递的是引用的副本，而不是对象本身。

19、一个 “.java” 源文件的类有什么限制？

一个 ".java" 源文件中的类在 Java 中有一些限制和约定，主要包括以下几点：

  1. 文件名和类名一致：Java 要求 ".java" 源文件的文件名必须与其中定义的公共类的类名完全一致。例如，定义了一个名为 MyClass 的公共类，则该源文件的文件名必须为 MyClass.java。
  2. 只能有一个公共类：一个 ".java" 源文件中只能有一个公共类（public class），且该公共类的类名必须与文件名一致。如果源文件中包含多个类，只能有一个是公共类，其他类可以是默认访问级别的类。
  3. 公共类的访问修饰符：公共类（public class）可以被其他类访问，因此它的访问修饰符可以是 public 或者默认（不写访问修饰符），但不能是 private 或 protected。
  4. 文件中其他类的访问修饰符：除了公共类外，源文件中的其他类可以是任意访问级别，包括 public、protected、private 或默认（不写访问修饰符），但推荐使用默认访问级别，即不写访问修饰符。
  5. 一个源文件中可以有多个非公共类：除了公共类外，一个源文件中可以包含多个非公共类（不使用 public 修饰的类），这些类的访问权限是包内可见的，只能被同一个包内的其他类访问。
  6. 源文件中的类可以包含成员变量、方法和构造方法：在源文件中的类可以包含成员变量、方法和构造方法等成员，用于描述类的属性和行为。

总的来说，一个 ".java" 源文件的类有以下限制：文件名必须与公共类的类名一致，一个源文件只能有一个公共类，公共类的访问修饰符可以是 public 或默认访问级别，其他类的访问修饰符可以是任意访问级别。

20、Java 中的注释有哪些写法？

Java 中的注释有三种常用的写法：

  1. 单行注释：以双斜线（//）开头，用于注释单行内容。

    // 这是单行注释
int a = 10; // 可以在代码行后添加单行注释

  2. 多行注释：以斜线加星号（/）开头，以星号加斜线（/）结尾，用于注释多行内容或大段代码。

    /*
 * 这是多行注释
 * 可以注释多行内容
 */

  3. 文档注释：以斜线加星号加两个星号（/**）开头，以星号加斜线（*/）结尾，用于生成文档。

    /**
 * 这是文档注释
 * 用于生成文档
 */
public class MyClass {
    // 类的代码
}

其中，单行注释和多行注释用于注释代码逻辑或说明，不会被编译器处理；而文档注释则用于生成文档，可以通过工具生成代码文档，提供代码的详细说明、参数说明、返回值说明等信息，通常用于公共类、方法和字段的注释。

21、static 关键字有什么用？

static 关键字在 Java 中具有多种用途，主要包括以下几个方面：

  1. 静态变量：使用 static 关键字声明的变量为静态变量，也称为类变量。静态变量属于类，而不是属于类的实例（对象），所有该类的实例共享同一个静态变量的值。静态变量在类加载时被初始化，在整个程序执行期间都存在，不会随着对象的创建和销毁而改变。
  2. 静态方法：使用 static 关键字声明的方法为静态方法，也称为类方法。静态方法可以通过类名直接调用，不需要先创建对象。静态方法中不能直接访问非静态成员变量和非静态方法，因为它们是属于类的，而不是属于对象的。
  3. 静态代码块：使用 static 关键字声明的代码块为静态代码块，在类加载时执行，用于初始化静态变量或执行一些静态的初始化操作。静态代码块在类加载时只会执行一次。
  4. 静态内部类：使用 static 关键字修饰的内部类称为静态内部类，它可以直接访问外部类的静态成员变量和静态方法，不需要依赖外部类的实例。
  5. 静态导入：使用 static 关键字可以进行静态导入，即导入类的静态成员，使得可以直接使用静态成员而不需要通过类名。

总的来说，static 关键字用于定义类级别的元素，包括静态变量、静态方法、静态代码块和静态内部类等，在面向对象编程中具有重要的作用，如共享数据、提高程序执行效率、简化调用方式等。

22、static 变量和普通变量的区别？

static 变量（静态变量）和普通变量（实例变量）在 Java 中有以下区别：

  1. 存储位置：
    • 静态变量存储在静态区（方法区）中，属于类级别，所有对象共享同一个静态变量的值。
    • 实例变量存储在堆内存中，属于对象级别，每个对象都有自己的实例变量副本。
  2. 初始化时机：
    • 静态变量在类加载时被初始化，只会初始化一次，整个程序执行期间都存在，不会随着对象的创建和销毁而改变。
    • 实例变量在创建对象时被初始化，每个对象都有自己的实例变量值，不同对象的实例变量相互独立。
  3. 调用方式：
    • 静态变量可以通过类名直接访问，也可以通过对象访问。
    • 实例变量必须通过对象访问，不能通过类名直接访问。
  4. 生命周期：
    • 静态变量的生命周期与类的生命周期相同，当类被加载进内存时初始化，当程序结束时销毁。
    • 实例变量的生命周期与对象的生命周期相同，当对象被垃圾回收时销毁。
  5. 共享性：
    • 静态变量属于类级别，所有对象共享同一个静态变量的值，适合用于表示类级别的属性或全局共享的状态。
    • 实例变量属于对象级别，每个对象都有自己的实例变量值，适合用于表示对象的状态或属性。

总的来说，静态变量是属于类的变量，所有对象共享同一个静态变量的值；而实例变量是属于对象的变量，每个对象都有自己的实例变量副本。静态变量适合用于表示类级别的属性或全局共享的状态，而实例变量适合用于表示对象的状态或属性。

23、static 可以修饰局部变量么？

在 Java 中，static 关键字不能用来修饰局部变量。static 关键字主要用于修饰类级别的成员，如静态变量、静态方法、静态代码块和静态内部类等，而不用于修饰局部变量。

局部变量是定义在方法、构造方法或代码块内部的变量，它的生命周期仅限于方法、构造方法或代码块的执行过程中，当方法、构造方法或代码块执行完毕后，局部变量就会被销毁，无法通过类名或对象名进行访问。

因此，static 关键字不适用于局部变量，只能用于修饰类级别的成员，用于表示类级别的属性、方法和代码块。

24、final 关键字有哪些用法？

final 关键字在 Java 中有多种用法，主要包括以下几个方面：

  1. 常量：用于声明常量，一旦赋值后不可修改。

    final int MAX_VALUE = 100;

  2. 方法：用于修饰方法，表示该方法不可被子类重写（覆盖）。

    public final void display() {
    // 方法体
}

  3. 类：用于修饰类，表示该类不可被继承（派生）。

    public final class MyClass {
    // 类的内容
}

  4. 变量：用于修饰变量，表示该变量只能被赋值一次，类似于常量的特性。

    final int x = 10;

  5. 参数：用于修饰方法参数，表示该参数在方法内部不可被修改。

    public void process(final int num) {
    // 方法内部不能修改num的值
}

  6. 块：用于修饰代码块，表示该代码块在执行后不可被修改。

    {
    final int y = 20;
    // 这个代码块执行完毕后，y的值不可再修改
}

总的来说，final 关键字用于表示不可变的特性，可以用于修饰常量、方法、类、变量、参数和代码块等，具体使用取决于需要表达的语义和约束。

25、final、finally、finalize 有什么区别？

这三个关键字在 Java 中有不同的含义和用法：

  1. final：
    • final 是一个修饰符，用于修饰类、方法、变量和参数，表示不可变的特性。
    • 修饰类时，表示该类不可被继承。
    • 修饰方法时，表示该方法不可被子类重写。
    • 修饰变量时，表示该变量只能被赋值一次。
    • 修饰参数时，表示该参数在方法内部不可被修改。
  2. finally：
    • finally 是 Java 中的关键字，用于定义在 try-catch-finally 结构中的代码块，在 try 或 catch 中的代码执行完毕后，无论是否发生异常，finally 中的代码都会被执行。
    • finally 常用于确保资源的释放和清理，比如关闭文件、数据库连接等操作。
  3. finalize：
    • finalize 是一个方法，是 Java 对象的一个方法，用于在垃圾回收器回收对象之前调用。
    • 在 Java 中，对象不再被引用时会被标记为可回收的垃圾，垃圾回收器会在适当的时候回收这些垃圾对象，释放它们占用的内存。在对象被回收前，垃圾回收器会调用对象的 finalize 方法，可以在这个方法中进行资源的释放或其他清理操作。
    • 需要注意的是，虽然可以使用 finalize 方法进行资源清理，但是由于无法保证垃圾回收器何时调用 finalize 方法，因此不建议过度依赖 finalize 方法进行资源管理，最好使用 try-finally 结构来确保资源的正确释放。

综上所述，final 是一个修饰符，表示不可变性；finally 是一个关键字，用于定义在 try-catch 结构中的最终执行代码块；finalize 是一个方法，用于在对象被回收前进行清理操作。这三者在 Java 中具有不同的作用和用法。

26、void 和 Void 有什么区别？

void 和 Void 在 Java 中代表不同的概念：

  1. void：
    • void 是 Java 的关键字，用于表示方法的返回类型为无返回值。
    • 在方法声明中，如果返回类型为 void，则表示该方法不返回任何值，只执行一些操作而不产生返回结果。
  2. Void：
    • Void 是 Java 中的一个类，位于 java.lang 包下，表示 void 的包装类。
    • Void 类只有一个静态常量 TYPE，用于表示 void 关键字对应的 Class 对象。

因此，void 是用于方法返回类型的关键字，表示无返回值；而 Void 是一个类，表示 void 关键字对应的包装类，用于一些特殊的需求，如泛型中的类型参数。

27、为什么 byte 取值范围为 -128～127？

byte 类型的取值范围为 -128 到 127 是由于 Java 中的基本数据类型 byte 使用了补码表示法。补码是一种计算机中用于表示有符号整数的编码方式，它具有以下特点：

  1. 符号位：在补码表示法中，最高位（即最左边的位）用于表示数值的符号，0 表示正数，1 表示负数。
  2. 表示范围：对于一个 n 位的补码，它能够表示的数值范围为 -2^(n-1) 到 2^(n-1)-1，其中负数的最小值是 -2^(n-1)，正数的最大值是 2^(n-1)-1。

对于 byte 类型，在 Java 中，它占用 8 位（1 字节）的内存空间，因此它的取值范围是 -2^7 到 2^7-1，即 -128 到 127。这是因为 byte 类型的最高位（即最左边的位）用于表示符号位，剩下的 7 位用于表示数值的大小。

所以，byte 类型取值范围为 -128 到 127 是由于其使用了 8 位的补码表示法，其中最高位表示符号位，剩下的 7 位表示数值的大小。

28、char 类型可以存储中文汉字吗？

是的，char 类型可以存储中文汉字。在 Java 中，char 类型是用来表示字符的数据类型，它占用 16 位（2 字节）的内存空间，可以存储 Unicode 编码中的字符，包括中文汉字。

Unicode 是一种字符编码标准，它包含了世界上几乎所有的字符，包括各种语言的字符、符号、表情等。中文汉字在 Unicode 编码中也有对应的字符表示。

在 Java 中，可以使用 char 类型来存储任意 Unicode 编码的字符，包括中文汉字。例如，可以使用 char 类型的变量来表示一个中文汉字，如下所示：

char chineseChar = '中'; // 使用单引号括起来的字符表示中文汉字

因此，char 类型是可以存储中文汉字的，只需要使用对应的 Unicode 编码即可。

29、重载和重写有什么区别？

重载（Overloading）和重写（Overriding）是 Java 中面向对象编程中常用的两个概念，它们有以下区别：

  1. 定义：
    • 重载（Overloading）：在同一个类中，允许存在多个同名方法，但方法的参数列表必须不同（参数类型、个数、顺序不同），称为方法的重载。
    • 重写（Overriding）：在继承关系中，子类可以重写（覆盖）父类的方法，即在子类中定义与父类方法名、参数列表完全相同的方法，称为方法的重写。
  2. 适用范围：
    • 重载（Overloading）适用于同一个类中，方法名相同，但参数列表不同的情况。
    • 重写（Overriding）适用于子类继承父类的情况，子类可以重写父类的方法。
  3. 方法调用：
    • 重载（Overloading）的方法调用是在编译时确定的，根据调用时传入的参数类型和个数确定调用哪个重载方法。
    • 重写（Overriding）的方法调用是在运行时确定的，根据对象的实际类型确定调用父类还是子类的方法。
  4. 方法签名：
    • 重载（Overloading）方法的签名由方法名和参数列表组成，参数列表不同的方法可以共存。
    • 重写（Overriding）方法的签名由方法名和参数列表组成，必须与父类方法的签名完全一致，包括返回类型、方法名和参数列表。

总的来说，重载（Overloading）是指在同一个类中可以存在多个同名方法，方法的参数列表必须不同；重写（Overriding）是指子类可以重写父类的方法，方法名和参数列表必须完全相同，用于实现多态性。重载是静态绑定的，而重写是动态绑定的。

30、构造器可以被重写和重载吗？

构造器（Constructor）在 Java 中是用来创建对象的特殊方法，它们不能被重写（Overriding），但可以被重载（Overloading）。

  1. 重写（Overriding）：重写是指子类可以重写父类的方法，但是构造器不是普通的方法，因此构造器不能被重写。子类的构造器可以调用父类的构造器，但不能重写。
  2. 重载（Overloading）：重载是指在同一个类中可以存在多个同名方法，但参数列表必须不同。构造器也可以被重载，即在一个类中可以定义多个构造器，只要它们的参数列表不同即可。例如，一个类可以有默认构造器、带参数的构造器等。

31、main 方法可以被重写和重载吗？

在 Java 中，main 方法是程序的入口方法，它是一个特殊的静态方法，用于启动 Java 程序。main 方法具有特定的签名和语义，因此不能被重写（Overriding），但可以被重载（Overloading）。

  1. 重写（Overriding）：重写是指子类可以重写父类的方法，但是 main 方法不是普通的方法，而是 Java 程序的入口方法，它具有特定的签名和语义，所以不能被子类重写。
  2. 重载（Overloading）：重载是指在同一个类中可以存在多个同名方法，但参数列表必须不同。main 方法也可以被重载，即在同一个类中可以定义多个 main 方法，只要它们的参数列表不同即可。但是需要注意的是，只有具有特定的 public static void main(String[] args) 签名的 main 方法才是程序的入口方法，其他重载的 main 方法不会被 JVM 调用。

32、私有方法能被重载或者重写吗？

私有方法（Private Methods）在 Java 中具有以下特点：

  1. 可见性：私有方法只能在声明它的类内部访问，无法在其他类中直接调用。
  2. 继承：私有方法不会被子类继承，因为它们不可见于子类。
  3. 重写：由于私有方法不可见于子类，所以不能被子类重写（Overriding）。
  4. 重载：私有方法可以被重载（Overloading），即在同一个类中可以存在多个同名的私有方法，只要它们的参数列表不同即可。

因此，私有方法不能被重写（Overriding），但可以被重载（Overloading）。私有方法的重载是指在同一个类中可以存在多个同名的私有方法，但它们的参数列表必须不同，因为私有方法只能在当前类内部调用，所以不存在多态的情况，也就没有重写的概念。

33、Java 中的断言（assert）是什么？

Java 中的断言（assertion）是一种用于在代码中进行测试和调试的机制，它可以在代码中插入断言语句来检查程序的运行结果是否符合预期。断言主要用于以下几个方面：

  1. 预置条件检查：在方法内部对输入参数进行检查，确保满足预期的条件。
  2. 不变式检查：在方法执行过程中检查对象状态是否满足不变式。
  3. 后置条件检查：在方法结束时检查返回值是否符合预期的条件。
  4. 错误检测：在代码中插入断言语句来检测潜在的错误或异常情况。

断言的语法格式为：

assert expression;
assert expression : errorMessage;

其中，expression 是一个布尔表达式，用于检查条件是否成立；errorMessage 是可选的错误信息，用于在断言失败时输出详细的错误信息。

在 Java 中，默认情况下断言是禁用的，需要在运行时通过 -ea 参数（或者 -enableassertions 参数的简写）启用断言。例如：

vbnetCopy code
java -ea MyClass

启用断言后，如果断言失败（即条件不成立），会抛出 AssertionError 异常。可以通过在启动时使用 -da 参数（或者 -disableassertions 参数的简写）来禁用断言。

示例：

public class MyClass {
    public static void main(String[] args) {
        int num = -5;
        assert num > 0 : "Number should be positive";
        System.out.println("Number is positive");
    }
}

在上面的示例中，如果启用了断言，当 num 的值小于等于 0 时，断言失败，会抛出 AssertionError 异常并输出错误信息 "Number should be positive"；否则会输出 "Number is positive"。

34、Java 异常有哪些分类？

Java 中的异常可以分为两大类：可检查异常（Checked Exception）和不可检查异常（Unchecked Exception）。

  1. 可检查异常（Checked Exception）：
    • 可检查异常是指编译器在编译时会强制要求程序员处理的异常，即程序在编译时必须对这些异常进行捕获处理或者通过 throws 关键字声明抛出。如果不处理这些异常，编译器会报错。
    • 常见的可检查异常包括：
      • IOException：输入输出异常，如文件读写异常。
      • SQLException：数据库操作异常。
      • ClassNotFoundException：类未找到异常。
      • InterruptedException：线程中断异常等。
  2. 不可检查异常（Unchecked Exception）：
    • 不可检查异常是指编译器在编译时不会强制要求程序员处理的异常，即程序在编译时不需要对这些异常进行捕获处理或者声明抛出。不可检查异常通常是由程序运行时出现的问题导致的，如逻辑错误、空指针异常、数组越界异常等。
    • 常见的不可检查异常包括：
      • NullPointerException：空指针异常，访问了空引用。
      • ArrayIndexOutOfBoundsException：数组越界异常。
      • ClassCastException：类型转换异常。
      • IllegalArgumentException：非法参数异常。
      • IllegalStateException：非法状态异常。
      • ArithmeticException：算术异常等。

除了可检查异常和不可检查异常之外，还有一种特殊的错误（Error），它表示程序运行时的严重问题，一般不需要程序员处理，而是由 JVM 或者其他系统组件处理。常见的错误包括：

  • OutOfMemoryError：内存溢出错误。
  • StackOverflowError：栈溢出错误。
  • NoClassDefFoundError：类未定义错误等。

总的来说，Java 中的异常可以分为可检查异常、不可检查异常和错误三大类。可检查异常在编译时会强制要求处理，不可检查异常不需要强制处理，而错误通常表示程序运行时的严重问题

35、Error 和 Exception 有什么区别？

Error 和 Exception 是 Java 中的两种不同的异常类型，它们有以下区别：

  1. 继承关系：
    • Error 类型是 Throwable 的子类，它表示程序运行时的严重问题，通常是由于系统故障或者虚拟机错误导致的，比如内存溢出（OutOfMemoryError）、栈溢出（StackOverflowError）等。
    • Exception 类型也是 Throwable 的子类，它表示程序运行时的一般异常情况，通常是由于程序逻辑错误、输入错误或外部环境异常导致的。
  2. 处理方式：
    • Error 类型的异常一般不需要程序员显示处理，因为这些异常通常是由系统或虚拟机导致的严重问题，处理方式一般是程序终止或者系统崩溃。
    • Exception 类型的异常一般需要程序员进行处理，可以通过捕获异常、抛出异常或者使用 try-catch-finally 结构来处理异常情况。
  3. 检查方式：
    • Error 类型的异常通常是不可预测的，比如内存溢出、系统崩溃等，程序员很难通过代码来检查并避免这些异常。
    • Exception 类型的异常通常是可预测的，程序员可以通过编码规范、输入验证等方式来避免一些常见的异常情况。

总的来说，Error 类型的异常表示程序运行时的严重问题，一般不需要程序员显示处理；而 Exception 类型的异常表示程序运行时的一般异常情况，通常需要程序员进行处理。在实际开发中，程序员主要关注处理 Exception 类型的异常，对于 Error 类型的异常则由系统或虚拟机来处理。

36、Java 中常见的异常有哪些？

Java 中常见的异常可以分为可检查异常（Checked Exception）和不可检查异常（Unchecked Exception），以下是一些常见的异常：

  1. 可检查异常（Checked Exception）：
    • IOException：输入输出异常，如文件读写异常。
    • SQLException：数据库操作异常。
    • ClassNotFoundException：类未找到异常。
    • InterruptedException：线程中断异常。
    • NoSuchMethodException：方法未找到异常。
    • NoSuchFieldException：字段未找到异常。
    • CloneNotSupportedException：克隆不支持异常。
    • FileNotFoundException：文件未找到异常。
    • EOFException：文件末尾异常。
  2. 不可检查异常（Unchecked Exception）：
    • NullPointerException：空指针异常，访问了空引用。
    • ArrayIndexOutOfBoundsException：数组越界异常。
    • ClassCastException：类型转换异常。
    • IllegalArgumentException：非法参数异常。
    • IllegalStateException：非法状态异常。
    • ArithmeticException：算术异常，如除以零。
    • NumberFormatException：数字格式异常，如字符串转换为数字时格式不正确。
    • IndexOutOfBoundsException：索引越界异常，如字符串或集合访问时索引超出范围。
    • SocketException：网络通信异常。
    • RuntimeException：运行时异常的基类，包括所有不需要显式捕获的异常。

需要注意的是，Java 中的异常是通过继承 Throwable 类来实现的，而 Throwable 的子类主要分为 Error 类型和 Exception 类型，其中 Error 类型通常表示严重的系统问题，而 Exception 类型则表示程序运行时的一般异常情况。在实际开发中，程序员主要关注处理 Exception 类型的异常，对于 Error 类型的异常通常由系统或虚拟机来处理。

37、Java 中常见的运行时异常有哪些？

Java 中常见的运行时异常主要包括以下几种：

  1. NullPointerException：空指针异常，通常发生在尝试访问空对象的属性或调用空对象的方法时。
  2. ArrayIndexOutOfBoundsException：数组越界异常，通常发生在尝试访问数组索引超出范围时。
  3. ClassCastException：类型转换异常，通常发生在尝试将一个对象转换为不兼容的类型时。
  4. IllegalArgumentException：非法参数异常，通常发生在方法参数不满足预期条件时。
  5. IllegalStateException：非法状态异常，通常发生在对象处于不正确的状态下进行操作时。
  6. ArithmeticException：算术异常，通常发生在除法运算时除数为零的情况。
  7. NumberFormatException：数字格式异常，通常发生在字符串转换为数字时格式不正确的情况。
  8. IndexOutOfBoundsException：索引越界异常，通常发生在集合或字符串访问时索引超出范围。

除了以上列举的常见运行时异常外，还有其他的运行时异常，例如：

  • ConcurrentModificationException：并发修改异常，通常发生在使用迭代器遍历集合时修改了集合结构。
  • UnsupportedOperationException：不支持的操作异常，通常发生在调用不支持的操作时。
  • NoClassDefFoundError：类未定义错误，在运行时找不到类的定义时抛出。

这些运行时异常通常表示程序运行时的逻辑错误或异常情况，可以通过编码规范和异常处理机制来避免或处理这些异常。

38、运行时异常与受检查异常有什么区别？

运行时异常（RuntimeException）和受检查异常（Checked Exception）是 Java 中两种不同的异常类型，它们之间的主要区别在于编译器在编译时是否强制要求程序员进行异常处理。

  1. 运行时异常（RuntimeException）：
    • 运行时异常是指继承自 RuntimeException 的异常类，它们通常表示程序在运行时出现的逻辑错误或异常情况，比如空指针异常（NullPointerException）、数组越界异常（ArrayIndexOutOfBoundsException）、类型转换异常（ClassCastException）等。
    • 编译器在编译时不会强制要求程序员捕获处理这些异常，因此也称为不受检查异常（Unchecked Exception）。
    • 程序员可以选择捕获处理这些异常，但不是强制性的，可以通过编码规范和良好的设计来避免这些异常的发生。
  2. 受检查异常（Checked Exception）：
    • 受检查异常是指继承自 Exception 但不继承自 RuntimeException 的异常类，它们通常表示程序在运行时可能出现的可预测的异常情况，比如文件未找到异常（FileNotFoundException）、输入输出异常（IOException）等。
    • 编译器在编译时会强制要求程序员捕获处理这些异常，或者通过 throws 关键字声明抛出，否则会编译报错。
    • 程序员必须显式地处理这些异常，以保证程序的健壮性和可靠性。

总的来说，运行时异常是不受检查的异常，在编译时不会强制要求程序员捕获处理；而受检查异常是需要受到编译器检查并强制要求程序员捕获处理或者声明抛出的异常。在实际开发中，程序员应该根据具体情况选择合适的异常处理策略，保证程序的稳定性和可靠性。

39、什么时候会发生空指针异常？

空指针异常（NullPointerException）通常在以下情况下会发生：

  1. 访问空对象的属性：当尝试访问一个空对象的属性（成员变量）时，会触发空指针异常。例如：

    String str = null;
int length = str.length(); // 这里会抛出空指针异常，因为 str 是空对象

  2. 调用空对象的方法：当尝试调用一个空对象的方法时，会触发空指针异常。例如：

    String str = null;
str.toLowerCase(); // 这里会抛出空指针异常，因为 str 是空对象

  3. 数组操作：当尝试对空数组进行操作时，比如获取数组的长度、访问数组元素等，会触发空指针异常。例如：

    int[] array = null;
int length = array.length; // 这里会抛出空指针异常，因为 array 是空数组

  4. 使用未初始化的变量：如果某个变量没有被初始化，尝试访问它的值时也会触发空指针异常。例如：

    String str;
int length = str.length(); // 这里会抛出空指针异常，因为 str 没有被初始化

  5. 对象的引用为空：当一个对象的引用为空（即指向 null），但尝试使用该引用进行操作时，会触发空指针异常。例如：

    MyClass obj = null;
obj.someMethod(); // 这里会抛出空指针异常，因为 obj 是空引用

空指针异常通常是由于程序中未正确初始化对象或者对空对象进行操作导致的，可以通过在使用前进行有效的空值检查或者避免使用空对象来预防空指针异常的发生。

40、你知道有哪些避免空指针的方法？

避免空指针异常的方法主要包括以下几种：

  1. 空值检查：在使用对象之前，先检查对象是否为空（null）。可以使用 if 语句或者 Optional 类来进行空值检查，以避免空指针异常的发生。例如：

    String str = null;
if (str != null) {
    int length = str.length(); // 避免空指针异常
}

  2. 使用 Optional 类：Java 8 引入的 Optional 类可以有效避免空指针异常的发生。通过 Optional 类的方法，可以在获取对象时进行空值检查并安全地处理空值情况。例如：

    Optional<String> optionalStr = Optional.ofNullable(str);
int length = optionalStr.map(String::length).orElse(0); // 避免空指针异常，如果 str 为空则返回 0

  3. 空安全的方法调用：使用空安全的方法调用可以避免在空对象上调用方法时发生空指针异常。例如，使用 Objects 类的静态方法或者 Optional 类的方法来进行空安全的方法调用：

    String str = null;
int length = Objects.requireNonNullElse(str, "").length(); // 避免空指针异常

  4. 避免未初始化变量：确保在使用变量之前对其进行正确的初始化，避免使用未初始化的变量，以免发生空指针异常。例如：

    String str = ""; // 初始化为空字符串
int length = str.length(); // 避免空指针异常

  5. 使用条件表达式或 Optional 类来处理空对象：在需要使用对象的地方，可以使用条件表达式或者 Optional 类的方法来处理可能为空的对象，从而避免空指针异常的发生。例如：

    String str = null;
int length = (str != null) ? str.length() : 0; // 使用条件表达式避免空指针异常

通过以上方法，可以有效地避免空指针异常的发生，提高程序的稳定性和可靠性。

41、throw 和 throws 的区别？

throw 和 throws 是 Java 中与异常处理相关的两个关键字，它们的作用和用法有所不同：

  1. throw：

    • throw 是一个关键字，用于在程序中手动抛出异常对象。当程序发生某种异常情况时，可以使用 throw 关键字抛出一个异常对象，表示异常的发生。throw 的语法格式为：throw new ExceptionType();，其中 ExceptionType 是要抛出的异常类型。

    • 例如，手动抛出一个空指针异常：

      throw new NullPointerException("This is a NullPointerException");

  2. throws：

    • throws 是一个关键字，用于声明方法可能抛出的异常类型。当方法中存在可能会抛出异常的代码时，可以使用 throws 关键字在方法签名中声明该方法可能抛出的异常类型，通知调用该方法的代码处理可能的异常。throws 的语法格式为：public void methodName() throws ExceptionType1, ExceptionType2, ...;，其中 ExceptionType1, ExceptionType2, ... 是方法可能抛出的异常类型。

    • 例如，声明一个方法可能抛出 IOException 和 SQLException：

      public void readFile() throws IOException, SQLException {
    // 读取文件的代码，可能会抛出 IOException 和 SQLException
}

总的来说，throw 用于手动抛出异常对象，表示异常的发生；而 throws 用于在方法签名中声明方法可能抛出的异常类型，通知调用者处理可能的异常。它们是 Java 中异常处理机制中不可或缺的两个关键字。

42、try-catch-finally 中哪个部分可以省略？

在 Java 的异常处理中，try-catch-finally 结构中的 catch 块和 finally 块是可以省略其中一个或者两个的，但 try 块是必须存在的。

  1. 省略 catch 块：

    • 如果没有必要处理异常的情况，可以省略 catch 块。这种情况下，只有 try 块和 finally 块。

    • 例如，只关心资源释放，不需要处理异常情况：

      try {
    // 可能发生异常的代码
} finally {
    // 无论是否发生异常，都会执行的代码，比如资源释放
}

  2. 省略 finally 块：

    • 如果不需要在异常处理完毕后执行特定的代码，可以省略 finally 块。这种情况下，可以只有 try 块和 catch 块。

    • 例如，只需要捕获并处理异常，不需要特定的资源释放或清理操作：

      try {
    // 可能发生异常的代码
} catch (Exception e) {
    // 异常处理代码
}

  3. 同时省略 catch 和 finally 块：

    • 在某些情况下，可能只需要尝试执行一段代码，不需要处理异常也不需要在执行后进行资源清理，这种情况下可以省略 catch 块和 finally 块，只保留 try 块。

    • 例如，只需要尝试打开一个文件，不需要处理异常或者关闭文件资源：

      try {
    // 尝试打开文件的代码
}

总的来说，try 块是必须存在的，而 catch 块和 finally 块可以根据具体情况省略其中一个或者两个。根据程序逻辑和需求，灵活选择是否需要处理异常以及是否需要在异常处理完毕后执行特定的清理操作。

43、try 里面 return，finally还会执行吗？

在 Java 中，如果在 try 块中使用了 return 语句并且在 finally 块中也存在代码，那么无论 try 块中是否执行了 return，finally 块都会执行。

finally 块中的代码在以下情况下都会执行：

  1. try 块中没有发生异常：如果 try 块中没有发生异常，并且执行了 return 语句，finally 块中的代码依然会执行。这是因为 finally 块中的代码在 return 语句之前执行。

    public static void main(String[] args) {
    System.out.println(test());
}

public static int test() {
    try {
        return 1;
    } finally {
        System.out.println("Finally block executed");
    }
}

    输出结果：

    scssCopy codeFinally block executed
1

  2. try 块中发生异常：如果 try 块中发生异常，并且在 catch 块或 try 块中执行了 return 语句，finally 块中的代码依然会执行。这是因为 finally 块用于执行清理工作，无论是否发生异常都应该执行。

    public static void main(String[] args) {
    System.out.println(test());
}

public static int test() {
    try {
        int a = 1 / 0; // 引发算术异常
        return 1;
    } catch (Exception e) {
        return 2;
    } finally {
        System.out.println("Finally block executed");
    }
}

    输出结果：

    Finally block executed
2

因此，无论 try 块中是否执行了 return，finally 块中的代码都会执行。finally 块通常用于确保资源的释放或清理工作得到执行，无论是否发生异常。

43.finally 里面的在那些情况下不会被执行？

在 Java 中，finally 块中的代码通常会被执行，但在以下情况下不会执行 finally 块中的代码：

  1. System.exit() 方法：当程序使用 System.exit() 方法终止时，finally 块中的代码不会被执行。因为 System.exit() 方法会直接终止程序的执行，不会再执行 finally 块中的代码。

    public static void main(String[] args) {
    try {
        System.exit(0);
    } finally {
        System.out.println("Finally block executed");
    }
}

  2. 在执行 try 块之前发生了异常：如果在执行 try 块之前发生了异常，导致程序无法进入 try 块，那么 finally 块中的代码也不会执行。

    public static void main(String[] args) {
    int a = 1 / 0; // 引发算术异常，无法进入 try 块
    try {
        System.out.println("Inside try block");
    } finally {
        System.out.println("Finally block executed");
    }
}

  3. 在执行 try 块中的 return 语句之前抛出异常：如果在执行 try 块中的 return 语句之前抛出了异常，导致程序无法正常返回，那么 finally 块中的代码也不会执行。

    public static void main(String[] args) {
    System.out.println(test());
}

public static int test() {
    try {
        int a = 1 / 0; // 引发算术异常，无法执行 return 语句
        return 1;
    } finally {
        System.out.println("Finally block executed");
    }
}

在以上情况下，finally 块中的代码都不会被执行。除此之外，通常情况下 finally 块中的代码都会被执行，用于确保资源的释放或清理工作。

44、int 和 Integer 有什么区别？

int 和 Integer 是 Java 中表示整数的两种数据类型，它们之间有以下区别：

  1. 基本数据类型 vs 包装类：
    • int 是 Java 的基本数据类型之一，用于表示整数值，占用 4 个字节（32 位），范围为 -2,147,483,648 到 2,147,483,647。
    • Integer 是 int 的包装类，是一个引用类型，用于将基本数据类型 int 封装为对象。在使用 Integer 类型时，可以调用其提供的方法来操作整数值。
  2. 自动装箱与拆箱：
    • Java 提供了自动装箱（Autoboxing）和自动拆箱（Unboxing）的功能，可以方便地在基本数据类型 int 和包装类 Integer 之间进行转换。
    • 自动装箱是将基本数据类型自动转换为对应的包装类对象，例如 int 自动转换为 Integer。
    • 自动拆箱是将包装类对象自动转换为对应的基本数据类型，例如 Integer 自动转换为 int。
  3. 对象和值的区别：
    • int 是一个原始数据类型，直接存储整数的值。
    • Integer 是一个对象，可以在其中存储整数值，并且可以调用其方法来进行操作。
  4. 空值处理：
    • int 是基本数据类型，不能存储空值（null）。
    • Integer 是一个对象，可以存储空值（null），在需要表示可能为空的整数时，可以使用 Integer 类型。

总的来说，int 是基本数据类型，而 Integer 是对 int 的包装类，提供了一些额外的功能，例如可以存储空值、可以调用方法等。在使用时可以根据需要选择使用基本数据类型 int 还是包装类 Integer。

45、什么是包装类型？有什么用？

包装类型（Wrapper Class）是 Java 中用来将基本数据类型包装为对象的类。在 Java 中，每种基本数据类型都有对应的包装类型，它们是：

  1. Byte：对应 byte
  2. Short：对应 short
  3. Integer：对应 int
  4. Long：对应 long
  5. Float：对应 float
  6. Double：对应 double
  7. Character：对应 char
  8. Boolean：对应 boolean

包装类型的主要用途包括：

  1. 将基本数据类型转换为对象：包装类型允许将基本数据类型转换为对应的对象。这样做的好处是可以在对象上调用方法，进行更丰富的操作，同时可以使用泛型和集合类等需要对象类型的场景。

    Integer num = 10; // 自动装箱，将基本数据类型 int 转换为 Integer 对象

  2. 空值处理：包装类型可以存储空值（null），而基本数据类型不支持空值。在需要表示可能为空的场景下，可以使用包装类型。

    Integer num = null; // 表示一个可能为空的整数值

  3. 泛型限制：在泛型中，只能使用类对象而不能使用基本数据类型，因此需要使用包装类型作为泛型参数。

    List<Integer> numbers = new ArrayList<>(); // 使用 Integer 包装类型作为泛型参数
numbers.add(1);
numbers.add(2);

  4. 提供了一些额外的方法：包装类型提供了一些额外的方法，例如可以通过 Integer.parseInt(String) 方法将字符串转换为整数，还有比较、计算等方法。

    int value = Integer.parseInt("10"); // 将字符串 "10" 转换为整数值 10

总的来说，包装类型允许将基本数据类型转换为对象，提供了更多的操作和功能，同时也解决了一些在基本数据类型中无法实现的需求，例如空值处理和泛型限制。在实际开发中，可以根据需求选择使用基本数据类型或者包装类型。

46、什么是自动装厢、拆厢？

自动装箱（Autoboxing）和自动拆箱（Unboxing）是 Java 中的两个特性，用于方便地在基本数据类型和对应的包装类型之间进行转换。

  1. 自动装箱（Autoboxing）：

    • 自动装箱是指将基本数据类型自动转换为对应的包装类型对象的过程。当程序需要使用包装类型对象时，如果直接使用基本数据类型，编译器会自动将其转换为对应的包装类型对象。

    • 例如，将 int 类型的整数赋值给 Integer 对象，或者将 char 类型的字符赋值给 Character 对象，都属于自动装箱。

      int num1 = 10;
Integer num2 = num1; // 自动装箱，将 int 类型转换为 Integer 对象

  2. 自动拆箱（Unboxing）：

    • 自动拆箱是指将包装类型对象自动转换为对应的基本数据类型的过程。当程序需要使用基本数据类型时，如果直接使用包装类型对象，编译器会自动将其转换为对应的基本数据类型。

    • 例如，将 Integer 对象赋值给 int 类型的变量，或者将 Character 对象赋值给 char 类型的变量，都属于自动拆箱。

      Integer num1 = 10;
int num2 = num1; // 自动拆箱，将 Integer 对象转换为 int 类型

自动装箱和自动拆箱的出现简化了代码编写的过程，使得基本数据类型和包装类型之间的转换更加方便和自然，提高了代码的可读性和易用性。

47、你怎么理解 Java 中的强制类型转换？

在 Java 中，强制类型转换（Type Casting）是指将一个数据类型转换为另一个数据类型的过程。这种转换通常涉及到将一个更大范围的数据类型转换为更小范围的数据类型，需要显示地指定类型转换操作。强制类型转换可以分为两种情况：

  1. 基本数据类型的强制类型转换：

    • 当将一个数据类型的值转换为另一个数据类型时，如果目标数据类型的范围比原始数据类型小，就需要进行强制类型转换。

    • 例如，将 long 类型的值转换为 int 类型，或者将 double 类型的值转换为 float 类型，都需要进行强制类型转换。

      long num1 = 100L;
int num2 = (int) num1; // 强制类型转换，将 long 类型转换为 int 类型

  2. 对象之间的强制类型转换：

    • 当需要将一个对象的类型转换为另一个对象的类型时，也需要进行强制类型转换。这种情况下，通常需要满足一定的条件，例如父类对象转换为子类对象，或者接口实现类对象转换为接口对象。

    • 例如，将一个父类对象转换为子类对象：

      class Parent {}
class Child extends Parent {}

Parent parent = new Child();
Child child = (Child) parent; // 强制类型转换，将 Parent 类型转换为 Child 类型

需要注意的是，强制类型转换可能会造成数据丢失或者引发 ClassCastException 异常，因此在进行强制类型转换时需要谨慎考虑，并确保转换的安全性。此外，基本数据类型之间的转换通常只涉及范围的变化，而对象之间的转换涉及到继承、接口实现等更复杂的关系。

48、你怎么理解 Java 中的自动类型转换？

在 Java 中，自动类型转换（Automatic Type Conversion）指的是编译器在某些情况下自动将一种数据类型转换为另一种数据类型的过程，而无需显示地指定类型转换操作。自动类型转换通常发生在数据类型之间存在继承或者兼容关系的情况下，目标数据类型的范围大于或等于原始数据类型的范围。

自动类型转换的情况包括：

  1. 小范围类型向大范围类型的转换：

    • 当将一个小范围的数据类型转换为一个大范围的数据类型时，编译器会自动进行类型转换，因为数据类型的范围越大，可以表示的值的范围也就越大。

    • 例如，将一个 byte 类型的值赋给一个 int 类型的变量，或者将一个 float 类型的值赋给一个 double 类型的变量，都属于自动类型转换。

      byte num1 = 10;
int num2 = num1; // 自动类型转换，将 byte 类型转换为 int 类型

  2. 子类对象向父类对象的转换：

    • 当一个子类对象赋值给一个父类类型的变量时，编译器会自动进行类型转换，因为子类对象是父类对象的一种特殊情况。

    • 例如，将一个子类对象赋给一个父类类型的变量，或者将一个实现类对象赋给一个接口类型的变量，都属于自动类型转换。

      class Parent {}
class Child extends Parent {}

Child child = new Child();
Parent parent = child; // 自动类型转换，将 Child 类型转换为 Parent 类型

自动类型转换是 Java 中的一种便捷特性，能够简化代码编写的过程，提高代码的可读性和易用性。但需要注意的是，自动类型转换只能发生在具有继承或兼容关系的数据类型之间，并且目标数据类型的范围必须大于或等于原始数据类型的范围。

49、你怎么理解 Java 中的类型提升？

在 Java 中，类型提升（Type Promotion）指的是将低精度的数据类型自动提升为高精度的数据类型的过程。这种提升发生在表达式中涉及多种数据类型计算时，编译器会自动将较低精度的数据类型提升为较高精度的数据类型，以保证计算结果的准确性。

类型提升的规则如下：

  1. 整数类型的提升规则：

    • 如果表达式中包含了 byte、short 或者 char 类型的数据，那么这些数据在计算过程中会被自动提升为 int 类型。

    • 例如，将 byte 类型和 int 类型相加，byte 类型会被提升为 int 类型进行计算。

      byte num1 = 10;
int num2 = 20;
int result = num1 + num2; // byte 类型 num1 会被提升为 int 类型

  2. 浮点类型的提升规则：

    • 如果表达式中包含了 float 类型的数据，那么这些数据在计算过程中会被自动提升为 double 类型。

    • 例如，将 float 类型和 double 类型相加，float 类型会被提升为 double 类型进行计算。

      float num1 = 10.5f;
double num2 = 20.5;
double result = num1 + num2; // float 类型 num1 会被提升为 double 类型

  3. 混合类型的提升规则：

    • 如果表达式中同时包含了整数类型和浮点类型的数据，那么整数类型会被提升为浮点类型，然后进行计算。

    • 例如，将 int 类型和 double 类型相加，int 类型会被提升为 double 类型进行计算。

      int num1 = 10;
double num2 = 20.5;
double result = num1 + num2; // int 类型 num1 会被提升为 double 类型

类型提升的目的是为了避免精度丢失或者计算结果不准确的情况发生，保证表达式计算的结果是正确的和可预期的。因此，在 Java 中，编译器会根据数据类型的精度规则自动进行类型提升。

50、switch 是否能用在 long 上？

在 Java 中，switch 语句不能直接用于 long 类型。switch 语句可以用于以下几种数据类型：

  1. 整数类型：byte、short、char 和 int。
  2. 枚举类型（Enum）。
  3. 字符串类型（从 Java 7 开始支持）。

这意味着 switch 语句可以用于处理整数类型和枚举类型的数据，以及从 Java 7 开始可以处理字符串类型的数据。但是，switch 语句无法直接处理 long 类型的数据，因为 long 类型的数据范围较大，无法在 switch 中高效地处理。

如果需要在 switch 中处理 long 类型的数据，可以考虑将 long 类型转换为适合 switch 的类型，例如将 long 类型转换为 int 类型，前提是要确保转换后的值在 int 类型的范围内。

示例代码如下：

long num = 100L;
int numAsInt = (int) num; // 将 long 类型转换为 int 类型
switch (numAsInt) {
    case 100:
        System.out.println("Value is 100");
        break;
    default:
        System.out.println("Value is not 100");
}

在这个示例中，首先将 long 类型的数据转换为 int 类型，然后在 switch 语句中处理 int 类型的数据。需要注意的是，这种方法可能导致精度丢失或者数据范围超出 int 类型的范围，因此在转换前需要进行合理的检查和处理。

52、switch case 支持哪几种数据类型？

在 Java 中，switch 语句支持以下几种数据类型作为 case 的取值：

  1. 整数类型：
    • byte
    • short
    • int
    • char
  2. 枚举类型（Enum）：从 Java 5 开始引入了枚举类型，在 switch 中可以使用枚举类型作为 case 的取值。
  3. 字符串类型（从 Java 7 开始）：从 Java 7 开始，switch 语句支持使用字符串类型作为 case 的取值。

53、String 属于基础的数据类型吗？

在 Java 中，String 不属于基本的数据类型，而是属于引用数据类型（Reference Data Type）中的一种。Java 中的基本数据类型包括：

  1. 整数类型：byte、short、int、long
  2. 浮点类型：float、double
  3. 字符类型：char
  4. 布尔类型：boolean

而 String 是 Java 中的字符串类，用于表示一串字符序列。在 Java 中，字符串是以引用的方式进行处理的，即 String 对象存储在堆内存中，并且可以通过引用来访问和操作。

因此，尽管 String 在 Java 中被广泛使用，并且具有很多特殊的操作方法，但它并不是基本的数据类型，而是一种引用数据类型。

54、String 类的常用方法都有那些？

String 类是 Java 中用于操作字符串的核心类之一，它提供了许多常用的方法来处理字符串。以下是一些常用的 String 类方法：

  1. 获取字符串长度：
    • int length()：返回字符串的长度，即包含的字符数。
  2. 获取指定位置的字符：
    • char charAt(int index)：返回字符串中指定索引位置的字符。
  3. 字符串拼接：
    • String concat(String str)：将指定的字符串连接到此字符串的末尾。
  4. 字符串比较：
    • boolean equals(Object obj)：比较字符串内容是否相等。
    • boolean equalsIgnoreCase(String anotherString)：忽略大小写比较字符串内容是否相等。
  5. 子串操作：
    • String substring(int beginIndex)：从指定位置开始截取子串。
    • String substring(int beginIndex, int endIndex)：从指定位置开始到结束位置截取子串。
  6. 字符串搜索：
    • int indexOf(int ch)：返回指定字符在字符串中第一次出现的索引位置。
    • int indexOf(String str)：返回指定字符串在字符串中第一次出现的索引位置。
    • int lastIndexOf(int ch)：返回指定字符在字符串中最后一次出现的索引位置。
    • int lastIndexOf(String str)：返回指定字符串在字符串中最后一次出现的索引位置。
  7. 字符串替换：
    • String replace(char oldChar, char newChar)：将字符串中的指定字符替换为新的字符。
    • String replace(CharSequence target, CharSequence replacement)：将字符串中的指定字符序列替换为新的字符序列。
  8. 字符串切割：
    • String[] split(String regex)：根据指定的正则表达式将字符串分割成子串，并返回子串数组。
  9. 字符串格式化：
    • String format(String format, Object... args)：使用指定的格式字符串和参数进行格式化。
  10. 字符串大小写转换：
    • String toLowerCase()：将字符串中的所有字符转换为小写。
    • String toUpperCase()：将字符串中的所有字符转换为大写。
  11. 去除空格：
    • String trim()：去除字符串两端的空格。
  12. 判断前缀和后缀：
    • boolean startsWith(String prefix)：判断字符串是否以指定的前缀开头。
    • boolean endsWith(String suffix)：判断字符串是否以指定的后缀结尾。

这些是 String 类中常用的方法，可以满足大部分字符串操作的需求。需要注意的是，String 对象是不可变的，即一旦创建就不能修改其内容，每次对字符串的操作都会返回一个新的字符串对象。

55、String 的底层实现是怎样的？

在 Java 中，String 类的底层实现主要有两种方式：基于字符数组（char[]）和基于字节数组（byte[]）。

  1. 基于字符数组的实现：
    • 在 Java 中，String 类的最常见的底层实现方式是使用字符数组（char[]）来存储字符串的内容。每个字符对应数组中的一个元素，字符串的长度即为数组的长度。
    • 优点：基于字符数组的实现简单高效，支持对字符串的快速访问和操作。
    • 缺点：由于字符串是不可变的，每次对字符串进行修改或者拼接操作都会创建新的字符串对象，可能会导致内存浪费。
  2. 基于字节数组的实现：
    • 在某些特殊情况下，Java 中的字符串也可以使用字节数组（byte[]）来存储。这种实现方式主要用于处理二进制数据或者使用指定的字符集进行编码。
    • 优点：适用于处理二进制数据或者特定字符集的字符串，提供了更灵活的处理方式。
    • 缺点：相对于基于字符数组的实现，基于字节数组的实现可能会增加一些复杂性，并且需要考虑字符集编码的问题。

总的来说，Java 中常见的 String 类的底层实现是基于字符数组的方式，这种实现方式简单高效，并且满足了大部分字符串处理的需求。在处理特殊情况下的字符串或者需要特定字符集编码的字符串时，可以考虑使用基于字节数组的实现方式。

56、String 是可变的吗？为什么？

在 Java 中，String 类是不可变的（Immutable）。这意味着一旦创建了 String 对象，它的值就无法被修改。例如，对于一个已经存在的 String 对象，无法通过赋值或者修改操作来改变其内容。这是由于 String 类的设计和实现决定的。

String 不可变的原因有以下几点：

  1. 安全性：不可变的字符串是线程安全的，多个线程可以同时访问不可变的字符串对象而不会发生冲突，因为不会有修改操作。
  2. 缓存优化：不可变的字符串可以被缓存和重用，因为相同内容的字符串在内存中只需要存储一份，可以提高内存利用率和性能。
  3. 参数传递：不可变的字符串作为方法参数传递时，不会因为方法内部修改字符串而影响到外部的引用。
  4. 字符串常量池：Java 中的字符串常量池（String Pool）利用了字符串不可变的特性，可以节省内存，提高性能。

尽管 String 类本身是不可变的，但可以通过其他类来实现可变的字符串，例如 StringBuilder 和 StringBuffer。这两个类提供了可变的字符串操作方法，可以进行插入、删除、替换等操作，适用于需要频繁修改字符串内容的场景。

57、String 类可以被继承吗？

在 Java 中，String 类是被声明为 final 的，因此不能被继承。使用 final 关键字修饰的类表示该类是最终类，不允许其他类继承它，也就是说不能创建该类的子类。

这种设计是为了保护 String 类的不可变性。如果允许其他类继承 String 类并进行修改，可能会破坏字符串的不可变性，导致安全性和可靠性问题。因此，Java 设计者将 String 类声明为 final，确保其不可变性和线程安全性。

如果需要进行字符串操作并且需要可变性，可以使用 StringBuilder 或者 StringBuffer 类，它们提供了可变的字符串操作方法，并且不是最终类，可以被继承和扩展。

58、String 真的是不可变的吗？

在Java中，String类是不可变的，这意味着一旦创建了String对象，它的值就无法被修改。这个特性在Java中是被广泛认可的，因为它带来了一系列的优点，比如线程安全、安全性、缓存优化等。

然而，有一些特殊情况下，似乎String对象可以被修改，实际上这是因为Java对于字符串的处理有一些优化措施，看起来是在修改字符串，但实际上是在创建新的字符串对象。

举个例子：

String str = "Hello";
str = str + " World";

在这个例子中，看起来好像对str进行了修改，实际上是创建了一个新的字符串对象"Hello World"，并将其赋值给了str。原始的"Hello"字符串对象并没有被修改。

另外一个例子是使用substring()方法：

String str = "Hello World";
String newStr = str.substring(0, 5);

在这个例子中，虽然看起来好像是从str中截取了一个子串赋值给newStr，但实际上substring()方法返回的是一个新的字符串对象，原始的"Hello World"字符串对象并没有被修改。

因此，虽然有些情况下看起来好像String对象是可变的，但实际上是在创建新的字符串对象，原始的String对象并没有被修改，依然保持不可变性。

59、String 字符串如何进行反转？

要反转一个字符串，可以使用 StringBuilder 或者 StringBuffer 类中的 reverse() 方法。这两个类都提供了可变的字符串操作方法，包括字符串反转。

以下是使用 StringBuilder 类进行字符串反转的示例代码：

String original = "Hello World";
StringBuilder reversed = new StringBuilder(original).reverse();
String reversedStr = reversed.toString();
System.out.println(reversedStr); // 输出：dlroW olleH

这段代码首先创建了一个 StringBuilder 对象，并将原始字符串传入构造方法中。然后调用 reverse() 方法进行字符串反转，最后通过 toString() 方法将反转后的字符串转换为普通的字符串对象。

需要注意的是，StringBuilder 和 StringBuffer 都是可变的字符串类，可以进行插入、删除、替换等操作，因此适用于需要频繁修改字符串内容的场景。在这个例子中，使用 reverse() 方法可以很方便地实现字符串反转。

60、String 字符串如何实现编码转换？

在 Java 中，可以使用 String 类的 getBytes() 和构造函数来进行编码转换。这种方法适用于将字符串按照指定的字符集编码为字节数组，或者将字节数组按照指定的字符集解码为字符串。

  1. 字符串编码为字节数组：

    • 使用 getBytes() 方法可以将字符串按照指定的字符集编码为字节数组。

    • getBytes()

      方法有两种重载形式：

      • byte[] getBytes()：使用平台默认的字符集进行编码。
      • byte[] getBytes(String charsetName)：使用指定的字符集进行编码。

    示例代码：

    String str = "Hello World";
byte[] utf8Bytes = str.getBytes("UTF-8"); // 使用UTF-8字符集编码为字节数组

  2. 字节数组解码为字符串：

    • 使用 String 的构造函数可以将字节数组按照指定的字符集解码为字符串。
    • String(byte[] bytes, String charsetName) 构造函数可以指定字节数组的字符集进行解码。

    示例代码：

    byte[] utf8Bytes = {72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100};
String str = new String(utf8Bytes, "UTF-8"); // 使用UTF-8字符集解码为字符串

需要注意的是，在进行编码转换时，应该始终明确指定字符集，避免出现乱码或者不正确的编码结果。常见的字符集包括 UTF-8、GBK、ISO-8859-1 等，具体选择取决于实际需求和数据来源。

61、String 有没有长度限制？是多少？

在 Java 中，String 的长度是受限制的，但实际上限制的是字符串对象的总大小，而不是字符串的字符数。这个限制取决于 Java 虚拟机的具体实现和系统的内存限制。

一般来说，String 对象的长度受限于系统的可用内存。在现代的计算机系统中，通常可以容纳非常大的字符串，远远超过实际应用中所需的大小。但是，如果创建的字符串对象超过了系统可用的内存限制，就会导致 OutOfMemoryError 异常。

另外，需要注意的是，字符串在 Java 中是以 Unicode 编码方式存储的，一个 Unicode 字符可能占用一个或者多个字节，取决于具体的字符。因此，实际字符串的长度也受到字符编码方式的影响。

总的来说，Java 中的String对象的长度限制主要受系统内存限制，可以容纳非常大的字符串，但需要注意避免创建过大的字符串对象导致内存溢出异常。

62、为什么不能用 + 拼接字符串？

在 Java 中，使用 + 操作符来拼接字符串是合法且常见的做法，例如：

String str1 = "Hello";
String str2 = "World";
String result = str1 + " " + str2;
System.out.println(result); // 输出：Hello World

以上代码使用了 + 操作符来拼接两个字符串，结果是将两个字符串连接起来形成一个新的字符串。

如果说不能用 + 拼接字符串，可能是指在某些特定的情况下，使用大量的 + 操作符来拼接字符串可能会带来性能上的问题。因为每次使用 + 操作符来拼接字符串时，都会创建一个新的 String 对象，如果频繁地进行字符串拼接操作，会导致大量的临时对象产生，增加了内存的使用和垃圾回收的压力，从而影响性能。

为了避免这种性能问题，可以使用 StringBuilder 或者 StringBuffer 类来进行字符串的拼接操作。这两个类都是可变的字符串类，可以提供更高效的字符串拼接操作，避免创建过多的临时对象。

示例代码使用 StringBuilder 类来进行字符串拼接：

StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
String result = sb.toString();
System.out.println(result); // 输出：Hello World

使用 StringBuilder 类的 append() 方法可以高效地拼接字符串，而不会创建大量的临时对象。因此，在需要频繁进行字符串拼接操作时，推荐使用 StringBuilder 或者 StringBuffer 类来提高性能。

63、StringBuffer 和 StringBuilder 的区别？

StringBuffer 和 StringBuilder 都是 Java 中用于处理可变字符串的类，它们之间的主要区别在于线程安全性和性能。

  1. 线程安全性：
    • StringBuffer 是线程安全的，它的方法是同步的，即可以在多线程环境下安全使用。
    • StringBuilder 不是线程安全的，它的方法是非同步的，适合在单线程环境下使用。
  2. 性能：
    • StringBuilder 的性能通常比 StringBuffer 更好，因为它不需要进行线程同步操作，所以在单线程环境下可以获得更高的执行效率。
    • StringBuffer 的方法都是同步的，需要进行线程同步操作，可能会带来一些性能上的损失。

因此，如果在单线程环境下进行字符串操作，并且关注性能的话，推荐使用 StringBuilder。如果在多线程环境下进行字符串操作，需要考虑线程安全性的话，可以使用 StringBuffer。

示例代码使用 StringBuilder 进行字符串拼接：

StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
String result = sb.toString();
System.out.println(result); // 输出：Hello World

需要注意的是，在性能和线程安全性之间进行选择时，根据具体的应用场景和需求来决定使用哪个类。

64、StringJoiner 有什么用？

StringJoiner 是 Java 8 中引入的一个用于拼接字符串的工具类，它可以方便地将多个字符串按照指定的分隔符连接起来。

主要用途有以下几点：

  1. 拼接字符串：StringJoiner 可以将多个字符串按照指定的分隔符连接起来，生成一个新的字符串。这在需要将多个字符串拼接成一个字符串时非常有用。
  2. 自定义分隔符：可以通过构造函数指定分隔符，也可以在实例化后使用 setDelimiter() 方法来设置分隔符。这样可以灵活地控制生成的字符串格式。
  3. 添加前缀和后缀：可以通过构造函数或者 setPrefix() 和 setSuffix() 方法来设置拼接结果的前缀和后缀。这样可以在生成的字符串前后添加固定的内容。
  4. 处理空值：可以通过构造函数或者 setEmptyValue() 方法来设置当没有输入字符串时，生成的默认值。这样可以避免出现空字符串的情况。

示例代码：

StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.add("Apple");
joiner.add("Banana");
joiner.add("Cherry");

String result = joiner.toString();
System.out.println(result); // 输出：[Apple, Banana, Cherry]

在这个例子中，使用 StringJoiner 将字符串 "Apple"、"Banana" 和 "Cherry" 按照逗号和方括号进行拼接，生成了 [Apple, Banana, Cherry] 的结果。

65、Java 所有类的祖先类是哪个？

Object 类是 Java 中的根类，位于 java.lang 包下，所有其他类都直接或间接地继承自 Object 类。

66、Object 类有哪些常用的方法？

在 Java 中，所有类的祖先类是 Object 类。Object 类是 Java 中的根类，位于 java.lang 包下，所有其他类都直接或间接地继承自 Object 类。

Object 类中定义了一些常用的方法，例如：

  • toString()：返回对象的字符串表示形式。
  • equals(Object obj)：比较两个对象是否相等。
  • hashCode()：返回对象的哈希码值。
  • getClass()：返回对象的运行时类。
  • wait()、notify()、notifyAll()：用于线程间的等待和通知机制。

67、普通类和抽象类有什么区别？

普通类和抽象类在 Java 中有一些区别，主要体现在以下几个方面：

  1. 实例化：
    • 普通类可以直接实例化对象，即可以使用 new 关键字创建对象。
    • 抽象类不能直接实例化对象，即不能使用 new 关键字创建对象。因为抽象类是为了被子类继承和实现的，其中可能包含抽象方法，需要子类去实现。
  2. 方法：
    • 普通类可以包含普通的方法、静态方法、成员变量等。
    • 抽象类可以包含普通方法、抽象方法、静态方法、成员变量等。抽象方法是一种没有实现体的方法，只有方法签名，需要子类去实现。
  3. 继承：
    • 普通类可以被其他类直接继承。
    • 抽象类可以被其他类直接继承，也可以作为其他抽象类的父类。同时，抽象类也可以实现接口。
  4. 对象化：
    • 普通类的对象化是具体的，即可以创建具体的对象。
    • 抽象类的对象化是抽象的，即不能直接创建抽象类的对象，需要通过其子类来实例化。
  5. 设计目的：
    • 普通类用于表示具体的事物，有具体的实现。
    • 抽象类用于表示一类事物的抽象特征，其中可能包含一些抽象方法，需要子类去实现具体的逻辑。

总的来说，普通类是具体的、可实例化的类，而抽象类是一种更加抽象的类，其中可能包含抽象方法，需要子类去实现。抽象类主要用于抽象出一类事物的共性，提供一种模板或者规范，而不是具体的实现。

68、静态内部类和普通内部类有什么区别？

静态内部类和普通内部类在 Java 中有几点区别：

  1. 实例化：
    • 静态内部类可以直接实例化，无需依赖外部类的实例。
    • 普通内部类必须依赖于外部类的实例才能实例化。
  2. 静态性：
    • 静态内部类是静态的，可以包含静态成员变量和静态方法。
    • 普通内部类是非静态的，不能包含静态成员变量和静态方法，可以访问外部类的实例变量和方法。
  3. 依赖关系：
    • 静态内部类与外部类之间的依赖关系比较独立，即使外部类不存在实例，静态内部类仍然可以单独存在和使用。
    • 普通内部类与外部类之间的依赖关系较为密切，普通内部类可以访问外部类的实例变量和方法，并且依赖于外部类的实例。
  4. 访问权限：
    • 静态内部类可以设置为 private、protected、public 或者包级私有的访问权限。
    • 普通内部类的访问权限取决于外部类的访问权限，无法独立设置访问权限。
  5. 内存占用：
    • 静态内部类不会持有外部类的引用，因此在某些情况下可以节省内存空间。
    • 普通内部类会持有外部类的引用，可能会导致内存泄漏问题，需要注意及时释放外部类的引用。

示例代码演示了静态内部类和普通内部类的用法：

public class OuterClass {
    private static String outerStaticField = "Outer static field";
    private String outerField = "Outer field";

    // 静态内部类
    static class StaticInnerClass {
        private static String staticInnerField = "Static inner field";

        public void printOuterStaticField() {
            System.out.println(outerStaticField); // 可以直接访问外部类的静态成员变量
            // System.out.println(outerField); // 不能访问外部类的实例变量
            System.out.println(staticInnerField);
        }
    }

    // 普通内部类
    class InnerClass {
        private String innerField = "Inner field";

        public void printOuterField() {
            System.out.println(outerStaticField); // 可以访问外部类的静态成员变量
            System.out.println(outerField); // 可以访问外部类的实例变量
            System.out.println(innerField);
        }
    }

    public static void main(String[] args) {
        // 实例化静态内部类
        StaticInnerClass staticInner = new StaticInnerClass();
        staticInner.printOuterStaticField();

        // 实例化普通内部类
        OuterClass outer = new OuterClass();
        InnerClass inner = outer.new InnerClass();
        inner.printOuterField();
    }
}

在这个例子中，静态内部类 StaticInnerClass 可以直接访问外部类的静态成员变量，并且不依赖于外部类的实例。而普通内部类 InnerClass 可以访问外部类的实例变量，并且需要通过外部类的实例来实例化。

69、静态方法可以直接调用非静态方法吗？

静态方法内部不能直接调用非静态方法，因为静态方法属于类级别，而非静态方法属于对象级别，两者之间没有直接的关联。

如果静态方法需要调用非静态方法，需要通过对象实例来调用。换句话说，静态方法内部可以创建对象实例，然后通过对象实例来调用非静态方法。

70、静态变量和实例变量有什么区别？

静态变量和实例变量是 Java 中两种不同类型的变量，它们的主要区别在于作用域、存储位置和生命周期等方面：

  1. 作用域：
    • 静态变量属于类级别，被所有对象共享，可以通过类名直接访问。
    • 实例变量属于对象级别，每个对象都有一份独立的实例变量副本，必须通过对象实例来访问。
  2. 存储位置：
    • 静态变量存储在方法区（Method Area）的静态区，属于类的元数据，仅在类加载时初始化一次。
    • 实例变量存储在堆内存中，每个对象都有自己的实例变量副本，在对象创建时被初始化。
  3. 生命周期：
    • 静态变量的生命周期与类的生命周期相同，当类被加载到内存中时初始化，直到程序结束或类被卸载时销毁。
    • 实例变量的生命周期与对象的生命周期相同，当对象被创建时初始化，当对象被垃圾回收时销毁。
  4. 访问方式：
    • 静态变量可以通过类名直接访问，例如 ClassName.staticVariable。
    • 实例变量必须通过对象实例来访问，例如 object.instanceVariable。

71、内部类可以访问其外部类的成员吗？

是的，内部类可以访问其外部类的成员，包括私有、受保护、默认（包级私有）和公共成员。这种访问是因为内部类与外部类之间存在一种特殊的关系，内部类被视为外部类的一部分。

72、接口和抽象类有什么区别？

接口（Interface）和抽象类（Abstract Class）是 Java 中两种不同的抽象机制，它们在设计和使用上有一些区别：

  1. 定义方式：
    • 接口使用 interface 关键字来定义，可以包含抽象方法、默认方法、静态方法和常量。
    • 抽象类使用 abstract 关键字来定义，可以包含抽象方法、非抽象方法、静态方法和成员变量。
  2. 多继承：
    • 接口支持多继承，一个类可以实现多个接口。
    • 抽象类不支持多继承，一个类只能继承一个抽象类。
  3. 成员变量：
    • 接口中只能包含常量（public static final）成员变量，不能包含实例变量。
    • 抽象类可以包含实例变量和静态变量。
  4. 方法：
    • 接口中可以包含抽象方法、默认方法（default 关键字修饰）、静态方法（static 关键字修饰）。
    • 抽象类可以包含抽象方法、非抽象方法，可以有方法体的实现。
  5. 构造器：
    • 接口中不能定义构造器，因为接口中的成员变量默认是 public static final 的，不能通过构造器初始化。
    • 抽象类可以定义构造器，用于初始化实例变量。
  6. 继承：
    • 类实现接口时使用 implements 关键字。
    • 类继承抽象类时使用 extends 关键字。
  7. 设计目的：
    • 接口用于定义一组规范、行为或能力，表示 "是什么"，强调对象的功能。
    • 抽象类用于表示一种共性，提取出共有的属性和方法，表示 "有什么"，强调对象的本质。

总的来说，接口适合用于定义规范和行为，支持多继承，成员变量只能是常量，不能包含方法体；抽象类适合用于表示一种共性，支持单继承，可以包含非抽象方法和实例变量。在设计时，可以根据具体需求和场景选择合适的抽象机制。

73、接口是否可以继承接口？

是的，接口可以继承其他接口。这种继承关系可以让一个接口继承另一个接口的成员变量、抽象方法、默认方法、静态方法和内部接口，从而实现接口的多层次继承和组合。

74、接口里面可以写方法实现吗？

在 Java 8 之前，接口里面是不能写方法的实现的，只能定义抽象方法。但是从 Java 8 开始，引入了默认方法（Default Methods）和静态方法（Static Methods），使得接口中可以包含方法的实现。

  1. 默认方法：默认方法使用 default 关键字修饰，可以在接口中提供方法的默认实现。如果实现类没有实现该方法，会使用接口中的默认实现。示例代码如下：
public interface MyInterface {
    default void defaultMethod() {
        System.out.println("This is a default method.");
    }
}
  1. 静态方法：静态方法使用 static 关键字修饰，可以在接口中定义静态方法。示例代码如下：
public interface MyInterface {
    static void staticMethod() {
        System.out.println("This is a static method.");
    }
}

默认方法和静态方法使得接口具有了一定的灵活性和扩展性，可以在接口中提供一些通用的实现逻辑，而不需要每个实现类都去实现这些方法。需要注意的是，默认方法和静态方法不能被重写，而且默认方法不能访问实例变量。

75、抽象类必须要有抽象方法吗？

不一定。抽象类不一定要有抽象方法，它可以包含非抽象方法、抽象方法、静态方法、构造方法、成员变量等。抽象类的主要作用是为了被子类继承和扩展，可以提供一些通用的方法和属性。

76、抽象类能使用 final 修饰吗？

抽象类可以使用 final 修饰，但是这样做会导致该抽象类不能被继承，与抽象类的设计初衷相违背。通常情况下，抽象类被设计为用来被子类继承和扩展的，因此一般不会将抽象类声明为 final。

当一个抽象类被声明为 final 时，意味着这个类不能有任何子类，也就无法进行继承和扩展，因此与抽象类的设计目的相悖。一般来说，final 关键字用于修饰不能被继承或修改的类、方法或变量，而抽象类的设计初衷则是为了被继承和扩展的。

77、抽象类是否可以继承具体类？

在Java中，抽象类是可以继承具体类的，这种继承关系在语法上是合法的。抽象类的设计初衷是为了被子类继承和扩展，而具体类则是可以被继承的，因此抽象类可以继承具体类。

当抽象类继承具体类时，它会继承该具体类的所有非私有成员变量和方法。具体类的非私有成员变量和方法会被视为抽象类的一部分，子类也可以继承和使用这些成员和方法。

78、抽象类是否可以实现接口？

是的，抽象类可以实现接口。抽象类可以包含抽象方法和非抽象方法，而接口可以定义抽象方法、默认方法和静态方法，因此抽象类可以通过实现接口来实现接口中的方法，并提供自己的实现逻辑。

在抽象类实现接口时，可以选择性地实现接口中的方法，如果接口中定义了默认方法，则不需要在抽象类中实现这些默认方法。而抽象类中必须实现接口中的所有抽象方法，除非抽象类自己也是一个抽象类。

79、怎么查看一个 Java 类的字节码？

要查看 Java 类的字节码，可以使用 Java 编译器自带的 javap 命令。这个命令可以反编译 .class 文件，显示其对应的字节码信息。

以下是使用 javap 命令查看字节码的步骤：

  1. 首先，使用 Java 编译器 javac 编译 Java 源文件，生成对应的 .class 文件。假设你有一个名为 MyClass.java 的 Java 源文件，可以通过以下命令编译它：

    javac MyClass.java

  2. 编译完成后，可以使用 javap 命令查看生成的字节码信息。语法格式如下：

    javap -c MyClass

    其中，-c 参数表示显示字节码指令。

  3. 运行以上命令后，会显示 MyClass 类的字节码信息，包括类的结构、字段、方法和字节码指令等。

    示例输出可能类似于以下内容：

    Copy codeCompiled from "MyClass.java"
public class MyClass {
  public MyClass();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: return
}

通过以上步骤，你可以查看到 Java 类的字节码信息，了解类的结构、方法和字节码指令等内容。

80、Java 中的 UUID 是什么?

UUID（Universally Unique Identifier，通用唯一标识符）是一种用于唯一标识信息的标准化方法。在 Java 中，UUID 是一个由 128 位二进制数表示的标识符，通常以 32 个十六进制数字（8-4-4-4-12 的格式）的形式呈现。它的生成算法保证了 UUID 的唯一性，即使在分布式系统中也不会发生冲突。

Java 中的 java.util.UUID 类提供了生成 UUID 的方法，常用的有两种生成方式：

  1. 随机生成 UUID：使用 randomUUID() 方法可以生成一个随机的 UUID。

    import java.util.UUID;

public class UUIDExample {
    public static void main(String[] args) {
        UUID uuid = UUID.randomUUID();
        System.out.println(uuid.toString());
    }
}

    运行以上代码会生成一个类似于 6fdab4e7-4d42-42a0-b4b3-cb80a8926ebd 的随机 UUID。

  2. 根据指定的字节数组生成 UUID：使用 nameUUIDFromBytes(byte[]) 方法可以根据指定的字节数组生成一个 UUID。这种方式可以根据特定的数据生成一个唯一的 UUID。

    import java.util.UUID;

public class UUIDExample {
    public static void main(String[] args) {
        byte[] bytes = "example".getBytes();
        UUID uuid = UUID.nameUUIDFromBytes(bytes);
        System.out.println(uuid.toString());
    }
}

    运行以上代码会生成一个类似于 9d23a6a4-7c80-3b71-aee6-57260e36d0d5 的 UUID。

UUID 在分布式系统中常用于唯一标识对象、会话标识、数据库记录等，保证了全局范围内的唯一性。

81、Java 类初始化顺序是怎样的？

Java 类的初始化顺序主要包括静态变量初始化、静态代码块初始化、实例变量初始化和构造方法初始化。具体顺序如下：

  1. 静态变量初始化：静态变量按照定义顺序依次初始化，无论它们在类中的位置如何。
  2. 静态代码块初始化：静态代码块按照定义顺序依次执行，它们在类加载时被执行且只执行一次。
  3. 实例变量初始化：实例变量按照定义顺序依次初始化，会在对象实例化时执行。
  4. 构造方法初始化：构造方法在对象实例化时执行，根据实例化的顺序依次执行。

具体的示例代码如下：

package org.example;

public class InitializationOrder {
    static int staticVar1 = initializeStaticVar1();
    static int staticVar2 = initializeStaticVar2();

    int instanceVar1 = initializeInstanceVar1();
    int instanceVar2 = initializeInstanceVar2();

    static {
        System.out.println("静态代码块1");
    }

    static {
        System.out.println("静态代码块2");
    }

    {
        System.out.println("代码块1");
    }

    {
        System.out.println("代码块1");
    }

    public InitializationOrder() {
        System.out.println("构造方法");
    }

    public static int initializeStaticVar1() {
        System.out.println("静态变量1");
        return 10;
    }

    public static int initializeStaticVar2() {
        System.out.println("静态变量2");
        return 20;
    }

    public int initializeInstanceVar1() {
        System.out.println("成员变量1");
        return 30;
    }

    public int initializeInstanceVar2() {
        System.out.println("成员变量2");
        return 40;
    }

    public static void main(String[] args) {
        InitializationOrder obj = new InitializationOrder();
    }
}

运行以上代码会得到如下输出：

静态变量1
静态变量2
静态代码块1
静态代码块2
成员变量1
成员变量2
代码块1
代码块1
构造方法

从输出可以看出，静态变量初始化、静态代码块初始化、实例变量初始化和构造方法初始化的顺序是按照定义顺序依次执行的。

82、为什么成员变量命名不建议用 isXXX？

使用 isXXX 命名成员变量通常用于表示一个布尔值属性，例如 isReady、isActive 等。尽管这样的命名习惯在某些情况下很常见，但也存在一些不建议使用的情况：

  1. 引起混淆：使用 isXXX 命名成员变量可能会引起混淆，因为在 JavaBeans 规范中，isXXX 命名约定用于表示布尔属性的 getter 方法，而不是成员变量。如果一个成员变量使用了 isXXX 命名，而实际上它并不是一个布尔属性，会导致使用者误解。
  2. 与 getter 方法冲突：如果一个成员变量使用了 isXXX 命名，并且为了符合 JavaBeans 规范，提供了相应的 getter 方法 isXXX()，那么在使用这个类时，可能会误以为 isXXX 是一个 getter 方法，而实际上它是一个成员变量。
  3. 不符合命名规范：虽然 Java 编译器允许使用 isXXX 命名成员变量，但它并不符合一般的命名规范和约定，会导致代码的可读性和维护性降低。

因此，一般来说，建议避免使用 isXXX 命名成员变量，而是使用其他命名方式，如直接使用属性名或者添加前缀等，以提高代码的清晰度和易读性。

83、hashCode 有什么用？

hashCode 方法是 Java 中的一个重要方法，用于返回对象的哈希码值。哈希码是一种将对象映射到哈希表中的索引的方式，通常用于快速查找、比较对象是否相等等操作。哈希码的主要作用包括以下几个方面：

  1. 哈希表的性能：哈希码可以用于快速定位对象在哈希表中的位置，提高哈希表的查找、插入和删除等操作的性能。通过哈希码，可以将对象存储在哈希表的特定位置，从而实现快速的查找和访问。
  2. 集合类的操作：在 Java 中，像 HashMap、HashSet、Hashtable 等集合类都会用到哈希码。例如，HashMap 使用键的哈希码来确定键值对的存储位置，HashSet 使用元素的哈希码来检查元素是否已经存在等。
  3. 对象的比较：哈希码可以用于快速比较对象是否相等。在一些需要快速判断对象相等性的场景下，可以先比较对象的哈希码，如果哈希码不相等，则对象肯定不相等，可以避免进行额外的比较操作。
  4. 哈希算法的应用：哈希码还可以用于实现一些哈希算法，例如密码加密、数据摘要等领域。

在 Java 中，hashCode 方法是由 Object 类定义的，它返回对象的哈希码值。通常情况下，重写 hashCode 方法是为了保证对象在集合中的正确性，即当对象相等时，它们的哈希码也应该相等，以确保集合类的正确性和性能。

需要注意的是，虽然哈希码在很多情况下是用来加速查找和比较的，但它并不是唯一确定对象相等性的方法。在比较对象是否相等时，还需要重写 equals 方法，并保证在 equals 方法返回 true 的对象中，它们的哈希码也应该相等。

84、hashCode 和 identityHashCode 的区别？

hashCode 方法和 System.identityHashCode 方法都是用于获取对象的哈希码值，但它们之间有一些重要的区别：

  1. hashCode 方法：
    • hashCode 方法是定义在 Object 类中的一个实例方法，用于返回对象的哈希码值。
    • 默认情况下，hashCode 方法是根据对象的内部状态计算的，即对象的内容相同则哈希码相同。
    • 通常情况下，我们会重写 hashCode 方法，以便根据对象的内容定义哈希码，以确保相等对象的哈希码相同。
  2. System.identityHashCode 方法：
    • System.identityHashCode 方法是 System 类中的一个静态方法，用于返回对象的标识哈希码值。
    • 标识哈希码值是根据对象的内存地址计算的，即不同的对象具有不同的标识哈希码值，即使它们的内容相同。
    • System.identityHashCode 方法不受对象的内容影响，只与对象的标识（内存地址）有关。

总的来说，hashCode 方法是根据对象的内容来计算的，而 System.identityHashCode 方法是根据对象的标识（内存地址）来计算的。在一些特定的场景中，可能需要使用标识哈希码来区分不同的对象，而不考虑它们的内容是否相同。

85、什么是 hash 冲突？

哈希冲突是指不同的输入数据在经过哈希函数计算后，得到相同的哈希值的情况。在哈希函数的理想情况下，不同的输入应该能够均匀地映射到哈希值空间中的不同位置，从而减少哈希冲突的概率。然而，在实际应用中，由于哈希函数的映射方式以及输入数据的特性等因素，可能会导致哈希冲突的发生。

哈希冲突可能会对哈希表等数据结构的性能产生影响，因为当发生冲突时，哈希表需要解决冲突的方法，例如开放寻址法、链表法等，这些方法都会增加插入、查找和删除等操作的时间复杂度。

通常情况下，哈希冲突的概率取决于哈希函数的质量和输入数据的分布情况。为了减少哈希冲突的发生，可以采取以下几种策略：

  1. 良好的哈希函数：选择一个良好的哈希函数是减少哈希冲突的关键。良好的哈希函数应该能够将不同的输入数据均匀地映射到哈希值空间中，从而降低哈希冲突的概率。
  2. 哈希表的大小：哈希表的大小也会影响哈希冲突的概率。通常情况下，哈希表的大小应该选择为质数，并且足够大，以减少哈希冲突的发生。
  3. 解决冲突的方法：对于发生冲突的情况，需要选择合适的解决冲突的方法。常见的解决冲突的方法包括开放寻址法（线性探测、二次探测等）和链表法（拉链法）等。
  4. 数据分布：尽量使输入数据的分布均匀，避免数据集中在某个区域，从而减少哈希冲突的发生。

综上所述，哈希冲突是指不同的输入数据在哈希函数计算后得到相同的哈希值的情况，可以通过选择良好的哈希函数、适当设置哈希表大小、选择合适的解决冲突方法以及保持输入数据的均匀分布等策略来减少哈希冲突的发生。

86、equals 和 hashCode 的区别和联系？

equals 方法和 hashCode 方法是 Java 中用于处理对象相等性的两个重要方法，它们之间有一定的联系和区别：

  1. 联系：
    • equals 方法用于判断两个对象是否相等，即判断对象的内容是否相同。
    • hashCode 方法用于返回对象的哈希码值，用于快速查找对象在哈希表等数据结构中的位置。
  2. 区别：
    • 实现方式：equals 方法是一个实例方法，通常需要根据对象的内容来实现。而 hashCode 方法是一个实例方法，用于计算对象的哈希码值，可以根据对象的内容或者标识来实现。
    • 返回值类型：equals 方法的返回类型是布尔型，用于判断两个对象是否相等。hashCode 方法的返回类型是整型，用于返回对象的哈希码值。
    • 使用场景：equals 方法通常用于比较对象的内容是否相等，例如在集合类中判断两个对象是否相等。hashCode 方法通常用于实现哈希表等数据结构，以快速查找、插入和删除对象。
  3. 联系和约定：
    • 如果两个对象通过 equals 方法比较相等（即返回 true），则它们的哈希码值应该相等，即通过 hashCode 方法计算出来的哈希码值应该相同。
    • 如果两个对象的哈希码值相等（即通过 hashCode 方法返回的值相等），它们并不一定相等，需要通过 equals 方法进一步比较确定是否相等。

因此，在实现自定义类时，通常需要同时重写 equals 方法和 hashCode 方法，以保证对象的相等性判断和哈希表等数据结构的正确性。常见的约定是：如果两个对象通过 equals 方法比较相等，则它们的哈希码值应该相等；反之，如果两个对象的哈希码值相等，则它们并不一定相等，需要通过 equals 方法进一步比较。

87、两个对象 equals 相等， hashCode 也相等么？

不一定。虽然在理想情况下，如果两个对象通过 equals 方法比较相等，则它们的哈希码值应该相等，即通过 hashCode 方法计算出来的哈希码值应该相同，但这并不是绝对的规则。

Java 中的哈希码冲突是可能发生的，即不同的对象可能会有相同的哈希码值。这种情况下，即使两个对象的 equals 方法返回 true，它们的哈希码值也可能相等，但并不一定总是相等。

因此，一般来说，如果两个对象通过 equals 方法比较相等，则它们的哈希码值应该相等，但反过来并不成立：即两个对象的哈希码值相等并不一定意味着它们通过 equals 方法比较相等。这是因为哈希码值是通过哈希函数计算出来的，可能会发生冲突，导致不同的对象具有相同的哈希码值。

88、两个对象 hashCode 相等，equals 也相等么？

不一定。虽然在一般情况下，如果两个对象通过 hashCode 方法计算得到的哈希码值相等，则它们的 equals 方法比较应该返回 true，但这并不是绝对的规则。

在理想情况下，如果两个对象的哈希码值相等，那么它们应该属于同一个哈希码桶，即它们应该存储在哈希表的同一个位置。在哈希表中，通常会通过哈希码值先定位到可能的存储位置，然后再通过 equals 方法比较确保对象的相等性。

然而，由于哈希码的计算方式可能会存在冲突，即不同的对象计算得到相同的哈希码值，这种情况下就会发生哈希码碰撞。因此，即使两个对象的哈希码值相等，也不能百分之百地保证它们通过 equals 方法比较一定会返回 true。

综上所述，虽然通常情况下，如果两个对象的哈希码值相等，则它们的 equals 方法比较应该返回 true，但由于哈希码的不可逆性和可能的冲突，不能绝对保证。因此，在实现自定义类时，通常需要同时重写 hashCode 方法和 equals 方法，以保证对象相等性判断的准确性和正确性。

89、为什么重写 equals 就要重写 hashCode 方法？

重写 equals 方法时，通常也需要重写 hashCode 方法，这是因为在 Java 中，对于相等的对象，它们的哈希码值应该相等。这是一种约定和规范，确保对象在使用哈希表等数据结构时能够正确地工作。具体原因包括以下几点：

  1. 哈希表数据结构：在 Java 中，像 HashMap、HashSet 等基于哈希表实现的集合类，它们在判断两个对象是否相等时，会先比较它们的哈希码值，如果哈希码值相等，则再通过 equals 方法进一步比较确定是否相等。因此，如果两个对象通过 equals 方法比较相等，那么它们的哈希码值应该相等，以确保集合类的正确性和性能。
  2. 哈希码冲突：哈希码冲突是指不同的对象可能会有相同的哈希码值。在哈希表中，为了处理哈希码冲突，会使用一些解决冲突的方法，例如开放寻址法、链表法等。如果两个对象通过 equals 方法比较相等，但它们的哈希码值不相等，那么可能会导致它们存储在哈希表中不同的位置，从而影响集合类的正确性和性能。
  3. 约定和规范：在 Java 中，对于自定义类，默认的 hashCode 方法是根据对象的内存地址计算的，这种计算方式并不适用于对象相等性的判断。因此，为了符合约定和规范，需要重写 hashCode 方法，以确保在对象相等时，它们的哈希码值也相等。

综上所述，重写 equals 方法时，通常也需要重写 hashCode 方法，以保证对象相等性判断的正确性和一致性，确保在使用哈希表等数据结构时能够正确地工作。

90、Java 常用的元注解有哪些？

Java 中的元注解是用于注解其他注解的注解，常用的元注解有以下几种：

  1. @Target：指定注解的作用目标，例如类、方法、字段等。常用取值包括：
    • ElementType.TYPE：类、接口、枚举等。
    • ElementType.METHOD：方法。
    • ElementType.FIELD：字段。
    • ElementType.PARAMETER：方法参数。
    • ElementType.CONSTRUCTOR：构造函数。
    • ElementType.LOCAL_VARIABLE：局部变量。
    • ElementType.ANNOTATION_TYPE：注解类型。
    • ElementType.PACKAGE：包。
    • ElementType.TYPE_PARAMETER：类型参数（Java 8+）。
    • ElementType.TYPE_USE：类型使用（Java 8+）。
  2. @Retention：指定注解的保留策略，即注解在什么时候生效。常用取值包括：
    • RetentionPolicy.SOURCE：注解仅存在于源代码中，在编译后不包含在编译后的字节码中。
    • RetentionPolicy.CLASS：注解存在于编译后的字节码中，但在运行时不可通过反射获取。
    • RetentionPolicy.RUNTIME：注解存在于编译后的字节码中，并在运行时可通过反射获取。
  3. @Documented：指定注解是否包含在 Java 文档中。
  4. @Inherited：指定注解是否可以被子类继承。
  5. @Repeatable：指定注解是否可以重复应用于同一个目标，Java 8 引入。

这些元注解可以配合其他注解一起使用，用于指定注解的作用目标、保留策略、是否包含在 Java 文档中等属性。

91、Java 泛型中的 T、R、K、V、E 分别指什么？

在 Java 泛型中，通常使用一些通用的字母来表示不同类型的参数，这些通用字母的含义如下：

  1. T：表示任意类型。通常用于泛型类或泛型方法中，表示可以接受任意类型的参数或返回值。例如：

    public class Box<T> {
    private T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

  2. R：表示返回值类型。通常用于泛型方法中，表示方法的返回值类型。例如：

    public <R> R convert(T input) {
    // 转换逻辑...
}

  3. K：表示键（Key）的类型。通常用于表示映射（Map）中的键的类型。例如：

    public class MyMap<K, V> {
    private List<K> keys;
    private List<V> values;

    // 省略其他代码...
}

  4. V：表示值（Value）的类型。通常用于表示映射（Map）中的值的类型。例如：

    public class MyMap<K, V> {
    private List<K> keys;
    private List<V> values;

    // 省略其他代码...
}

  5. E：表示元素（Element）的类型。通常用于表示集合（Collection）中的元素的类型。例如：

    public class MyList<E> {
    private List<E> elements;

    // 省略其他代码...
}

这些通用字母在编写泛型类、泛型接口和泛型方法时，可以帮助我们定义更灵活、通用的代码，使得代码更加抽象和可复用。

92、Java 金额计算怎么避免精通丢失？

在 Java 中进行金额计算时，可以采取以下几种方式来避免精度丢失：

  1. 使用 BigDecimal 类：Java 中的 BigDecimal 类提供了精确的数字操作，可以避免浮点数计算中的精度丢失问题。使用 BigDecimal 类进行金额计算时，需要注意使用其提供的方法进行加减乘除等运算，而不是直接使用 +、-、*、/ 等运算符。

    BigDecimal amount1 = new BigDecimal("10.25");
BigDecimal amount2 = new BigDecimal("5.75");
BigDecimal result = amount1.add(amount2); // 加法

  2. 指定精度和舍入规则：在使用 BigDecimal 进行除法运算时，可以指定精度和舍入规则，以确保计算结果的精确性和准确性。

    BigDecimal amount1 = new BigDecimal("10.25");
BigDecimal amount2 = new BigDecimal("3");
BigDecimal result = amount1.divide(amount2, 2, RoundingMode.HALF_UP); // 保留两位小数，四舍五入

  3. 避免使用浮点数类型：尽量避免使用 float 和 double 类型进行金额计算，因为这些类型在进行精确计算时可能会导致精度丢失的问题。

  4. 注意处理小数点位置：在金额计算中，需要注意小数点的位置，确保计算结果的小数位数和精度符合预期。

  5. 避免无限循环小数：在除法运算时，如果除数和被除数可能产生无限循环小数，需要使用合适的精度和舍入规则来处理，避免结果不确定或产生错误。

综上所述，使用 BigDecimal 类、指定精度和舍入规则、避免使用浮点数类型以及注意处理小数点位置等方法可以有效避免 Java 中金额计算中的精度丢失问题。

93、Java 语法糖是什么意思？

Java 语法糖（Syntactic Sugar）指的是一种语法上的改进或简化，它并不会引入新的功能，只是为了让代码更加易读、简洁，以提高开发效率和代码可读性。语法糖通常是通过编译器在编译时将其转换成标准的 Java 代码，因此在运行时并不会有额外的开销或功能。

一些常见的 Java 语法糖包括：

  1. 泛型：Java 5 引入了泛型，使得在集合类和类库中可以使用泛型类型，避免了在使用集合时需要进行类型转换的问题，使得代码更加类型安全和简洁。

    List<String> list = new ArrayList<>(); // 使用泛型，避免类型转换

  2. 增强的 for 循环：Java 5 引入了增强的 for 循环（foreach 循环），可以更加简洁地遍历数组或集合。

    for (String item : list) {
    System.out.println(item);
}

  3. 自动装箱和拆箱：Java 5 引入了自动装箱（Autoboxing）和拆箱（Unboxing），使得基本数据类型和其对应的包装类型之间的转换更加方便。

    Integer num1 = 10; // 自动装箱
int num2 = num1; // 自动拆箱

  4. 变长参数：Java 5 引入了变长参数（Varargs），可以方便地处理可变数量的参数。

    public void printValues(String... values) {
    for (String value : values) {
        System.out.println(value);
    }
}

  5. 枚举类型：Java 5 引入了枚举类型，使得定义枚举更加简洁明了。

    enum Weekday {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

这些语法糖并不会引入新的功能或改变语言的基本特性，而是通过改进语法结构和简化代码书写来提高开发效率和代码可读性。

94、transient 关键字有什么用？

在 Java 中，transient 关键字用于修饰成员变量，表示该变量不会被序列化，即在对象序列化过程中，被标记为 transient 的变量不会被保存到持久化存储介质（如磁盘），只会在内存中存在。这主要用于一些不需要持久化的数据，例如临时缓存数据、临时计算结果等。

主要用途包括：

  1. 安全性：有些数据是敏感或者不希望被序列化存储到磁盘中的，使用 transient 关键字可以确保这些数据不会被持久化，增强数据的安全性。

    public class User implements Serializable {
    private transient String password; // 密码不会被序列化

    // 省略其他代码...
}

  2. 节省存储空间：有些数据在序列化后并不需要保存到持久化存储介质中，使用 transient 关键字可以避免将这些数据写入文件，从而节省存储空间。

  3. 提高序列化效率：不需要序列化的数据如果被标记为 transient，则在序列化过程中会跳过这些变量的序列化操作，从而提高序列化的效率。

需要注意的是，使用 transient 关键字修饰的变量在反序列化时会被赋予默认值，例如数值类型会被赋予 0，引用类型会被赋予 null。因此，在设计使用 transient 的类时，需要确保这些变量在反序列化后的状态是可接受的。

95、如何实现对象克隆？

要实现对象的克隆，可以使用以下几种方法：

  1. 实现 Cloneable 接口：Java 中的 Cloneable 接口是一个标记接口，用于指示实现类可以进行克隆操作。实现类需要重写 Object 类的 clone 方法，并且在方法中调用 super.clone() 方法来创建对象的浅拷贝（Shallow Copy）。

    public class MyClass implements Cloneable {
    private int id;
    private String name;

    // 省略其他代码...

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

    使用时可以调用对象的 clone 方法来创建克隆对象：

    MyClass original = new MyClass();
MyClass clone = (MyClass) original.clone();

    需要注意的是，clone 方法会返回一个 Object 类型的对象，需要进行强制类型转换。

  2. 使用序列化和反序列化：通过将对象序列化成字节流，然后再反序列化成对象，可以实现对象的深拷贝（Deep Copy）。

    public class DeepCopyUtil {
    public static <T extends Serializable> T clone(T object) {
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(object);

            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);

            return (T) objectInputStream.readObject();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

    使用时可以调用 DeepCopyUtil.clone 方法进行对象的深拷贝：

    MyClass original = new MyClass();
MyClass clone = DeepCopyUtil.clone(original);

    需要注意的是，对象及其所有引用类型的成员变量都需要实现 Serializable 接口，否则无法进行序列化和反序列化。

这些方法都可以实现对象的克隆，但需要根据具体需求选择合适的方法。使用 Cloneable 接口实现的克隆方式为浅拷贝，而使用序列化和反序列化实现的克隆方式为深拷贝。

96、对象克隆浅拷贝和深拷贝的区别？

对象克隆的浅拷贝和深拷贝的区别在于拷贝对象时对于对象内部引用类型的处理方式：

  1. 浅拷贝（Shallow Copy）：
    • 浅拷贝是指在拷贝对象时，只复制对象本身和其基本数据类型的成员变量，而不会复制对象内部引用类型的成员变量。
    • 拷贝后的对象和原始对象共享引用类型的成员变量，即它们指向相同的内存地址，因此修改其中一个对象的引用类型成员变量会影响到另一个对象的对应成员变量。
    • 浅拷贝通常通过实现 Cloneable 接口并重写 clone 方法来实现，或者使用对象流的序列化和反序列化方式。
  2. 深拷贝（Deep Copy）：
    • 深拷贝是指在拷贝对象时，不仅复制对象本身和其基本数据类型的成员变量，还会递归复制对象内部所有引用类型的成员变量，直到所有引用类型的成员变量都是新的对象。
    • 拷贝后的对象和原始对象拥有各自独立的引用类型成员变量，修改其中一个对象的引用类型成员变量不会影响到另一个对象的对应成员变量。
    • 深拷贝通常通过实现序列化和反序列化来实现，或者手动递归复制对象内部的引用类型成员变量。

举例来说，假设有一个包含引用类型成员变量的对象 A，并且对象 B 是对象 A 的浅拷贝或深拷贝：

  • 浅拷贝：如果对象 B 是对象 A 的浅拷贝，那么对象 A 和对象 B 的引用类型成员变量会指向同一个内存地址，即修改对象 A 的引用类型成员变量会影响到对象 B。
  • 深拷贝：如果对象 B 是对象 A 的深拷贝，那么对象 A 和对象 B 的引用类型成员变量会指向不同的内存地址，即修改对象 A 的引用类型成员变量不会影响到对象 B。

因此，深拷贝比浅拷贝更加安全和独立，但在性能和资源消耗上通常会比浅拷贝更高。在实际应用中，根据需求选择合适的拷贝方式。

97、Java 反射机制有什么用？

Java 反射机制是指在运行时动态获取类的信息并操作类的属性、方法和构造器的能力。反射机制主要通过 java.lang.reflect 包中的类实现，包括 Class、Field、Method、Constructor 等类，它们提供了一系列方法来获取类的结构信息、调用类的方法、访问和修改类的属性等。

Java 反射机制的主要作用包括：

  1. 动态加载类：通过反射可以在运行时动态加载类，无需在编译时确定类的名称，使得程序更加灵活和可扩展。
  2. 获取类的信息：可以获取类的结构信息，包括类名、父类、接口、字段、方法、构造器等，并可以通过这些信息动态操作类的属性和方法。
  3. 创建对象：可以使用反射机制动态创建对象，即使在编译时无法确定对象的具体类型，也可以根据类名动态创建对象实例。
  4. 调用方法：可以通过反射调用类的方法，包括调用公有方法、私有方法、静态方法等，并可以传递参数进行方法调用。
  5. 访问和修改属性：可以通过反射访问和修改类的属性，包括公有属性、私有属性等，从而实现动态操作对象的属性。
  6. 实现通用框架和工具：反射机制可以用于实现通用框架和工具，例如动态代理、注解处理器、对象序列化等。

虽然反射机制提供了灵活性和功能强大的能力，但也需要注意一些性能和安全性问题，例如反射操作可能会影响程序的性能，而且对私有属性和方法的访问需要慎重考虑安全性问题。因此，在使用反射机制时需要谨慎考虑，并结合实际情况选择合适的方案。

98、Java 反射机制的优缺点？

Java 反射机制具有许多优点和一些缺点，这些优点和缺点在使用反射时需要权衡和考虑。下面是 Java 反射机制的优缺点：

优点：

  1. 动态性： 反射机制可以在运行时动态获取类的信息，并且可以动态创建对象、调用方法、访问和修改属性，使得程序更加灵活和可扩展。
  2. 灵活性： 反射机制可以实现通用的框架和工具，例如动态代理、注解处理器、对象序列化等，提高了代码的复用性和通用性。
  3. 无侵入性： 反射机制可以在不修改现有代码的情况下对类的结构进行操作，减少了代码的侵入性，有利于代码的维护和扩展。
  4. 动态加载类： 反射机制可以在运行时动态加载类，无需在编译时确定类的名称，使得程序更加灵活和可配置。

缺点：

  1. 性能影响： 反射操作通常比直接调用方法或访问属性性能较低，因为反射涉及到动态查找类的信息、方法调用、属性访问等操作，会增加程序的运行时开销。
  2. 安全性问题： 反射机制可以访问和修改类的私有属性和方法，如果不加限制地使用反射，可能会影响程序的安全性，例如绕过访问权限检查直接访问私有成员。
  3. 编译时检查失效： 使用反射可以绕过编译时的类型检查，在运行时才会发现类型错误，这可能导致程序在运行时出现异常或错误。
  4. 可读性和维护性差： 使用反射机制会增加代码的复杂度，降低代码的可读性和维护性，特别是对于不熟悉反射机制的开发人员来说，理解和调试反射代码可能会更加困难。

综上所述，Java 反射机制在提供灵活性和动态性的同时，也存在一些性能、安全性、可读性和维护性等方面的缺点，因此在使用反射时需要权衡利弊，根据实际需求和情况选择合适的方案。

99、Java 反射机制 Class 类有哪些常用方法？

Java 反射机制中的 Class 类是反射的核心，它提供了一系列常用的方法来获取类的信息、属性、方法和构造器等。以下是 Class 类中常用的方法：

  1. 获取类的信息：
    • getName()：获取类的全限定名。
    • getSimpleName()：获取类的简单名称。
    • getCanonicalName()：获取类的规范名称。
    • getTypeParameters()：获取类的泛型参数类型。
  2. 获取类的修饰符：
    • getModifiers()：获取类的修饰符，返回一个整数，可以通过 Modifier 类进行解析。
    • isPublic()、isPrivate()、isProtected()：判断类的访问修饰符。
  3. 获取类的父类和接口：
    • getSuperclass()：获取类的父类。
    • getInterfaces()：获取类实现的接口数组。
  4. 获取类的构造器：
    • getConstructors()：获取类的公有构造器数组。
    • getDeclaredConstructors()：获取类的所有构造器数组，包括私有构造器。
  5. 获取类的字段（属性）：
    • getFields()：获取类的公有字段数组。
    • getDeclaredFields()：获取类的所有字段数组，包括私有字段。
  6. 获取类的方法：
    • getMethods()：获取类的公有方法数组，包括继承自父类的方法。
    • getDeclaredMethods()：获取类的所有方法数组，包括私有方法，但不包括继承的方法。
  7. 获取类的注解：
    • getAnnotations()：获取类的所有注解。
    • getDeclaredAnnotations()：获取类声明的所有注解。
  8. 创建类的实例：
    • newInstance()：通过默认构造器创建类的实例，相当于调用 new 关键字。
  9. 判断类之间的关系：
    • isAssignableFrom(Class<?> cls)：判断当前类是否可以赋值给参数指定的类。
  10. 其他方法：
    • isInterface()、isArray()、isEnum()、isPrimitive()：判断类是否为接口、数组、枚举、基本数据类型。
    • getEnumConstants()：获取枚举类的枚举常量数组。

100、Java 反射可以访问私有方法吗？

Java 反射机制可以访问私有方法。通过反射，可以获取类的所有方法，包括公有方法和私有方法，并且可以调用这些方法。

在使用反射调用私有方法时，需要先通过 getDeclaredMethod() 方法或 getDeclaredMethods() 方法获取类的所有方法，然后通过设置方法的访问权限为可访问（即调用 setAccessible(true) 方法），最后使用 invoke() 方法调用私有方法。

import java.lang.reflect.Method;

public class MyClass {
    private void privateMethod() {
        System.out.println("私有方法被调用");
    }

    public static void main(String[] args) throws Exception {
        MyClass obj = new MyClass();

        // 获取私有方法
        Method privateMethod = MyClass.class.getDeclaredMethod("privateMethod");

        // 设置方法的访问权限为可访问
        privateMethod.setAccessible(true);

        // 调用私有方法
        privateMethod.invoke(obj);
    }
}

101、Java 反射可以访问私有变量吗？

Java 反射机制可以访问私有变量。通过反射，可以获取类的所有字段（包括公有字段和私有字段），并且可以获取和修改这些字段的值。

在使用反射访问私有变量时，需要先通过 getDeclaredField() 方法或 getDeclaredFields() 方法获取类的所有字段，然后通过设置字段的访问权限为可访问（即调用 setAccessible(true) 方法），最后可以使用 get() 方法获取私有变量的值，使用 set() 方法修改私有变量的值。

import java.lang.reflect.Field;

public class MyClass {
    private String privateField = "私有字段的初始值";

    public static void main(String[] args) throws Exception {
        MyClass obj = new MyClass();

        // 获取私有字段
        Field privateField = MyClass.class.getDeclaredField("privateField");

        // 设置字段的访问权限为可访问
        privateField.setAccessible(true);

        // 获取私有字段的值
        String value = (String) privateField.get(obj);
        System.out.println("私有字段的值为：" + value);

        // 修改私有字段的值
        privateField.set(obj, "修改后的私有字段值");

        // 再次获取私有字段的值
        String modifiedValue = (String) privateField.get(obj);
        System.out.println("修改后的私有字段的值为：" + modifiedValue);
    }
}

102、Class.forName 和 ClassLoader 的区别？

Class.forName 和 ClassLoader 都是 Java 中用于加载类的机制，但它们之间有一些区别：

  1. Class.forName：
    • Class.forName(String className) 是一个静态方法，用于根据类的全限定名（包括包路径）加载类并返回对应的 Class 对象。
    • Class.forName 方法默认会执行类的静态代码块，即在加载类的同时会执行类的静态初始化。
    • 如果在加载类的过程中发生异常（例如类名拼写错误、类文件找不到等），Class.forName 方法会抛出 ClassNotFoundException 异常。
  2. ClassLoader：
    • ClassLoader 是一个抽象类，Java 中的类加载机制就是通过 ClassLoader 来实现的。
    • ClassLoader 类的子类（例如 URLClassLoader、AppClassLoader 等）负责实际的类加载工作，根据指定的类路径或者其他方式来加载类。
    • ClassLoader 允许动态地加载类，可以通过自定义 ClassLoader 的方式实现更灵活的类加载策略，例如从网络、数据库中加载类。
    • ClassLoader 类的 loadClass(String className) 方法用于加载类，但不会执行类的静态代码块，只有在调用类的静态方法或者创建类的实例时才会执行类的静态初始化。

总的来说，Class.forName 是一个静态方法，用于加载并初始化类，会执行类的静态代码块，并且在加载过程中可能抛出异常；而 ClassLoader 是一个抽象类，负责类的加载工作，允许自定义类加载策略，并且加载类时不会执行类的静态代码块，只有在需要时才会执行类的静态初始化。

103、什么是宏变量和宏替换？

java中的枚举

104、什么是逃逸分析？

逃逸分析（Escape Analysis）是编译器在编译 Java 代码时进行的一种优化技术，用于分析对象的作用域，确定对象的生命周期和存储位置，以便进行针对性的优化。逃逸分析主要用于优化对象的分配和回收，以减少内存的开销和提高程序的性能。

逃逸分析的主要目标是识别出对象的创建和使用过程中是否存在对象逃逸的情况，即对象是否在方法或线程外部被引用或访问。如果对象没有逃逸，即只在方法内部被使用，那么可以进行一些优化，例如对象的栈上分配、标量替换等，从而避免将对象分配在堆上，减少垃圾回收的开销。

逃逸分析的优化包括：

  1. 栈上分配（Stack Allocation）： 如果对象的引用不会逃逸到方法外部，可以将对象直接分配在方法的栈帧中，而不是分配在堆上，从而减少对象的创建和回收成本。
  2. 标量替换（Scalar Replacement）： 将对象的成员变量拆分成基本数据类型，并将这些基本数据类型存储在栈上，而不是存储在堆上的对象中，从而提高访问效率和减少内存占用。
  3. 同步消除（Lock Elimination）： 如果对象的锁只在方法内部使用，并且不会逃逸到其他线程，可以将锁操作优化为非同步操作，从而减少同步的开销。
  4. 逃逸分析后端优化： JIT 编译器可以根据逃逸分析的结果进行后端优化，例如方法内联、循环展开等，进一步提高程序的性能。

逃逸分析在 JIT 编译器中扮演着重要的角色，能够有效地优化 Java 代码，减少对象的创建和销毁，提高程序的运行效率和性能。

105、什么是伪共享？有什么解决方案？

伪共享（False Sharing）是一种性能问题，通常发生在多个线程同时访问共享的内存区域，但实际上这些线程并不需要共享相同的数据。当多个线程同时访问同一个缓存行（Cache Line）中的不同变量时，可能会导致缓存行失效，从而降低程序的性能。

伪共享的主要原因是现代计算机系统的缓存一般以缓存行为单位进行管理，如果多个线程访问同一个缓存行中的不同变量，那么每个线程都会将该缓存行加载到自己的 CPU 缓存中，这样就会导致多个 CPU 缓存之间频繁地进行缓存同步，从而造成性能下降。

解决伪共享的常见方案包括：

  1. 填充（Padding）： 在变量之间插入一些无关的数据（填充），使得不同变量分布在不同的缓存行中，从而避免多个线程同时访问同一个缓存行的问题。这种方式称为填充消除。

    public class PaddedObject {
    long value1;
    long padding1, padding2, padding3; // 填充，确保 value1 与 value2 分布在不同的缓存行上
    long value2;
}

  2. 对齐（Alignment）： 对变量进行适当的对齐，使得变量的起始地址与缓存行对齐，从而减少跨缓存行的访问。

  3. 线程绑定（Thread Affinity）： 将线程绑定到特定的 CPU 核心上，避免多个线程同时访问同一缓存行的问题。

  4. 使用 @Contended 注解（JDK 8+）： JDK 8 引入了 @Contended 注解，可以标记类、字段或方法，告诉 JVM 在对其进行优化时应该考虑缓存对齐的问题。

    import jdk.internal.vm.annotation.Contended;

public class ContendedObject {
    @Contended
    long value1;

    @Contended
    long value2;
}

以上是一些常见的解决伪共享的方法，不同的应用场景可能会选择不同的解决方案。在实际开发中，可以根据具体情况进行性能测试和调优，选择最适合的方案来解决伪共享问题。

106、Java 有没有 goto 关键字？

在 Java 中，是没有 goto 关键字的。Java 在设计时就明确避免了 goto 关键字，这是为了防止代码的混乱和难以维护性。相反，Java 提供了其他结构化的控制流语句来代替 goto。

107、Java 中有没有指针的概念？

在 Java 中，没有直接的指针概念，与 C 或 C++ 等语言不同，Java 程序员无法直接操作内存地址或使用指针来访问内存。这是因为 Java 语言旨在提供更高级别的抽象和安全性，避免了许多与指针相关的低级别问题，如内存泄漏、越界访问等。

Java 中主要使用引用（Reference）来代替指针的概念。在 Java 中，对象都是通过引用来访问的，而不是直接通过内存地址。引用是一个指向对象的标识符，可以用来操作对象并获取对象的成员变量和方法。

Java 的引用有以下特点：

  1. 对象的创建和销毁： 在 Java 中，对象的创建由 JVM 自动管理，不需要手动分配和释放内存，这样可以避免内存泄漏和内存越界等问题。
  2. 垃圾回收（Garbage Collection）： Java 中的垃圾回收机制可以自动识别不再使用的对象，并释放其所占用的内存空间，这样可以避免内存泄漏问题。
  3. 安全性： Java 的引用机制使得程序更加安全，可以避免许多常见的指针相关的错误，如空指针异常、内存越界等。

虽然 Java 中没有直接的指针概念，但是 Java 的引用机制提供了一种更安全、更高级别的方式来操作对象，使得程序更加可靠和易于维护。

108、Java 中的 classpath 环境变量作用？

在 Java 中，classpath 是一个环境变量，用于告诉 JVM（Java 虚拟机）在运行时从哪里加载类文件。具体来说，classpath 环境变量指定了 Java 类加载器在寻找类文件时应该搜索的路径。

classpath 的作用包括：

  1. 加载类文件： 当 Java 程序需要使用某个类时，JVM 会根据类路径搜索对应的类文件，并加载到内存中，从而使得程序可以使用该类。
  2. 加载第三方库： 如果程序依赖于第三方库或外部 JAR 包，可以通过设置 classpath 来告诉 JVM 在哪里查找这些库文件，以便程序正确地加载和使用这些库。
  3. 加载资源文件： 除了类文件外，classpath 也可以用于加载程序所需的其他资源文件，如配置文件、图像、音频等。

classpath 可以通过多种方式指定：

  • 在命令行启动 Java 程序时，可以使用 -classpath 或 -cp 参数来指定类路径，如：java -classpath /path/to/classes:/path/to/lib/* MyApp。
  • 在环境变量中设置 CLASSPATH 变量，例如 export CLASSPATH=/path/to/classes:/path/to/lib/*（Linux 或 macOS），或者在 Windows 中通过控制面板设置环境变量。
  • 在 Java 应用程序中通过代码动态设置类路径，如：System.setProperty("java.class.path", "/path/to/classes:/path/to/lib/*");。

需要注意的是，classpath 的设置方式会影响 Java 程序的运行行为，包括类的加载、资源文件的读取等。正确设置 classpath 对于程序的运行是非常重要的，可以确保程序能够正常加载所需的类和资源文件。

109、Math.round(1.5) 等于多少？

Math.round(1.5) 的结果是 2。在 Java 中，Math.round() 方法用于将浮点数四舍五入到最接近的整数。对于 1.5 这样的参数，四舍五入的规则是向最接近的整数靠拢，因此 1.5 会被四舍五入为 2。

110、Math.round(-1.5) 等于多少？

Math.round(-1.5) 的结果也是 -1。在 Java 中，Math.round() 方法对于负数也遵循四舍五入的规则，即向最接近的整数靠拢。因此，对于 -1.5 这样的参数，它会被四舍五入为 -1。

111、Java 8 都新增了哪些新特性？

Java 8 是一个重要的版本，引入了许多新特性和改进。以下是 Java 8 中新增的主要特性：

  1. Lambda 表达式： Lambda 表达式是 Java 8 中最显著的特性之一，它允许以更简洁的方式编写匿名函数，并且可以实现函数式编程的风格。
  2. Stream API： Stream API 提供了一种新的处理集合数据的方式，支持并行处理和函数式编程风格，可以大大简化集合操作和数据处理的代码。
  3. 函数式接口： Java 8 引入了 @FunctionalInterface 注解，用于定义函数式接口，即只有一个抽象方法的接口，与 Lambda 表达式配合使用。
  4. 方法引用： 方法引用是一种更简洁地调用已有方法的方式，可以替代一部分 Lambda 表达式，使代码更加清晰。
  5. 默认方法和静态方法： 接口中可以定义默认方法和静态方法，使得接口具有了更强的扩展性和功能性。
  6. Optional 类： Optional 类用于处理可能为空的值，可以避免空指针异常，并提供了一些便捷的方法来处理可选值。
  7. 新的日期和时间 API： Java 8 引入了全新的日期和时间 API，包括 LocalDate、LocalTime、LocalDateTime 等类，提供了更加简单和灵活的日期时间处理方式。
  8. 并发增强： Java 8 在并发包中引入了一些新特性，如 CompletableFuture 类用于异步编程，以及对并发操作的性能优化。
  9. 新的注解： Java 8 引入了重复注解（Repeatable Annotation）和类型注解（Type Annotation）等新的注解特性。
  10. 其他改进： 还包括对集合 API 的改进（如新增的 forEach 方法）、改进的 Nashorn JavaScript 引擎、新的编译工具等。

这些新特性使得 Java 8 在语言特性和开发体验方面有了显著的提升，同时也为后续版本的 Java 奠定了基础。

112、Java 8 中的 Lambda 表达式有啥用？

Java 8 中的 Lambda 表达式为 Java 引入了函数式编程的概念，它的主要作用包括：

  1. 简化代码： Lambda 表达式可以使代码更加简洁和清晰，尤其是对于匿名内部类的替代，可以大大减少冗余代码。
  2. 函数式编程： Lambda 表达式使得 Java 支持函数式编程的风格，可以将函数作为一等公民来使用，使得代码更加灵活和易于理解。
  3. 简化集合操作： 使用 Lambda 表达式结合 Stream API 可以轻松地进行集合操作，如过滤、映射、排序等，减少了传统的循环和条件判断。
  4. 并行处理： Lambda 表达式可以与并行流一起使用，实现并行处理数据，充分利用多核处理器提高程序的性能。
  5. 事件驱动编程： Lambda 表达式可以简化事件处理代码，如监听器和回调函数，使得事件驱动编程更加方便和直观。
  6. 延迟执行： Lambda 表达式支持延迟执行，只有在需要的时候才会执行，可以提高程序的效率和性能。

总的来说，Lambda 表达式为 Java 带来了更加现代化和灵活的编程方式，使得代码更加简洁、易读、易写，提高了开发效率和代码质量。

113、Java 8 中的 Optional 类有什么用？

Java 8 中的 Optional 类是用来解决空指针异常问题的。它的主要作用是用来表示一个可能为空的值，并提供了一些方法来安全地处理这个可能为空的值，避免了在处理空值时出现空指针异常。

Optional 类的主要用途包括：

  1. 避免空指针异常： 通过 Optional 类可以更加安全地处理可能为空的值，避免在使用空值时出现空指针异常。
  2. 强制使用者处理空值情况： 当一个方法的返回值可能为空时，可以使用 Optional 类将其包装，强制调用者在处理返回值时必须考虑空值情况，从而提高代码的健壮性。
  3. 链式调用： Optional 类提供了一系列方法，支持链式调用，使得对可能为空的值进行操作更加方便和直观。
  4. 避免显式的空值检查： 使用 Optional 类可以避免显式地进行空值检查，代码更加简洁和易读。
  5. 提供默认值： Optional 类提供了 orElse()、orElseGet() 和 orElseThrow() 等方法，可以在值为空时提供默认值或抛出异常。
  6. 更好地与流 API 配合： Optional 类与 Java 8 中的流 API 配合使用，可以更加方便地处理流中的可能为空的元素。

总的来说，Optional 类是 Java 8 中解决空指针异常问题的一种方式，它提供了一种更加安全和优雅的处理可能为空的值的方式，使得代码更加健壮和可靠。

114、Java 8 中的 Stream 有啥用？

Java 8 中的 Stream 是用来处理集合数据的流式操作 API。它的主要作用包括：

  1. 函数式编程： Stream API 支持函数式编程风格，可以使用 Lambda 表达式来对集合进行操作，使得代码更加简洁、易读和易写。
  2. 简化集合操作： Stream API 提供了一系列操作方法，如过滤、映射、排序、去重、限制数量等，可以简化集合的操作，减少了传统的循环和条件判断。
  3. 延迟执行： Stream API 支持延迟执行，只有在需要的时候才会执行，可以提高程序的效率和性能。
  4. 并行处理： Stream API 提供了并行流操作方法，可以充分利用多核处理器，实现并行处理数据，提高程序的性能。
  5. 更加灵活： Stream API 提供了丰富的操作方法，可以灵活组合和链式调用，实现复杂的数据处理逻辑。
  6. 与函数式接口配合： Stream API 与函数式接口（如 Predicate、Function、Consumer 等）配合使用，可以更加方便地进行数据处理和转换。
  7. 支持并行流： Stream API 支持并行流操作，可以在多核处理器上并行处理数据，提高程序的性能。

总的来说，Java 8 中的 Stream API 提供了一种新的集合操作方式，支持函数式编程风格，使得代码更加简洁、易读和易写，同时提供了并行处理的能力，可以提高程序的性能。通过 Stream API，可以更加方便地进行集合数据的处理和转换，使得 Java 编程更加现代化和高效。

115、Java 8 中的@Repeatable 注解有什么用？

Java 8 中的 @Repeatable 注解用于支持在同一个元素上多次使用同一种注解，以前需要通过容器注解来实现这种功能，而使用 @Repeatable 注解可以使代码更加简洁和清晰。

具体来说，@Repeatable 注解的作用是：

  1. 简化注解的使用： 使用 @Repeatable 注解可以直接在同一个元素上多次使用相同的注解，而不需要使用容器注解来包装多个注解。
  2. 提高代码可读性： 通过直接在同一个元素上使用多个相同的注解，可以使代码更加清晰和易读，避免了使用容器注解时的嵌套结构。
  3. 方便维护和修改： 使用 @Repeatable 注解可以使代码结构更加扁平化，便于维护和修改。

举个例子，假设有一个自定义注解 @Role 用于标记用户角色，使用 @Repeatable 注解可以使得同一个方法或类上可以多次标记相同的角色，例如：

@Repeatable(Roles.class)
@Retention(RetentionPolicy.RUNTIME)
public @interface Role {
    String value();
}

@Retention(RetentionPolicy.RUNTIME)
public @interface Roles {
    Role[] value();
}

使用示例：

@Role("ADMIN")
@Role("USER")
public class User {
    // 类的定义
}

上面的例子中，@Role 注解被 @Repeatable(Roles.class) 包裹，使得 User 类可以直接在同一个元素上多次使用 @Role 注解，而不需要使用 @Roles 容器注解。

116、Java 8 中的方法引用是指什么？

在 Java 8 中，方法引用（Method Reference）是一种更简洁、更直观地调用已有方法的方式，它允许直接引用一个已存在的方法，而不需要显式地编写 Lambda 表达式。

方法引用的语法形式为 方法的持有者::方法名，其中：

  • 方法的持有者 可以是类名（静态方法）、对象引用（实例方法）或者构造方法（构造方法引用）。
  • 方法名 是被引用的方法的名称。

方法引用主要有以下几种形式：

  1. 静态方法引用： 类名::静态方法名，例如 Integer::parseInt。
  2. 实例方法引用：
    • 对象引用：对象引用::实例方法名，例如 list::add。
    • 类名：类名::实例方法名，例如 String::toUpperCase。
  3. 构造方法引用： 类名::new，例如 ArrayList::new。

方法引用可以简化代码，并且使得代码更加清晰和易读。它通常用于作为 Lambda 表达式的替代，特别是当 Lambda 表达式中的代码与已有方法一致时，可以直接使用方法引用来代替 Lambda 表达式。例如：

// Lambda 表达式形式
list.forEach(element -> System.out.println(element));

// 方法引用形式
list.forEach(System.out::println);

在这个例子中，System.out::println 是一个方法引用，它引用了 System.out 的 println 方法，直接打印了集合中的每个元素。这种形式比显式地编写 Lambda 表达式更加简洁和直观。

117、Java 8 中的函数式编程怎么用？

在 Java 8 中，函数式编程主要通过 Lambda 表达式、方法引用、函数式接口以及 Stream API 来实现。以下是函数式编程在 Java 8 中的一些常用用法：

  1. Lambda 表达式： Lambda 表达式是函数式编程的重要特性之一，它可以用来替代匿名内部类，简化代码，实现函数式接口的实例化。Lambda 表达式的基本语法为 (参数列表) -> { 方法体 }，例如：

    // Lambda 表达式示例
Runnable runnable = () -> System.out.println("Hello, Lambda!");

  2. 方法引用： 方法引用是一种更简洁、直观地调用已有方法的方式，可以替代一部分 Lambda 表达式，例如：

    // 方法引用示例
list.forEach(System.out::println);

  3. 函数式接口： 函数式接口是只有一个抽象方法的接口，在 Java 8 中引入了 @FunctionalInterface 注解用于标识函数式接口，例如：

    // 函数式接口示例
@FunctionalInterface
interface MyFunction {
    void doSomething();
}

  4. Stream API： Stream API 提供了丰富的操作方法，支持函数式编程风格，可以用于对集合数据进行流式处理，例如过滤、映射、排序、归约等操作：

    // Stream API 示例
List<String> list = Arrays.asList("apple", "banana", "cherry");
list.stream()
    .filter(s -> s.startsWith("a"))
    .map(String::toUpperCase)
    .forEach(System.out::println);

  5. Optional 类： Optional 类是用来解决空指针异常问题的，可以在方法返回可能为空的值时使用，避免空指针异常，例如：

    // Optional 类示例
Optional<String> optional = Optional.ofNullable(someNullableValue);
optional.ifPresent(System.out::println);

通过使用这些功能，可以使 Java 8 中的函数式编程更加方便、灵活和高效，帮助开发者更好地应用函数式编程思想来编写现代化的 Java 代码。

118、怎么创建一个 Stream 流？

在 Java 中，可以通过多种方式创建 Stream 流，具体取决于需要处理的数据类型和数据来源。以下是几种常见的创建 Stream 流的方式：

  1. 通过集合创建流： 可以通过集合的 stream() 方法或者 parallelStream() 方法创建流。例如：

    List<String> list = Arrays.asList("apple", "banana", "cherry");
Stream<String> stream = list.stream();

  2. 通过数组创建流： 可以通过 Arrays.stream() 方法来创建数组的流。例如：

    String[] array = {"apple", "banana", "cherry"};
Stream<String> stream = Arrays.stream(array);

3. **通过静态工厂方法创建流：** Java 8 中的 `Stream` 类提供了一些静态工厂方法来创建流，例如 `Stream.of()` 方法用于创建包含指定元素的流。例如：
   ```java
   Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);

  1. 通过函数生成流： 可以通过 Stream.generate() 方法或者 Stream.iterate() 方法生成流。例如：

    Stream<Integer> generatedStream = Stream.generate(() -> new Random().nextInt(100));
Stream<Integer> iteratedStream = Stream.iterate(0, n -> n + 2).limit(10);

  2. 通过文件生成流： 可以通过 Files.lines() 方法来读取文件内容并生成流。例如：

    Path path = Paths.get("example.txt");
Stream<String> fileStream = Files.lines(path);

  3. 通过其他方式生成流： 还可以通过 Stream.builder() 方法、Pattern.splitAsStream() 方法等方式生成流，具体取决于数据来源和处理需求。

以上是一些常见的创建 Stream 流的方式，根据实际情况选择合适的方式来创建需要的流对象。

119、Oracle JDK 和 OpenJDK 有啥区别？

Oracle JDK 和 OpenJDK 都是 Java 开发工具包，但它们之间有一些区别，主要集中在授权、发布周期和支持方面：

  1. 授权：

    • Oracle JDK：Oracle JDK 是由 Oracle 公司发布的 Java 开发工具包，其中包含了 Oracle 的商业特性和组件，需要遵守 Oracle 的授权条款使用。商业环境中使用 Oracle JDK 需要购买商业许可证。
    • OpenJDK：OpenJDK 是一个开源项目，由 Java 社区维护和支持。它的授权基于 GPL 许可证，可以免费用于商业环境，也可以自由分发和修改。

  2. 发布周期：

    • Oracle JDK：Oracle JDK 的发布周期较为稳定，通常每年发布一个主要版本，例如 Java 8、Java 11、Java 17 等。
    • OpenJDK：OpenJDK 的发布周期也较为稳定，与 Oracle JDK 相关版本通常同步发布。

  3. 支持：

    • Oracle JDK：Oracle 提供商业支持服务，包括安全更新、修复漏洞等，但需要购买商业许可证才能享受这些服务。
    • OpenJDK：OpenJDK 作为一个开源项目，可以通过社区获得支持和贡献，也可以通过其他第三方提供的商业支持服务获得支持。

总的来说，Oracle JDK 和 OpenJDK 在功能和性能上没有太大区别，主要区别在于授权方式、商业支持和发布周期。对于大多数开发者和组织来说，OpenJDK 是一个更加灵活和经济实惠的选择，因为它是开源的并且可以免费使用。而对于一些需要商业支持和服务的企业来说，可能更倾向于选择 Oracle JDK，并购买商业许可证以获得 Oracle 提供的支持服务。


__EOF__

本文作者：‘陌路邑人’
本文链接：https://www.cnblogs.com/MLYR/p/18252435.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！
posted @   陌路邑人  阅读(14)  评论(0)  编辑  收藏  举报
相关博文：
· Java集合
· Spring
· Java基础知识回顾(一)
· Java面向对象基础
· 万字干货|Java基础面试题（2022版）
阅读排行：
· Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
点击右上角即可分享
微信分享提示