Java基础知识面试题汇总

引言

Java基础是面试必考内容。本文系统梳理Java基础知识的高频面试题。

一、数据类型

1.1 基本数据类型

// 8种基本数据类型
byte    // 1字节，-128 ~ 127
short   // 2字节，-32768 ~ 32767
int     // 4字节，-2^31 ~ 2^31-1
long    // 8字节，-2^63 ~ 2^63-1
float   // 4字节
double  // 8字节
char    // 2字节，0 ~ 65535
boolean // 1字节，true/false

1.2 包装类

// 自动装箱和拆箱
Integer a = 10;        // 装箱
int b = a;             // 拆箱

// 缓存机制
Integer x = 127;
Integer y = 127;
System.out.println(x == y); // true，使用缓存

Integer m = 128;
Integer n = 128;
System.out.println(m == n); // false，超出缓存范围

二、面向对象

2.1 三大特性

// 1. 封装
public class Person {
    private String name;
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}

// 2. 继承
public class Student extends Person {
    private String school;
}

// 3. 多态
Person person = new Student();

2.2 重载与重写

// 重载（Overload）：同一类中，方法名相同，参数不同
public void method(int a) {}
public void method(String a) {}

// 重写（Override）：子类重写父类方法
@Override
public String toString() {
    return "Custom toString";
}

三、关键字

3.1 static

public class Counter {
    private static int count = 0;  // 静态变量
    
    public static void increment() {  // 静态方法
        count++;
    }
    
    static {  // 静态代码块
        System.out.println("Static block");
    }
}

3.2 final

// 修饰类：不能被继承
public final class FinalClass {}

// 修饰方法：不能被重写
public final void method() {}

// 修饰变量：常量
public static final int MAX = 100;

3.3 abstract

// 抽象类
public abstract class Animal {
    // 抽象方法
    public abstract void eat();
    
    // 普通方法
    public void sleep() {
        System.out.println("Sleeping...");
    }
}

四、String类

4.1 不可变性

1
2
3

String s1 = "hello";
String s2 = s1.concat(" world");
// s1仍然是"hello"，s2是"hello world"

4.2 String vs StringBuilder vs StringBuffer

// String：不可变
String str = "hello";

// StringBuilder：可变，线程不安全，效率高
StringBuilder sb = new StringBuilder("hello");
sb.append(" world");

// StringBuffer：可变，线程安全，效率低
StringBuffer sbf = new StringBuffer("hello");
sbf.append(" world");

4.3 字符串常量池

String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2); // true，指向常量池

String s3 = new String("hello");
System.out.println(s1 == s3); // false，s3在堆中

String s4 = s3.intern();
System.out.println(s1 == s4); // true，intern()返回常量池引用

五、equals和hashCode

public class Person {
    private String name;
    private int age;
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        
        Person person = (Person) obj;
        return age == person.age && 
               Objects.equals(name, person.name);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

equals和hashCode的约定：

equals相等，hashCode必须相等
hashCode相等，equals不一定相等
重写equals必须重写hashCode

六、接口和抽象类

特性	抽象类	接口
继承	单继承	多实现
方法	可以有实现	JDK 8前只能是抽象方法
变量	任意变量	public static final
构造器	可以有	不能有

// 抽象类
public abstract class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public abstract void eat();
}

// 接口
public interface Flyable {
    void fly();
}

// 实现
public class Bird extends Animal implements Flyable {
    public Bird(String name) {
        super(name);
    }
    
    @Override
    public void eat() {
        System.out.println("Bird is eating");
    }
    
    @Override
    public void fly() {
        System.out.println("Bird is flying");
    }
}

七、泛型

// 泛型类
public class Box<T> {
    private T item;
    
    public void set(T item) {
        this.item = item;
    }
    
    public T get() {
        return item;
    }
}

// 泛型方法
public <T> T genericMethod(T param) {
    return param;
}

// 泛型通配符
public void process(List<?> list) {
    // ? 表示任意类型
}

public void process(List<? extends Number> list) {
    // 上界：Number及其子类
}

public void process(List<? super Integer> list) {
    // 下界：Integer及其父类
}

八、常见面试题

8.1 == 和 equals的区别

==：比较基本数据类型的值，比较引用类型的地址
equals()：比较对象内容是否相等

8.2 Java为什么不支持多继承？

避免菱形问题（Diamond Problem）。但可以实现多个接口。

8.3 什么是值传递和引用传递？

Java只有值传递。基本类型传递值的副本，引用类型传递引用的副本。

public void change(int num) {
    num = 10;  // 不影响外部
}

public void change(Person person) {
    person.setName("Alice");  // 影响外部
    person = new Person();     // 不影响外部
}