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

本文涉及的产品
对象存储 OSS,20GB 3个月
日志服务 SLS,月写入数据量 50GB 1个月
对象存储 OSS,内容安全 1000 次 1年
简介: 本文总结了Java基础面试中的高频考点,包括数据类型分类、final修饰符的三种用途、static关键字特性、==与equals的区别、Java只有值传递的特性、String的不可变性、Error与Exception的差异、程序初始化顺序规则,以及IO流的字节流/字符流分类。每个问题都配有简明定义和典型示例,如用final修饰变量示例、static方法调用限制说明等,帮助应聘者快速掌握核心概念和实际应用场景。

一、Java数据类型有哪些?

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

  1. 基本数据类型
    • 整数类型: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;)。
  2. 引用数据类型:类(如String)、接口、数组等。例如String str = "Hello";strString类的引用,指向字符串常量池中的“Hello”对象。

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

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

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

二、final有什么用?

  1. 修饰类:该类不能被继承。例如final class FinalClass {},任何其他类无法继承FinalClass
  2. 修饰方法:该方法不能被子类重写。如在一个类中定义public final void finalMethod() {},子类不能重写finalMethod方法。
  3. 修饰变量
    • 如果修饰基本数据类型变量,变量值不能被修改,成为常量。例如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。

  1. 静态变量:属于类,被类的所有实例共享。例如:
class StaticExample {
   
    static int staticVar = 10;
    int instanceVar = 20;
}

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

  1. 静态方法:同样属于类,可直接通过类名调用。静态方法中不能直接访问非静态成员(变量或方法),因为非静态成员依赖于类的实例。例如:
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

  1. 静态代码块:在类加载时执行,且只执行一次。例如:
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方法究竟有什么区别?

  1. 对于基本数据类型:“==”比较的是值是否相等。例如int a = 5; int b = 5;a == btrue
  2. 对于引用数据类型
    • “==”比较的是两个对象的引用(内存地址)是否相同。例如:
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的区别是什么?

  1. Error:表示系统级的错误和程序不必处理的异常,是Java运行时内部错误或资源耗尽错误,如OutOfMemoryError(内存溢出错误)、StackOverflowError(栈溢出错误)。这些错误通常是由于系统资源不足或系统内部错误导致,程序无法恢复,一般不需要捕获处理。
  2. 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程序初始化顺序是怎样的?

  1. 父类静态成员和静态代码块:按照在代码中出现的顺序依次初始化。例如:
class Parent {
   
    static int staticVar = 10;
    static {
   
        System.out.println("Parent static block");
    }
}

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

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

实操示例:验证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流分为字节流和字符流。

  1. 字节流
    • 以字节(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();
}
  1. 字符流
    • 以字符(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);
    }
}

这些实操示例涵盖了Java 10到Java 17的新特性,包括var关键字、Record类、静态导入、try-with-resources语句和NIO.2 API等。你对这些示例是否满意?如果需要进一步解释某个知识点或补充其他Java特性,欢迎告诉我。


Java 基础,应届生面试,面试高频问题,Java 面试题,Java 实操示例,Java 变量类型,Java 面向对象,Java 集合框架,Java 异常处理,Java 多线程,Java 并发编程,Java IO 流,Java 反射机制,Java 常用 API,Java 面试技巧



代码获取方式
https://pan.quark.cn/s/14fcf913bae6


相关文章
|
7天前
|
IDE Java 关系型数据库
Java 初学者学习路线(含代码示例)
本教程为Java初学者设计,涵盖基础语法、面向对象、集合、异常处理、文件操作、多线程、JDBC、Servlet及MyBatis等内容,每阶段配核心代码示例,强调动手实践,助你循序渐进掌握Java编程。
76 2
|
10天前
|
Java 开发者
Java 函数式编程全解析:静态方法引用、实例方法引用、特定类型方法引用与构造器引用实战教程
本文介绍Java 8函数式编程中的四种方法引用:静态、实例、特定类型及构造器引用,通过简洁示例演示其用法,帮助开发者提升代码可读性与简洁性。
|
10天前
|
Java
怎么用Java 代码示例来展示继承的实现
本文通过Java代码示例展示继承机制:Animal为父类,Cat和Dog继承其属性与方法,并实现构造函数调用、方法重写与特有功能扩展,体现代码复用与多态特性。
50 4
|
11天前
|
Java
java入门代码示例
本文介绍Java入门基础,包含Hello World、变量类型、条件判断、循环及方法定义等核心语法示例,帮助初学者快速掌握Java编程基本结构与逻辑。
166 0
|
15天前
|
Java 开发者
Java并发编程:CountDownLatch实战解析
Java并发编程:CountDownLatch实战解析
305 100
|
19天前
|
安全 Java API
Java Web 在线商城项目最新技术实操指南帮助开发者高效完成商城项目开发
本项目基于Spring Boot 3.2与Vue 3构建现代化在线商城,涵盖技术选型、核心功能实现、安全控制与容器化部署,助开发者掌握最新Java Web全栈开发实践。
202 1
|
19天前
|
机器学习/深度学习 JSON Java
Java调用Python的5种实用方案:从简单到进阶的全场景解析
在机器学习与大数据融合背景下,Java与Python协同开发成为企业常见需求。本文通过真实案例解析5种主流调用方案,涵盖脚本调用到微服务架构,助力开发者根据业务场景选择最优方案,提升开发效率与系统性能。
170 0
|
19天前
|
Java API 数据库
2025 年最新 Java 实操学习路线,从入门到高级应用详细指南
2025年Java最新实操学习路线,涵盖从环境搭建到微服务、容器化部署的全流程实战内容,助你掌握Java 21核心特性、Spring Boot 3.2开发、云原生与微服务架构,提升企业级项目开发能力,适合从入门到高级应用的学习需求。
281 0
|
19天前
|
安全 Java API
Java SE 与 Java EE 区别解析及应用场景对比
在Java编程世界中,Java SE(Java Standard Edition)和Java EE(Java Enterprise Edition)是两个重要的平台版本,它们各自有着独特的定位和应用场景。理解它们之间的差异,对于开发者选择合适的技术栈进行项目开发至关重要。
91 1
Java API 开发者
43 0