Java 面试笔记 - Java基础

1 、JDK、JRE 和 JVM 是 Java 开发与运行环境中的三个核心组件，它们之间的关系和区别如下：

1. JDK (Java Development Kit)

• 定义：JDK 是 Java 开发工具包，包含了开发 Java 应用程序所需的所有工具和库。
• 包含内容：
  • 编译器（javac）：将 Java 源代码编译为字节码。
  • 调试工具（jdb）：用于调试 Java 程序。
  • 其他开发工具（如 javadoc、jar 等）。
  • JRE：JDK 包含了 JRE，因此 JDK 也可以运行 Java 程序。
• 用途：用于开发 Java 应用程序。

2. JRE (Java Runtime Environment)

• 定义：JRE 是 Java 运行时环境，提供了运行 Java 应用程序所需的基本组件。
• 包含内容：
  • JVM：JRE 包含了 JVM，用于执行 Java 字节码。
  • 核心类库：Java 标准库，提供了 Java 程序运行所需的基础类。
• 用途：用于运行 Java 应用程序，但不包含开发工具。

3. JVM (Java Virtual Machine)

• 定义：JVM 是 Java 虚拟机，负责执行 Java 字节码。
• 功能：
  • 解释和执行字节码。
  • 提供内存管理、垃圾回收等功能。
  • 跨平台支持：JVM 使得 Java 程序可以在不同的操作系统上运行。
• 用途：JVM 是 Java 程序运行的核心引擎。

关系总结

• JDK ⊇ JRE ⊇ JVM：
  • JDK 包含了 JRE 和开发工具。
  • JRE 包含了 JVM 和核心类库。
  • JVM 是运行 Java 程序的核心组件。

区别总结

使用场景

• 开发：安装 JDK，因为它包含了所有开发工具。
• 运行：如果只需要运行 Java 程序，安装 JRE 即可。
• 跨平台：JVM 确保 Java 程序可以在不同操作系统上运行，实现“一次编写，到处运行”。

2 、在 Java 中，标识符是用来命名变量、方法、类、接口、包等的名称。Java 标识符的命名规则如下：

1. 基本规则

• 字符范围：
  • 可以使用字母（A-Z 或 a-z）、数字（0-9）、下划线（_）和美元符号（$）。
  • 支持 Unicode 字符，因此可以使用非英文字符（如中文、日文等），但不推荐。
• 开头字符：
  • 标识符必须以字母、下划线（_）或美元符号（$）开头，不能以数字开头。
• 长度限制：
  • 标识符的长度没有严格限制，但应保持简洁和有意义。
• 区分大小写：
  • Java 是区分大小写的，因此 myVar 和 myvar 是两个不同的标识符。

2. 关键字和保留字

• 不能使用关键字：
  • Java 的关键字（如 class、public、static 等）不能用作标识符。
• 不能使用保留字：
  • 保留字（如 goto、const 等）也不能用作标识符。

3. 命名规范

虽然 Java 对标识符的命名没有强制要求，但遵循一定的命名规范可以提高代码的可读性和可维护性。以下是常见的命名规范：

1. 类名和接口名

• 使用大驼峰命名法（PascalCase）：
  • 每个单词的首字母大写，其余字母小写。
  • 示例：MyClass, UserService, StudentRecord。

2. 方法名和变量名

• 使用小驼峰命名法（camelCase）：
  • 第一个单词的首字母小写，后续单词的首字母大写。
  • 示例：getUserName, calculateTotalPrice, isValid。

3. 常量名

• 使用全大写字母，单词之间用下划线分隔：
  • 示例：MAX_VALUE, PI, DEFAULT_TIMEOUT。

4. 包名

• 使用全小写字母，单词之间用点号（.）分隔：
  • 示例：com.example.myapp, org.apache.commons。

4. 示例

// 类名
public class MyClass {
    // 常量名
    public static final int MAX_VALUE = 100;

    // 变量名
    private String userName;

    // 方法名
    public void setUserName(String userName) {
        this.userName = userName;
    }
}

5. 注意事项

• 避免使用单个字符：
  • 除非是临时变量或循环变量（如 i、j、k），否则应避免使用单个字符作为标识符。
• 语义化命名：
  • 标识符应具有描述性，能够清晰地表达其用途。
• 避免混淆：
  • 不要使用与 Java 标准库类名相同的标识符（如 String、System 等）。

遵循这些规则和规范，可以使你的 Java 代码更加规范、易读和易于维护。

3、在 Java 中，常量和变量是用于存储数据的两种主要方式，它们的区别主要体现在以下几个方面：

1. 定义

• 变量：

  • 变量是程序中可以改变其值的数据存储单元。
  • 使用关键字 int、String、double 等声明变量。
  • 示例：

    int age = 25; // 变量 age 的值可以被修改
    age = 30;     // 合法
    

• 常量：

  • 常量是程序中一旦赋值后就不能再改变其值的数据存储单元。
  • 使用 final 关键字声明常量。
  • 示例：

    final double PI = 3.14159; // 常量 PI 的值不能被修改
    PI = 3.14;                 // 非法，编译报错
    

2. 可变性

• 变量：
  • 变量的值可以在程序运行过程中被多次修改。
• 常量：
  • 常量的值一旦赋值后就不能再修改。

3. 声明方式

• 变量：

  • 使用数据类型直接声明。
  • 示例：

    int count = 10;
    String name = "Alice";
    

• 常量：

  • 使用 final 关键字声明。
  • 示例：

    final int MAX_VALUE = 100;
    final String GREETING = "Hello";
    

4. 命名规范

• 变量：
  • 使用小驼峰命名法（camelCase）。
  • 示例：userName, totalCount。
• 常量：
  • 使用全大写字母，单词之间用下划线分隔。
  • 示例：MAX_VALUE, DEFAULT_TIMEOUT。

5. 内存分配

• 变量：
  • 变量的值存储在栈或堆中，具体取决于变量的类型（基本类型或引用类型）。
• 常量：
  • 常量的值在编译时被确定，通常存储在常量池中，以提高访问效率。

6. 用途

• 变量：
  • 用于存储程序中需要动态变化的数据。
  • 示例：计数器、用户输入、计算结果等。
• 常量：
  • 用于存储程序中固定不变的数据。
  • 示例：数学常数（如 π）、配置参数、固定的业务规则等。

7. 示例对比

public class Example {
    // 常量
    public static final double PI = 3.14159;

    public static void main(String[] args) {
        // 变量
        int radius = 5;
        double area = PI * radius * radius; // 使用常量 PI 计算面积

        System.out.println("Area: " + area);

        // 修改变量的值
        radius = 10;
        area = PI * radius * radius;
        System.out.println("Updated Area: " + area);

        // 尝试修改常量（会导致编译错误）
        // PI = 3.14; // 非法
    }
}

总结

通过合理使用常量和变量，可以使代码更加清晰、易读和易于维护。

4、Java 的基本数据类型（Primitive Data Types）是 Java 语言中预定义的、不可再分的数据类型。它们用于存储简单的数据值，而不是对象。Java 的基本数据类型共有 8 种，分为以下四类：

1. 整数类型

用于存储整数值，包括正数、负数和零。

• 示例：

  byte b = 100;
  short s = 1000;
  int i = 100000;
  long l = 10000000000L; // 注意：long 类型需要在值后加 'L'
  

2. 浮点类型

用于存储带小数部分的数值。

• 示例：

  float f = 3.14f; // 注意：float 类型需要在值后加 'f'
  double d = 3.141592653589793;
  

3. 字符类型

用于存储单个字符。

• 示例：

  char c = 'A';
  char unicodeChar = '\u0041'; // 表示字符 'A'
  

4. 布尔类型

用于存储逻辑值，只有两个可能的值：true 或 false。

• 示例：

  boolean isJavaFun = true;
  boolean isFishTasty = false;
  

5 、在 Java 中，自动类型提升和强制类型转换是处理不同类型数据之间赋值和运算的两种重要机制。它们的主要区别在于是否显式指定类型转换以及是否可能导致数据丢失。

1. 自动类型提升（Automatic Type Promotion）

• 定义：
  • 在表达式中，如果操作数的类型不一致，Java 会自动将较小的数据类型提升为较大的数据类型，以便进行计算。
  • 这种提升是隐式的，无需程序员显式指定。
  • 范围小的值赋值给范围大的值，自动类型提升。
  • 范围小的与范围大的值混合运算，自动类型提升为范围大的值的类型。
  • byte、short、char 数据类型进行算数或位运算时按int处理。
• 提升规则：
  • 如果操作数中有一个是 double，另一个操作数会被提升为 double。
  • 否则，如果有一个是 float，另一个操作数会被提升为 float。
  • 否则，如果有一个是 long，另一个操作数会被提升为 long。
  • 否则，操作数会被提升为 int。
• 示例：

  int a = 10;
  double b = 5.5;
  double result = a + b; // a 自动提升为 double
  System.out.println(result); // 输出 15.5
  

2. 强制类型转换（Type Casting）

• 定义：

  • 将一种数据类型显式转换为另一种数据类型。
  • 需要程序员手动指定，使用 (目标类型) 的语法。
  • 可能导致数据丢失（如将 double 转换为 int 时小数部分被截断）。

• 语法：

  (目标类型) 表达式
  

• 示例：

  double a = 10.5;
  int b = (int) a; // 强制将 double 转换为 int
  System.out.println(b); // 输出 10（小数部分被截断）
  

3. 自动类型提升与强制类型转换的区别

4. 自动类型提升的规则

Java 的自动类型提升遵循以下顺序（从小到大）：

byte → short → int → long → float → double → char

6、为什么 float 比 long 类型存储的范围大

在 Java 中，float 和 long 的存储范围差异源于它们的底层设计目标和数据表示方式。以下是详细解释：

1. 数据类型的存储结构

2. 为什么 float 的范围更大？

float 的范围远大于 long，核心原因是 浮点数通过指数位牺牲精度来扩展范围：

• 浮点数的组成：

  • float 使用 IEEE 754 标准 表示浮点数，其 32 位分为三部分：
    • 1 位符号位：表示正负。
    • 8 位指数位：用于表示数值的大小范围。
    • 23 位尾数位：用于表示数值的有效数字。

• 指数位的作用：

  • float 的 8 位指数 可以表示从 -126 到 +127 的指数范围，这使得它可以表示非常大或非常小的数。
  • 最大值为 (2^{127} \approx 1.7 \times 10^{38})，远大于 long 的 (2^{63} \approx 9.2 \times 10^{18})。

• 尾数位的代价：

  • float 的 23 位尾数 仅能表示约 7 位有效十进制数字，超出部分会丢失精度。
  • 例如：float 可以表示 1.234567e30，但无法精确存储 123456789012345678901234567890。

3. long 的精确性优势

• long 的 64 位完全用于整数存储，因此它可以精确表示范围内的所有整数，没有任何精度损失。
• 适用场景：
  • 需要精确计算的场景（如金融、计数器）。
  • 示例：long value = 9_223_372_036_854_775_807L;（最大值）。

4. float 的典型问题

long longValue = 9_223_372_036_854_775_807L; // 合法且精确
float floatValue = longValue;                // 转换为 float 会丢失精度！
System.out.println(floatValue);              // 输出：9.223372E18（无法还原精确值）

5. 总结对比

6. 实际应用建议

• 优先用 long：需要精确整数时（如计数器、唯一标识符）。
• 谨慎用 float：需要大范围但可接受精度损失时（如物理仿真）。
• 超大范围需求：Java 提供了 BigInteger 和 BigDecimal 类型支持任意精度计算。

总结

float 的范围比 long 大是因为它使用了指数部分来扩展数值范围，而 long 是一个固定长度的整数类型，只能表示有限范围内的精确整数值。虽然 float 的范围更大，但它以牺牲精度为代价，因此在选择数据类型时应根据具体需求权衡范围和精度的要求。

7、为什么 0.1 + 0.2 不等于 0.3？

在 Java 中，0.1 + 0.2 的结果并不是精确的 0.3，而是接近 0.3 的一个值（如 0.30000000000000004）。这种现象的根本原因在于浮点数的二进制表示方式和 IEEE 754 标准的限制。

1. 浮点数的二进制表示

• 十进制小数转二进制：

  • 十进制的小数（如 0.1 和 0.2）在转换为二进制时，可能会变成无限循环小数。
  • 例如，0.1 在二进制中是 0.00011001100110011...（无限循环），而 0.2 是 0.0011001100110011...（同样无限循环）。

• 有限精度存储：

  • 浮点数在计算机中使用有限的位数来存储，因此这些无限循环的小数必须被截断或舍入。
  • 这种舍入误差会导致计算结果不精确。

2. IEEE 754 标准

Java 使用 IEEE 754 标准来表示浮点数。根据该标准：

• 单精度浮点数 (float)：

  • 32 位，其中 1 位符号位、8 位指数位、23 位尾数位。

• 双精度浮点数 (double)：

  • 64 位，其中 1 位符号位、11 位指数位、52 位尾数位。

由于尾数位的限制，无法精确表示某些十进制小数，导致计算结果出现微小误差。

3. 具体示例

public class FloatPrecisionExample {
    public static void main(String[] args) {
        double a = 0.1;
        double b = 0.2;
        double sum = a + b;
        System.out.println("0.1 + 0.2 = " + sum); // 输出: 0.30000000000000004
    }
}

输出结果为 0.30000000000000004，而不是预期的 0.3。

4. 解决方法

为了避免浮点数的精度问题，可以采用以下几种方法：

• 使用 BigDecimal 类型：

  • BigDecimal 提供了任意精度的十进制数表示，适用于需要高精度计算的场景（如金融应用）。

  import java.math.BigDecimal;
  
  public class BigDecimalExample {
      public static void main(String[] args) {
          BigDecimal a = new BigDecimal("0.1");
          BigDecimal b = new BigDecimal("0.2");
          BigDecimal sum = a.add(b);
          System.out.println("0.1 + 0.2 = " + sum); // 输出: 0.3
      }
  }
  

• 四舍五入：

  • 如果对精度要求不高，可以通过四舍五入来处理浮点数的结果。

  public class RoundingExample {
      public static void main(String[] args) {
          double a = 0.1;
          double b = 0.2;
          double sum = Math.round((a + b) * 10) / 10.0;
          System.out.println("0.1 + 0.2 = " + sum); // 输出: 0.3
      }
  }
  

• 避免直接比较浮点数：

  • 在进行浮点数比较时，不要直接使用 ==，而是使用一个小的容差范围（epsilon）来进行比较。

  public class FloatingPointComparison {
      private static final double EPSILON = 1e-10;
  
      public static boolean nearlyEqual(double a, double b) {
          return Math.abs(a - b) < EPSILON;
      }
  
      public static void main(String[] args) {
          double a = 0.1;
          double b = 0.2;
          double sum = a + b;
          if (nearlyEqual(sum, 0.3)) {
              System.out.println("0.1 + 0.2 is approximately equal to 0.3");
          } else {
              System.out.println("0.1 + 0.2 is not equal to 0.3");
          }
      }
  }
  

5. 总结

0.1 + 0.2 不等于 0.3 是因为浮点数在二进制表示中的舍入误差。为了确保高精度计算，建议使用 BigDecimal 或其他适合的方法来处理浮点数运算。

8、++ – 在前在后有什么区别？

• 单独运算时，前后没有区别，相当于 +n 或 -n。
• 复合运算时，++ – 在前先运算再赋值，++ – 在后时先复制再运算。

9 、Java 是一种面向对象的编程语言，其核心特点包括以下几点：

1. 封装（Encapsulation）

• 定义：将数据（属性）和操作数据的方法（行为）绑定在一起，并隐藏内部实现细节。
• 实现方式：通过访问修饰符（如 private、protected、public）控制对类成员的访问。
• 优点：提高代码的安全性、可维护性和复用性。

2. 继承（Inheritance）

• 定义：子类继承父类的属性和方法，并可以扩展或重写父类的功能。
• 实现方式：通过 extends 关键字实现类与类之间的继承。
• 优点：减少代码冗余，提高代码的可重用性和可扩展性。

3. 多态（Polymorphism）

• 定义：同一操作作用于不同的对象，可以有不同的解释和执行结果。
• 实现方式：
  • 方法重载（Overloading）：同一个类中方法名相同，参数列表不同。
  • 方法重写（Overriding）：子类重写父类的方法。
  • 接口和抽象类：通过接口或抽象类实现多态。
• 优点：提高代码的灵活性和可扩展性。

4. 抽象（Abstraction）

• 定义：隐藏复杂的实现细节，只暴露必要的接口或功能。
• 实现方式：通过抽象类（abstract class）和接口（interface）实现。
• 优点：简化复杂系统的设计和实现。

5. 类与对象（Class and Object）

• 类：类是对象的模板，定义了对象的属性和行为。
• 对象：对象是类的实例，具有类定义的属性和行为。
• 特点：Java 中一切皆对象（除了基本数据类型）。

6. 其他面向对象特性

• 消息传递：对象之间通过方法调用进行通信。
• 动态绑定：在运行时确定调用哪个方法（多态的基础）。
• 组合与聚合：通过对象组合实现复杂功能，而不是仅依赖继承。

示例代码

在你的 JavaTest 类中，可以简单体现这些特性：

package org.face;

// 封装
class Animal {
    private String name; // 私有属性

    public Animal(String name) {
        this.name = name;
    }

    public void speak() { // 公共方法
        System.out.println(name + " makes a sound.");
    }
}

// 继承
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void speak() { // 方法重写
        System.out.println("Woof!");
    }
}

// 多态
public class JavaTest {
    public static void main(String[] args) {
        Animal myAnimal = new Dog("Buddy"); // 父类引用指向子类对象
        myAnimal.speak(); // 输出 "Woof!"
    }
}

总结

Java 的面向对象特性使其非常适合开发大型、复杂的应用程序，通过封装、继承、多态和抽象，可以提高代码的可维护性、可扩展性和复用性。

10、在Java中，final、finally和finalize虽然拼写相似，但它们的用途和含义完全不同。以下是它们的区别：

1. final

• 用途：final是一个关键字，用于修饰类、方法和变量。
• 作用：
  • 类：被final修饰的类不能被继承。
  • 方法：被final修饰的方法不能被子类重写。
  • 变量：被final修饰的变量一旦被赋值后，其值不能被修改（即常量）。

final class FinalClass {} // 不能被继承
class Parent {
    final void finalMethod() {} // 不能被子类重写
}
final int x = 10; // x的值不能被修改

2. finally

• 用途：finally是一个关键字，用于异常处理中的try-catch块。
• 作用：finally块中的代码无论是否发生异常都会执行，通常用于释放资源或执行清理操作。

try {
    // 可能抛出异常的代码
} catch (Exception e) {
    // 异常处理
} finally {
    // 无论是否发生异常，都会执行的代码
}

3. finalize

• 用途：finalize是Object类中的一个方法，用于垃圾回收。
• 作用：在对象被垃圾回收器回收之前，finalize方法会被调用。通常用于释放非Java资源（如文件句柄、网络连接等）。

@Override
protected void finalize() throws Throwable {
    try {
        // 清理资源
    } finally {
        super.finalize();
    }
}

总结

• final：用于修饰类、方法和变量，表示不可变。
• finally：用于异常处理，确保代码块一定会执行。
• finalize：用于垃圾回收，在对象被回收前执行清理操作。

这三者在Java中的作用和场景完全不同，理解它们的区别有助于更好地编写和维护Java代码。

11、