文章/答案/技术大牛

发布

社区首页 >专栏 >应届生面试高频 Java 基础问题及实操示例详解

应届生面试高频 Java 基础问题及实操示例详解

原创

啦啦啦191

发布于 2025-06-19 06:47:26

840

文章被收录于专栏：Java开发Java开发

一、Java数据类型有哪些？

Java数据类型分为基本数据类型和引用数据类型。

基本数据类型：
- 整数类型：byte（1字节）、short（2字节）、int（4字节）、long（8字节）。例如：int num = 10;，这里定义了一个整型变量num并赋值为10。
- 浮点类型：float（4字节，需在字面量后加f或F，如float f = 3.14f;）、double（8字节，如double d = 3.1415926;）。
- 字符类型：char（2字节），用于存储单个字符，如char c = 'A';。
- 布尔类型：boolean（1字节，值为true或false，如boolean flag = true;）。
引用数据类型：类（如String）、接口、数组等。例如String str = "Hello";，str是String类的引用，指向字符串常量池中的“Hello”对象。

实操示例：使用Java 10的局部变量类型推断

Java 10引入了var关键字，可以自动推断局部变量的类型，简化代码：

var number = 10; // 自动推断为int类型
var name = "John"; // 自动推断为String类型
var list = new ArrayList<String>(); // 自动推断为ArrayList<String>类型

二、final有什么用？

修饰类：该类不能被继承。例如final class FinalClass {}，任何其他类无法继承FinalClass。
修饰方法：该方法不能被子类重写。如在一个类中定义public final void finalMethod() {}，子类不能重写finalMethod方法。
修饰变量：
- 如果修饰基本数据类型变量，变量值不能被修改，成为常量。例如final int MAX_VALUE = 100;，MAX_VALUE的值无法再改变。
- 如果修饰引用数据类型变量，变量所指向的对象地址不能改变，但对象内部的属性可以改变。例如final StringBuilder sb = new StringBuilder();，sb不能再指向其他StringBuilder对象，但可以通过sb.append("Hello");修改其内容。

实操示例：使用final修饰不可变对象

在Java中，不可变对象是线程安全的，适合在多线程环境中使用。例如，Java 16引入的Record类就是不可变的：

public record Person(String name, int age) {
    // Record类的属性默认是final的，不可修改
}

// 使用示例
var person = new Person("Alice", 30);
// person.age = 31; // 编译错误，不能修改final属性

三、介绍下static。

静态变量：属于类，被类的所有实例共享。例如：

class StaticExample {
    static int staticVar = 10;
    int instanceVar = 20;
}

可以通过StaticExample.staticVar访问静态变量，无需创建类的实例。不同实例的instanceVar相互独立，但staticVar只有一份。

静态方法：同样属于类，可直接通过类名调用。静态方法中不能直接访问非静态成员（变量或方法），因为非静态成员依赖于类的实例。例如：

class StaticMethodExample {
    static void staticMethod() {
        System.out.println("This is a static method");
    }
    void instanceMethod() {
        System.out.println("This is an instance method");
    }
}

调用方式为StaticMethodExample.staticMethod();，而在staticMethod中不能直接调用instanceMethod。

静态代码块：在类加载时执行，且只执行一次。例如：

class StaticBlockExample {
    static {
        System.out.println("Static block executed");
    }
}

当StaticBlockExample类被加载到内存时，静态代码块中的内容会输出。

实操示例：使用静态导入简化代码

Java 5引入了静态导入，可以直接使用静态成员，无需通过类名访问：

import static java.lang.Math.*;

public class StaticImportExample {
    public static void main(String[] args) {
        double result = sqrt(pow(3, 2) + pow(4, 2));
        System.out.println("Result: " + result); // 输出5.0
    }
}

四、“==”和equals方法究竟有什么区别？

对于基本数据类型：“==”比较的是值是否相等。例如int a = 5; int b = 5;，a == b为true。
对于引用数据类型：
- “==”比较的是两个对象的引用（内存地址）是否相同。例如：

String s1 = new String("Hello");
String s2 = new String("Hello");
System.out.println(s1 == s2); // 输出false，因为s1和s2指向不同的对象

equals方法：在Object类中，equals方法和“==”作用相同，比较的是对象引用。但许多类（如String）重写了equals方法，用于比较对象的内容是否相等。例如：

String s1 = new String("Hello");
String s2 = new String("Hello");
System.out.println(s1.equals(s2)); // 输出true，因为String类重写了equals方法，比较内容

实操示例：重写equals方法

当我们创建自定义类时，通常需要重写equals方法以实现内容比较：

import java.util.Objects;

public class Employee {
    private int id;
    private String name;

    public Employee(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return id == employee.id && Objects.equals(name, employee.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
}

五、java中有没有引用传递？

Java中只有值传递。对于基本数据类型，传递的是值的副本。对于引用数据类型，传递的是对象引用的副本（即对象在堆内存中的地址的副本）。例如：

class PassByValueExample {
    static void changeValue(int num) {
        num = 20;
    }
    static void changeObject(MyObject obj) {
        obj.value = 20;
    }
}
class MyObject {
    int value = 10;
}

调用PassByValueExample.changeValue(10);时，原变量的值不会改变，因为传递的是10的副本。而调用PassByValueExample.changeObject(new MyObject());时，MyObject对象内部的value属性会改变，因为传递的对象引用副本指向堆中的同一个对象，通过该引用副本可以修改对象内容，但引用本身（指向的地址）无法在方法内改变。

实操示例：使用Java 8的Consumer接口演示引用传递

虽然Java只有值传递，但可以通过Consumer接口实现类似引用传递的效果：

import java.util.function.Consumer;

public class PassByValueDemo {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");
        
        // 使用Consumer修改StringBuilder内容
        modifyStringBuilder(sb, s -> s.append(" World"));
        
        System.out.println(sb); // 输出Hello World
    }
    
    public static void modifyStringBuilder(StringBuilder sb, Consumer<StringBuilder> consumer) {
        consumer.accept(sb);
    }
}

六、String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有？

原始的String对象内容没有改变。String类是不可变类，一旦创建，其内容不可修改。当执行s = s + " world!";时，实际上是创建了一个新的String对象，其值为“Hello world!”，而原来的“Hello”对象依然存在于字符串常量池中。例如：

String s = "Hello";
String originalS = s;
s = s + " world!";
System.out.println(s); // 输出Hello world!
System.out.println(originalS == s); // 输出false，说明s指向了新的对象

实操示例：使用StringBuilder替代String进行字符串拼接

在需要频繁拼接字符串的场景下，使用StringBuilder可以避免创建大量临时String对象，提高性能：

public class StringBuilderExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");
        sb.append(" world!");
        System.out.println(sb); // 输出Hello world!
        
        // 使用Java 9+的StringJoiner更方便地拼接字符串
        StringJoiner joiner = new StringJoiner(", ");
        joiner.add("Apple").add("Banana").add("Cherry");
        System.out.println(joiner.toString()); // 输出Apple, Banana, Cherry
    }
}

七、Error和Exception的区别是什么？

Error：表示系统级的错误和程序不必处理的异常，是Java运行时内部错误或资源耗尽错误，如OutOfMemoryError（内存溢出错误）、StackOverflowError（栈溢出错误）。这些错误通常是由于系统资源不足或系统内部错误导致，程序无法恢复，一般不需要捕获处理。
Exception：表示程序可以处理的异常，分为运行时异常（RuntimeException及其子类）和受检异常（非RuntimeException的异常）。
- 运行时异常：如NullPointerException（空指针异常）、ArrayIndexOutOfBoundsException（数组越界异常）等，这类异常在编译时不检查，运行时可能出现，通常是由于程序逻辑错误导致。
- 受检异常：如IOException（输入输出异常）、SQLException（数据库操作异常）等，这类异常在编译时必须进行处理（捕获或声明抛出），否则编译不通过。例如：

try {
    // 可能抛出IOException的代码
    FileReader fr = new FileReader("nonexistentFile.txt");
} catch (IOException e) {
    e.printStackTrace();
}

在上述代码中，FileReader的构造函数可能抛出IOException，因此必须进行捕获处理。

实操示例：使用Java 7的try-with-resources语句自动关闭资源

对于实现了AutoCloseable接口的资源（如文件流、数据库连接等），可以使用try-with-resources语句自动关闭资源，避免资源泄漏：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 无需手动调用br.close()，资源会自动关闭
    }
}

八、java程序初始化顺序是怎样的？

父类静态成员和静态代码块：按照在代码中出现的顺序依次初始化。例如：

class Parent {
    static int staticVar = 10;
    static {
        System.out.println("Parent static block");
    }
}

在Parent类加载时，staticVar先被初始化为10，然后执行静态代码块输出“Parent static block”。

子类静态成员和静态代码块：同样按照出现顺序初始化。
父类实例成员和实例代码块：在创建子类对象时，先初始化父类实例成员和实例代码块，顺序也是按代码中出现的顺序。
父类构造函数：调用父类构造函数完成父类对象初始化。
子类实例成员和实例代码块：初始化子类实例成员和实例代码块。
子类构造函数：最后执行子类构造函数完成子类对象初始化。

实操示例：验证Java程序初始化顺序

通过以下代码验证Java程序的初始化顺序：

class Parent {
    static {
        System.out.println("Parent Static Block");
    }
    
    {
        System.out.println("Parent Instance Block");
    }
    
    public Parent() {
        System.out.println("Parent Constructor");
    }
}

class Child extends Parent {
    static {
        System.out.println("Child Static Block");
    }
    
    {
        System.out.println("Child Instance Block");
    }
    
    public Child() {
        System.out.println("Child Constructor");
    }
}

public class InitializationOrderExample {
    public static void main(String[] args) {
        new Child();
        // 输出顺序：
        // Parent Static Block
        // Child Static Block
        // Parent Instance Block
        // Parent Constructor
        // Child Instance Block
        // Child Constructor
    }
}

九、java中IO流分为几种？它们的区别是什么？

Java中IO流分为字节流和字符流。

字节流：
- 以字节（8位）为单位进行数据读写，用于处理二进制数据，如图片、音频、视频等。字节流的基类是InputStream（输入流）和OutputStream（输出流）。例如FileInputStream用于从文件读取字节数据，FileOutputStream用于向文件写入字节数据。

try {
    FileInputStream fis = new FileInputStream("test.txt");
    int data;
    while ((data = fis.read()) != -1) {
        System.out.print((char) data);
    }
    fis.close();
} catch (IOException e) {
    e.printStackTrace();
}

字符流：
- 以字符（16位，对应Unicode编码）为单位进行数据读写，用于处理文本数据。字符流的基类是Reader（输入流）和Writer（输出流）。例如FileReader用于从文件读取字符数据，FileWriter用于向文件写入字符数据。

try {
    FileReader fr = new FileReader("test.txt");
    int data;
    while ((data = fr.read()) != -1) {
        System.out.print((char) data);
    }
    fr.close();
} catch (IOException e) {
    e.printStackTrace();
}

字符流内部其实也是通过字节流实现的，它会根据指定的字符编码（默认是系统编码）将字符转换为字节进行读写。与字节流相比，字符流更适合处理文本，因为它考虑了字符编码转换，使用起来更方便。

实操示例：使用Java NIO.2 API进行文件操作

Java 7引入了NIO.2 API，提供了更简洁、更高效的文件操作方式：

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;

public class NIO2Example {
    public static void main(String[] args) throws IOException {
        // 读取文件内容到字符串
        Path path = Paths.get("test.txt");
        String content = Files.readString(path);
        System.out.println(content);
        
        // 写入字符串到文件
        String text = "Hello, Java NIO.2!";
        Files.writeString(path, text);
        
        // 读取文件所有行
        List<String> lines = Files.readAllLines(path);
        for (String line : lines) {
            System.out.println(line);
        }
        
        // 创建目录
        Path dir = Paths.get("newDir");
        Files.createDirectory(dir);
    }
}