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

对于初学者来说，掌握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的优势

1. 跨平台：基于JVM实现“一次编写，到处运行”。
2. 面向对象：封装、继承、多态提升代码复用和维护性。
3. 丰富的类库：集合框架、多线程、网络编程等开箱即用。
4. 自动内存管理：垃圾回收机制减少内存泄漏风险。
5. 强生态系统：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的内部类）。

分类：

1. 成员内部类：依附于外部类实例，可访问所有成员。

   class Outer {
       class Inner { ... }
   }

2. 静态内部类：不依赖外部类实例，只能访问静态成员。

   class Outer {
       static class StaticInner { ... }
   }

3. 局部内部类：定义在方法或作用域内，仅局部可见。
4. 匿名内部类：无类名，直接实现接口或继承类。

   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只能存字符串）。
• 消除强制转换：减少ClassCastException风险。
• 代码复用：泛型类/方法可处理多种类型（如Comparator）。

示例：

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

24. 泛型擦除

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

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

示例：

List 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. 类加载过程

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

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

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流分类

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

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

36. 迭代器（Iterator）

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

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

示例：

List list = new ArrayList<>();
Iterator 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. 双亲委派机制

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

1. Bootstrap ClassLoader：加载JRE/lib核心类（如rt.jar）。
2. Extension ClassLoader：加载JRE/lib/ext扩展类。
3. 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 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"); // 触发扩容