当前位置：首页 > article >正文

Java基础知识大全（含答案，面试基础）

article 2026/3/19 13:00:56

对于初学者来说，掌握Java的基础知识是成为一名优秀Java开发者的第一步。而对于经验丰富的开发者，扎实的基础同样是继续深入学习、攻克更高难度技术的基础。因此，在面试和实际工作中，Java的基础知识不仅是评估开发者能力的标准，也是编程思维和问题解决能力的体现。

通过本文章学习，你不仅能够增强自己的Java编程基础，还能熟悉常见的面试题目，做好应对技术面试的准备。无论你是刚刚接触Java的新人，还是有一定经验的开发者，本文章都将为你提供扎实的基础与灵感，帮助你在Java的道路上走得更远。

1、Java中的数据类型有哪些

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

基本数据类型：

整数型：byte、short、int、long；布尔型：boolean；字符型：char；浮点型：float、double

引用数据类型：

数组Array、接口Interface、类（String等)，注意String不是基本数据类型

2、Java的自动装箱和拆箱

Java的自动装箱就是将基本数据类型转化为对应的封装类；自动拆箱就是封装类转化为对应的基本数据类型；

3、Java中的不可变类

不可变类是指在创建后其状态、数据就无法被修改的类，这种类的实例在整个生命周期内保持不变。特性如下：

该类被final修饰，防止子类继承；
类的所有属性被private和final修饰，确保它们初始化后不能被修改；
通过构造函数初始化所有属性；
不提供任何修改对象属性的方法；

常见的不可变类有String、Integer等，当我们对String对拼接、剪切等操作，都是新建一个String对象并指向它。

4. Java的多态

定义：同一操作作用于不同对象时产生不同行为，分为：

编译时多态（静态多态）：通过方法重载实现，编译器根据参数列表决定调用哪个方法。

void print(int a) { ... }
void print(String s) { ... } // 重载

运行时多态（动态多态）：通过方法重写+继承/接口实现，JVM根据对象实际类型决定调用方法。

class Animal { void sound() { ... } }
class Dog extends Animal { @Override void sound() { ... } // 重写
}

应用场景：接口回调、框架设计（如Spring依赖注入）。

5. Java的封装

核心思想：隐藏对象内部细节，通过公共方法控制访问。

实现方式：
- 使用private修饰属性，提供public getter/setter。
- 类内部保留辅助方法为private。
优势：
- 安全性：防止非法修改（如年龄为负数）。
- 灵活性：内部逻辑修改不影响外部调用。

示例：

class Person {private int age;public void setAge(int age) {if (age >= 0) this.age = age; // 数据校验}
}

6. ava的继承

定义：子类继承父类的属性和方法，实现代码复用和层次化设计。

语法：class Sub extends Super { ... }
限制：单继承（一个子类只能有一个直接父类）。
注意：
- 子类可重写父类方法（@Override）。
- 父类private成员不可直接访问。

示例：

class Vehicle { void run() { ... } }
class Car extends Vehicle { @Override void run() { ... } // 重写父类方法
}

7. 为什么Java不支持多重继承？

根本原因：避免菱形继承问题（多个父类有同名方法时冲突）。

替代方案：通过接口的多实现（implements Interface1, Interface2）实现多重能力扩展。
接口优势：
- 无方法冲突（接口方法默认抽象，需子类实现）。
- 更灵活的组合（如Runnable和Serializable接口组合）。

8. 序列化与反序列化

序列化：将对象转换为字节流（网络传输或持久化存储）。

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("data.obj"));
oos.writeObject(obj); // 序列化

反序列化：将字节流恢复为对象。

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("data.obj"));
MyClass obj = (MyClass) ois.readObject(); // 反序列化

注意事项：

需实现Serializable接口（标记接口）。
使用transient关键字修饰不序列化的字段。

9. 重写（Override） vs 重载（Overload）

特性	重写（Override）	重载（Overload）
作用范围	父子类之间	同一类中
方法签名	必须相同（方法名、参数、返回类型）	方法名相同，参数列表不同
访问权限	子类方法不能更严格（如父类`protected`，子类不能为`private`）	无限制
抛出异常	子类异常范围 ≤ 父类	无限制

示例：

// 重写
class Parent { void doSomething() throws IOException { ... } }
class Child extends Parent { @Override void doSomething() throws FileNotFoundException { ... } // 异常范围更小
}// 重载
class Calculator {int add(int a, int b) { return a + b; }double add(double a, double b) { return a + b; } // 参数类型不同
}

10.Error和Exception的区别是什么？

类别	Exception（异常）	Error（错误）
可恢复性	程序可捕获并处理（如文件未找到）	JVM系统级错误，程序无法恢复（如内存溢出）
处理方式	需`try-catch`或`throws`声明	通常不处理，由JVM终止程序
常见子类	`IOException`, `SQLException`	`OutOfMemoryError`, `StackOverflowError`

11. Java的优势

跨平台：基于JVM实现“一次编写，到处运行”。
面向对象：封装、继承、多态提升代码复用和维护性。
丰富的类库：集合框架、多线程、网络编程等开箱即用。
自动内存管理：垃圾回收机制减少内存泄漏风险。
强生态系统：Spring全家桶、大数据（Hadoop）、Android开发等。

12. 面向对象 vs 面向过程

维度	面向对象（OOP）	面向过程（POP）
核心思想	对象为中心，关注数据与行为的结合	函数为中心，关注步骤执行顺序
代码复用	继承、组合	函数复用
典型语言	Java、C++	C、Pascal
适用场景	复杂系统设计（如企业级应用）	简单逻辑或性能敏感场景（如嵌入式）

13. 参数传递方式

Java严格按值传递：

基本类型：传递值的副本，方法内修改不影响原值。
```
void change(int x) { x = 10; }
int a = 5;
change(a); // a仍为5
```

引用类型：传递对象地址的副本，方法内修改对象内容会影响原对象，但重新赋值不会。

void changeName(Student s) { s.setName("Bob"); // 修改对象内容，原对象受影响s = new Student(); // 重新赋值，原引用不变
}

14. 内部类的作用与分类

作用：

访问外部类私有成员。
实现多重继承（通过多个内部类继承不同父类）。
隐藏实现细节（如返回Iterator的内部类）。

分类：

成员内部类：依附于外部类实例，可访问所有成员。
```
class Outer {class Inner { ... }
}
```
静态内部类：不依赖外部类实例，只能访问静态成员。
```
class Outer {static class StaticInner { ... }
}
```
局部内部类：定义在方法或作用域内，仅局部可见。

匿名内部类：无类名，直接实现接口或继承类。

Runnable r = new Runnable() { // 匿名内部类public void run() { ... }
};

15. String、StringBuilder、StringBuffer对比

特性	String	StringBuilder	StringBuffer
可变性	不可变（final char[]）	可变	可变
线程安全	线程安全（不可变）	非线程安全	线程安全（synchronized方法）
性能	低（频繁拼接产生新对象）	高	中等（同步开销）
适用场景	常量或少量拼接	单线程下大量字符串操作	多线程下字符串操作

示例：

String s1 = "a" + "b"; // 编译优化为"ab"，只生成一个对象
StringBuilder sb = new StringBuilder();
sb.append("a").append("b"); // 直接修改内部数组

16. 接口 vs 抽象类

特性	接口（Interface）	抽象类（Abstract Class）
实现方式	多实现（`implements A, B`）	单继承（`extends`）
构造方法	无	有（用于子类初始化）
方法类型	Java 8前：全抽象；Java 8+：可含默认/静态方法	可包含抽象和具体方法
字段修饰符	默认`public static final`	无限制
设计目的	定义行为契约（如`Comparable`）	提供通用实现（如`AbstractList`）

17. JDK vs JRE

JRE（Java Runtime Environment）：
包含JVM、核心类库（如java.lang），用于运行Java程序。
JDK（Java Development Kit）：
包含JRE + 开发工具（javac编译器、jar打包工具、调试器等）。
关系：JDK > JRE > JVM。

18. hashCode()与equals()

equals()：比较对象内容是否相等（需重写equals方法）。
hashCode()：返回对象的哈希码，用于哈希表（如HashMap）快速查找。
重写规则：
- 若a.equals(b) == true，则a.hashCode() == b.hashCode()。
- hashCode冲突时，哈希表通过链表或红黑树处理。

示例：

class Student {String id;public boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student s = (Student) o;return id.equals(s.id); // 根据id判断相等}public int hashCode() {return id.hashCode(); // 保证相同id的hashCode一致}
}

19. 动态代理

定义：在运行时动态生成代理类，增强目标对象功能（如日志、事务）。

JDK动态代理：基于接口，通过InvocationHandler和Proxy类实现。

interface Subject { void request(); }
class RealSubject implements Subject { ... }InvocationHandler handler = (proxy, method, args) -> {System.out.println("Before method");return method.invoke(new RealSubject(), args);
};
Subject proxy = (Subject) Proxy.newProxyInstance(loader, new Class[]{Subject.class}, handler);

CGLIB动态代理：基于继承，生成目标类的子类（需引入cglib库）。

20. JDK代理 vs CGLIB代理

特性	JDK动态代理	CGLIB代理
依赖	目标类需实现接口	无接口要求（通过继承）
性能	调用方法较慢（反射）	生成代理类较慢，调用方法较快
限制	无法代理final类/方法	无法代理final方法
实现方式	`Proxy` + `InvocationHandler`	ASM字节码操作生成子类

21. 反射机制

定义：在运行时获取类信息并动态操作对象（如创建实例、调用方法）。

核心类：Class、Field、Method、Constructor。
应用场景：
- 框架设计（如Spring IoC容器创建Bean）。
- 动态代理、注解处理。

示例：

Class<?> clazz = Class.forName("com.example.MyClass");
Object obj = clazz.newInstance(); // 创建实例
Method method = clazz.getMethod("methodName");
method.invoke(obj); // 调用方法

22. SPI（Service Provider Interface）

机制：服务提供者动态加载实现类，解耦接口与实现。

实现步骤：
1. 定义接口（如java.sql.Driver）。
2. 在META-INF/services/下创建以接口全限定名命名的文件。
3. 文件中写入实现类的全限定名（如com.mysql.jdbc.Driver）。
应用：JDBC驱动加载、日志框架适配。

23. 泛型的作用

类型安全：编译时检查类型错误（如List<String>只能存字符串）。
消除强制转换：减少ClassCastException风险。
代码复用：泛型类/方法可处理多种类型（如Comparator<T>）。

示例：

List<String> list = new ArrayList<>(); // 泛型定义
list.add("Hello");
// list.add(1); // 编译报错

24. 泛型擦除

定义：编译器在编译后移除泛型类型信息，替换为原始类型（如List<String>→List）。

后果：
- 运行时无法获取泛型类型（如T.class非法）。
- 需通过反射+TypeToken（如Gson库）获取泛型类型。

示例：

List<Integer> list = new ArrayList<>();
list.add(1);
// 编译后等同于：
List list = new ArrayList();
list.add(1);

25. 浅拷贝 vs 深拷贝

浅拷贝：复制对象和其基本类型字段，引用类型字段共享同一对象。

class Person implements Cloneable {Address address; // 引用类型public Object clone() { return super.clone(); } // 浅拷贝
}

深拷贝：完全复制对象及其引用的所有对象。

public Object clone() {Person p = (Person) super.clone();p.address = (Address) address.clone(); // 递归拷贝引用对象return p;
}

26. Integer缓存池

范围：-128到127的Integer对象会被缓存（通过IntegerCache）。
示例：

Integer a = 127;
Integer b = 127;
System.out.println(a == b); // true（从缓存获取）Integer c = 128;
Integer d = 128;
System.out.println(c == d); // false（new新对象）

27. 类加载过程

加载：读取.class二进制数据，生成Class对象。
验证：校验字节码格式、符号引用等合法性。
准备：为静态变量分配内存并赋初始值（如int默认为0）。
解析：将符号引用转为直接引用（如方法地址）。
初始化：执行静态代码块和静态变量赋值（触发<clinit>方法）。

双亲委派：类加载请求先委派父加载器处理，避免重复加载。

28. BigDecimal

作用：精确计算浮点数（避免0.1 + 0.2 ≠ 0.3问题）。

构造方式：使用String参数（避免double精度丢失）。

BigDecimal d1 = new BigDecimal("0.1");
BigDecimal d2 = new BigDecimal("0.2");
System.out.println(d1.add(d2)); // 0.3

运算方法：add(), subtract(), multiply(), divide()（需指定舍入模式）。

29. new String("mianShiBiGuo")创建的对象数

字符串常量池中无"mianShiBiGuo"：
创建2个对象：常量池中的字符串对象 + new的堆对象。
常量池中已有：
创建1个堆对象（常量池对象已存在）。

30. final、finally、finalize

final：
- 修饰类：不可被继承（如String）。
- 修饰方法：不可被重写。
- 修饰变量：常量（基本类型值不可变，引用类型地址不可变）。
finally：try-catch中无论是否异常都会执行的代码块（常用于释放资源）。
finalize：Object类方法，对象被GC回收前调用（不推荐依赖，可用try-with-resources替代）。

31. 代码乱码原因

根源：字符编码和字符解码不一致。
- 源代码文件编码（如UTF-8）与编译器/运行环境编码（如GBK）不一致。
解决：
1. IDE中统一设置为UTF-8。
2. 文件头部添加编码声明：-Dfile.encoding=UTF-8。

32. JDK9的String优化

改动：将内部char[]改为byte[] + 编码标记（coder）。
优势：

内存节省：LATIN1字符（单字节）节省一半空间。
性能提升：减少内存占用，降低GC压力。

33. 线程多次调用start()的后果

结果：抛出IllegalThreadStateException。
原因：线程状态从NEW变为RUNNABLE后不可逆。
正确用法：一个线程实例只能调用一次start()。

34. 队列 vs 栈

特性	队列（Queue）	栈（Stack）
结构	FIFO（先进先出）	LIFO（后进先出）
方法	`add()`, `remove()`	`push()`, `pop()`
实现类	`LinkedList`, `PriorityQueue`	`Stack`, `Deque`（推荐用`ArrayDeque`）

35. I/O流分类

字节流：处理二进制文件（如图片、视频）。
- 输入：InputStream（如FileInputStream）。
- 输出：OutputStream（如FileOutputStream）。
字符流：处理文本文件（自动处理编码）。
- 输入：Reader（如FileReader）。
- 输出：Writer（如FileWriter）。

缓冲流：BufferedInputStream、BufferedReader（提升读写性能）。

36. 迭代器（Iterator）

作用：提供统一遍历集合元素的方式，隐藏底层实现。

核心方法：
- hasNext()：是否还有元素。
- next()：返回下一个元素。
- remove()：删除当前元素。
快速失败（Fail-Fast）：遍历时修改集合结构会抛ConcurrentModificationException（如ArrayList）。

示例：

List<String> list = new ArrayList<>();
Iterator<String> it = list.iterator();
while (it.hasNext()) {String s = it.next();it.remove(); // 安全删除
}

37. 运行时异常 vs 编译时异常

特性	运行时异常（RuntimeException）	编译时异常（Checked Exception）
处理要求	可不处理（通常为逻辑错误）	必须`try-catch`或`throws`声明
常见异常	`NullPointerException`, `IndexOutOfBoundsException`	`IOException`, `ClassNotFoundException`

38. 访问修饰符

修饰符	同类	同包	子类	其他包
`private`	✔	✖	✖	✖
`default`	✔	✔	✖	✖
`protected`	✔	✔	✔	✖
`public`	✔	✔	✔	✔

39. for循环 vs foreach循环

for循环：
- 支持索引操作和逆序遍历。
- 可修改集合结构（如删除元素）。
foreach循环：
- 语法简洁，但隐藏迭代器实现。
- 遍历时修改集合会抛ConcurrentModificationException（除非使用迭代器的remove()）。

示例：

// for循环删除元素（安全）
for (int i = 0; i < list.size(); i++) {if (condition) list.remove(i--);
}// foreach循环删除元素（抛异常）
for (String s : list) {list.remove(s); // 错误！
}

40. 双亲委派机制

流程：类加载器收到加载请求后，依次向上委托给父加载器，若父类无法加载，才由子类加载。
层级：

Bootstrap ClassLoader：加载JRE/lib核心类（如rt.jar）。
Extension ClassLoader：加载JRE/lib/ext扩展类。
Application ClassLoader：加载用户类路径（-classpath）。

破坏场景：

SPI服务加载（如JDBC用线程上下文类加载器加载实现类）。
OSGi模块化热部署。

41. 双亲委派机制的作用

避免重复加载：父加载器已加载的类，子加载器不再加载。
安全性：防止核心类被篡改（如自定义java.lang.String无效）。
统一性：保证类在各类加载器中表现一致。

42. wait() vs sleep()

特性	wait()	sleep()
所属类	`Object`	`Thread`
锁释放	释放锁	不释放锁
调用条件	必须在同步块中（持有锁）	任意位置
唤醒方式	`notify()`/`notifyAll()`	时间到自动唤醒
异常	可能抛`InterruptedException`	同左

43. 字节码是什么（Bytecode）

定义：Java源代码编译后的中间代码（.class文件），由JVM解释执行。
优势：跨平台（不同平台JVM解释相同字节码）。
查看工具：javap -c MyClass.class反编译字节码。

44. 静态方法 vs 实例方法

特性	静态方法	实例方法
调用方式	类名调用（`Math.abs()`）	对象调用（`list.add()`）
访问权限	只能访问静态成员	可访问静态和实例成员
内存分配	类加载时分配内存	对象实例化后分配
重写	不可被重写（隐藏）	可被重写

45. Optional类是什么

目的：显式处理null，避免空指针异常。
核心方法：

Optional.ofNullable(value)：包装可能为null的值。
orElse(default)：值为空时返回默认值。
orElseThrow()：值为空时抛异常。

示例：

Optional<String> name = Optional.ofNullable(user.getName());
String result = name.orElse("Unknown");

46. StringBuilder实现原理

底层结构：可扩容的char[]数组（默认容量16）。
扩容机制：当容量不足时，扩容为原容量*2 + 2。
线程安全：非线程安全（StringBuffer通过synchronized保证安全）。

示例：

StringBuilder sb = new StringBuilder();
sb.append("a"); // 容量足够时直接追加
sb.append("bcd"); // 触发扩容