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）

示例：

// 重写
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的区别是什么？

11. Java的优势

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

12. 面向对象 vs 面向过程

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

16. 接口 vs 抽象类

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代理

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

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

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<String> list = new ArrayList<>();
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
    it.remove(); // 安全删除
}

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

38. 访问修饰符

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()

43. 字节码是什么（Bytecode）

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

44. 静态方法 vs 实例方法

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"); // 触发扩容