Java后端面试-每日必看（1）-优快云博客

本文链接：https://blog.youkuaiyun.com/LB22csdn/article/details/145427835

前言

大家好啊！欢迎来到本期的“码农加油站”。今天我们要聊的是一个让无数“打工人”闻之色变却又不得不面对的话题——Java后端开发面试！

作为一名曾经在面试中被虐到怀疑人生的“社畜”，我深知大家的痛苦：明明写了N年的代码，明明觉得自己很努力，但一到面试现场，就被各种“奇技淫巧”和“冷门知识点”打得满地找牙。什么“线程安全”？什么“JVM内存模型”？什么“设计模式”？这些问题就像是面试官手中的“九阴白骨爪”，分分钟让你跪地求饶。

但是！但是！但是！今天我就要站在这里，手把手教大家如何在Java后端开发面试中“华丽逆袭”！

在这个专栏中，我会用最通俗易懂的语言、最接地气的例子，为大家梳理Java后端开发面试的核心知识点。无论是刚入行的小白，还是想要提升自己的老鸟，这个专栏都能让你有所收获！

所以！还在等什么？赶紧点击关注、点赞、收藏！订阅专栏！让我们一起在Java的世界里遨游，成为那个让人羡慕的“技术大牛”！-每日更新哦

面向对象：代码世界的“社交达人”！

什么是面向对象？

在编程的世界里，有两种解决问题的思路：一种是“按部就班”的面向过程，另一种是“以人为本”的面向对象。简单来说，前者像是一个“流程控”，后者更像是一个“社交达人”。

举个例子：假设我们要写一个程序来模拟“洗衣机洗衣服”的场景。

面向过程：按部就班的“流程控”

面向过程的思路就是把任务拆解成一系列的步骤，严格按照顺序执行：

打开洗衣机。
放衣服进去。
放洗衣粉。
开始清洗。
烘干。

这种方式很直接、很高效，就像一个完美的“流程图”。但它有个缺点：一旦需求变化（比如洗衣机需要支持“快速洗涤”模式），就需要重新修改整个流程，代码的扩展性和维护性较差。

面向对象：社交达人的“分工合作”

而面向对象的思路则完全不同。它会把任务拆分成不同的“角色”（也就是对象），每个角色负责自己的职责：

人：负责打开洗衣机、放衣服、放洗衣粉。
洗衣机：负责清洗和烘干。

这样一来，代码的结构就变得清晰多了。如果以后洗衣机需要新增功能（比如“蒸汽除皱”），只需要修改洗衣机这个“角色”的代码，完全不影响其他部分。这就是面向对象的魅力！

面向对象的三大核心特性

1. 封装：代码界的“外卖包装”

封装的意思是把代码的功能和实现细节分开，只暴露给外界需要使用的部分，内部的具体实现对外不可见。就像点外卖一样：

外卖包装上写着“香辣鸡翅”，你只需要知道这是你的餐品。
但你不需要关心鸡翅是怎么腌制的、用了多少辣椒粉、烤箱温度是多少……这些细节都封装在餐厅里。

在编程中，封装的好处是显而易见的：

隐藏复杂性：外部调用者不需要了解内部实现。
提高安全性：防止外部代码随意修改内部数据。
便于维护：内部实现可以随时调整，只要接口不变，外部代码就不受影响。

2. 继承：代码界的“家族传承”

继承的意思是子类可以直接使用父类的方法和属性，同时还可以根据自己的需求进行扩展。就像一个家族的传承：

父亲会做饭、开车、管理家务。
子女继承了父亲的这些技能，同时还可以学习新的技能（比如编程）。

在编程中，继承的好处主要有两点：

代码复用：子类不需要重复编写父类已经实现的功能。
层次分明：通过继承关系，代码结构更加清晰。

举个例子：

// 父类：人类 
class Human {
    void eat() {
        System.out.println("吃饭");
    }
}
 
// 子类：程序员 
class Programmer extends Human {
    void code() {
        System.out.println("写代码");
    }
}

在这个例子中，Programmer类继承了Human类的eat()方法，同时新增了自己的code()方法。这样既保留了父类的功能，又增加了新的特性。

3. 多态：代码界的“千面人生”

多态的意思是同一个方法可以根据不同的对象表现出不同的行为。就像一个人在不同的场合可以扮演不同的角色：

在家里，他是“爸爸”；
在公司，他是“老板”；
在朋友面前，他是“开心果”。

在编程中，多态的表现形式主要有两种：

编译时多态：通过方法重载实现。
运行时多态：通过方法重写实现。

示例：运行时多态

// 父类：动物 
class Animal {
    void makeSound() {
        System.out.println("动物发出声音");
    }
}
 
// 子类：猫 
class Cat extends Animal {
    @Override 
    void makeSound() {
        System.out.println("喵喵叫");
    }
}
 
// 子类：狗 
class Dog extends Animal {
    @Override 
    void makeSound() {
        System.out.println("汪汪叫");
    }
}
 
public class Test {
    public static void main(String[] args) {
        Animal animal1 = new Cat(); // 猫 
        Animal animal2 = new Dog(); // 狗 
        
        animal1.makeSound(); // 输出：喵喵叫 
        animal2.makeSound(); // 输出：汪汪叫 
    }
}

在这个例子中，makeSound()方法在不同的对象（猫和狗）中表现出不同的行为。这就是多态的魅力！

JDK、JRE、JVM：Java世界的“铁三角”！

在Java的世界里，有三个“灵魂人物”——JDK、JRE和JVM。它们就像一支默契的乐队，各有各的分工，却又紧密配合，共同奏响Java程序的“生命乐章”。今天，我们就来聊聊它们之间的区别和联系，顺便用一些幽默的比喻让大家更容易理解！

1. JDK：Java世界的“瑞士军刀”

JDK（Java Development Kit） 是Java开发工具包，简单来说，它就是程序员的“工作台”。如果你是一名Java开发者，那么JDK就是你的“瑞士军刀”，包含了开发Java程序所需的一切工具。

主要功能：

编译器（javac）：把我们写的Java代码（.java文件）编译成字节码（.class文件）。
调试工具（jdb）：帮助我们找出代码中的bug。
文档生成工具（javadoc）：自动生成API文档。
其他工具：比如jar（打包工具）、jconsole（监控工具）等等。

生活中的比喻：

想象一下，JDK就像一个全能型的“工具箱”。它不仅能帮你完成基本的工作（比如编译代码），还能提供额外的支持（比如调试、文档生成）。如果你是一名Java开发者，没有JDK就相当于没有工具箱，寸步难行！

2. JRE：Java世界的“充电宝”

JRE（Java Runtime Environment） 是Java运行时环境，它的主要作用是运行Java程序。简单来说，如果你只是想运行别人写好的Java程序，而不是自己开发，那么你只需要安装JRE就可以了。

主要功能：

提供运行Java程序所需的类库（比如java.lang、java.util等）。
包含JVM（Java虚拟机），负责执行字节码。

生活中的比喻：

JRE就像一个“充电宝”，它的作用就是为Java程序提供运行所需的“能量”。如果你只是想玩一款Java游戏或者运行一个Java应用，那么JRE就是你的“救星”。但如果你还想自己开发游戏或者应用，那就需要升级到“满配版”——JDK啦！

3. JVM：Java世界的“翻译官”

JVM（Java Virtual Machine） 是Java虚拟机，它是整个Java生态系统的核心。简单来说，JVM的作用就是把Java程序编译生成的字节码（.class文件）翻译成计算机能够理解的机器码，并执行它。

主要特点：

跨平台性：JVM屏蔽了底层硬件和操作系统的差异，使得Java程序可以“一次编写，到处运行”。
内存管理：自动管理内存分配和垃圾回收。
安全管理：提供沙盒机制，防止恶意代码破坏系统。

生活中的比喻：

想象一下，JVM就像一个“翻译官”。当你写了一段Java代码并编译成字节码后，这段字节码就像是用“火星文”写的一样，只有JVM才能看懂并把它翻译成计算机能理解的语言。无论你是在Windows、Linux还是Mac上运行程序，JVM都会帮你搞定一切！

4. 三者之间的关系

总结一下，三者的关系可以这样理解：

JDK = JRE + 开发工具
- 如果你安装了JDK，那么你其实已经拥有了JRE（因为JDK包含了JRE）。
- 但反过来不行，如果你只安装了JRE，你就无法进行开发（比如编译代码）。
JRE = JVM + 类库
- JRE的核心是JVM，但它还包含了一些运行Java程序所需的类库。
JVM = Java程序的“灵魂”
- 没有JVM，Java程序就无法运行。

生活中的比喻：

JDK就像一个“全能型选手”，包含了开发和运行所需的全部工具。
JRE就像一个“轻量化选手”，只专注于运行程序。
JVM就像一个“幕后英雄”，默默为整个Java世界提供动力。

5. 实际应用场景

场景1：普通用户

如果你只是想运行Java程序（比如玩一款Java小游戏），那么你只需要安装JRE就可以了。
安装完JRE后，你的电脑就能运行任何Java程序了。

场景2：开发者

如果你想开发Java程序（比如写一个自己的应用或游戏），那么你需要安装JDK。
安装完JDK后，你就可以使用里面的工具（比如编译器、调试工具）来开发自己的程序了。

场景3：跨平台开发

无论你是在Windows、Linux还是Mac上开发或运行Java程序，JVM都会帮你搞定一切！这就是Java“一次编写，到处运行”的魅力所在。

6.三者关系图解

`==` 和 `equals()`：Java世界的“真假美猴王”！

在Java的世界里，有两个看似相似但实际上“性格迥异”的“兄弟”——== 和 equals()。它们就像一对“真假美猴王”，总能让新手程序员们“傻傻分不清”。今天，我们就来聊聊它们之间的区别，顺便用一些幽默的比喻让大家更容易理解！

1. `==`：表面功夫的“皮相大师”

== 是Java中的一个运算符，用于比较两个变量的值。它的比较方式取决于变量的类型：

（1）基本数据类型

对于基本数据类型（比如 int、char、boolean 等），== 比较的是它们的实际值。简单来说，就是“数值是否相等”。

int a = 10;
int b = 10;
System.out.println(a == b); // 输出：true

（2）引用数据类型

对于引用数据类型（比如 String、Object 等），== 比较的是它们在内存中的地址（即指向的对象是否是同一个）。换句话说，它比较的是“身份”，而不是“内容”。

String str1 = new String("hello");
String str2 = new String("hello");
System.out.println(str1 == str2); // 输出：false

2. `equals()`：深入灵魂的“内在比较”

equals() 是一个方法，用于比较两个对象的内容是否相同。默认情况下，equals() 方法的行为与 == 相同（即比较内存地址），但很多类（比如 String、Integer 等）会重写这个方法，使其比较对象的内容。

默认行为

在 Object 类中，equals() 方法的默认实现与 == 相同，即比较内存地址。

Object obj1 = new Object();
Object obj2 = new Object();
System.out.println(obj1.equals(obj2)); // 输出：false

重写行为

很多类会重写 equals() 方法，使其比较对象的内容。例如，String 类的 equals() 方法会比较字符串的内容是否相同。

String str1 = new String("hello");
String str2 = new String("hello");
System.out.println(str1.equals(str2)); // 输出：true

3. `==` 和 `equals()` 的区别总结（重点）

特性	`==`	`equals()`
作用域	运算符	方法
基本类型	比较数值	不适用（只能用于对象）
引用类型	比较内存地址	默认比较内存地址，可重写为比较内容
灵活性	固定行为	可重写，灵活性更高

`hashCode()`：Java世界的“身份证号”！

在Java的世界里，有一个神奇的方法叫做hashCode()。它就像每个对象的“身份证号”，帮助系统快速找到对象的位置。今天，我们就来聊聊它的作用、重要性以及一些需要注意的地方，顺便用一些幽默的比喻让大家更容易理解！

1. `hashCode()`：对象的“身份证号”

hashCode() 是一个方法，用于为对象生成一个唯一的整数（int类型），这个整数被称为哈希码或散列码。它的主要作用是帮助散列表（比如 HashSet、HashMap）快速定位对象的位置。

哈希表的工作原理

哈希表是一种存储键值对（key-value）的数据结构，它的特点是“能根据‘键’快速检索出对应的‘值’”。具体来说：

当你往哈希表中插入一个键值对时，哈希表会根据键的 hashCode() 值计算出一个索引位置。
如果这个位置是空的，哈希表会直接将键值对存入该位置。
如果这个位置已经有其他键值对了，哈希表会调用 equals() 方法检查这两个键是否相等：
- 如果相等，则更新值。
- 如果不相等，则重新计算索引位置（散列到其他位置）。

生活中的比喻

想象一下，哈希表就像一个“超级快递柜”，而 hashCode() 就是每个包裹的“快递单号”。快递员根据快递单号快速找到包裹的位置。如果两个包裹的快递单号相同，快递员就会检查它们是否是同一个包裹（通过 equals() 方法）。如果不是同一个包裹，快递员就会重新安排位置。

2. 为什么需要 `hashCode()`？

以 `HashSet` 为例

HashSet 是一个不允许重复元素的集合。当你往 HashSet 中添加一个对象时，它会先计算该对象的 hashCode() 值来判断该对象的位置：

如果该位置为空，HashSet 会假设该对象是唯一的，并将其存入该位置。
如果该位置已经有其他对象了，HashSet 会调用 equals() 方法检查这两个对象是否相等：
- 如果相等，则拒绝添加（认为是重复对象）。
- 如果不相等，则重新计算索引位置（散列到其他位置）。

为什么要引入 `hashCode()`？

如果不使用 hashCode()，直接使用 equals() 方法来检查重复对象，效率会非常低下。因为每次插入或查找都需要遍历整个集合，逐一比较所有元素。而通过 hashCode()，可以快速缩小范围，减少 equals() 的调用次数，从而大大提高性能。

3. `hashCode()` 和 `equals()` 的关系

规则1：如果两个对象相等，则它们的 `hashCode()` 必须相同

if (obj1.equals(obj2)) {
    obj1.hashCode() == obj2.hashCode(); // 必须成立 
}

规则2：两个对象的 `hashCode()` 相同，并不一定意味着它们相等

if (obj1.hashCode() == obj2.hashCode()) {
    obj1.equals(obj2); // 可能为 true 或 false 
}

规则3：如果重写了 `equals()` 方法，则必须重写 `hashCode()` 方法

这是因为 hashCode() 的默认实现是基于对象的内存地址的。如果你重写了 equals() 方法（比如比较对象的内容），但没有重写 hashCode() 方法，那么两个相等的对象可能会有不同的 hashCode() 值，导致哈希表无法正常工作。

4. `hashCode()` 的默认行为

在 Object 类中，hashCode() 的默认实现是基于对象的内存地址的。也就是说，每个对象的 hashCode() 值都是唯一的（只要它们没有被重写）。然而，这种默认行为并不适用于大多数实际场景，因为我们需要根据对象的内容生成 hashCode() 值。

5. 如何正确重写 `hashCode()`？

在重写 hashCode() 方法时，需要注意以下几点：

一致性：如果两个对象相等（equals() 返回 true），它们的 hashCode() 必须相同。
分布性：尽量让 hashCode() 的值均匀分布，避免过多冲突（即不同的对象生成相同的 hashCode()）。
性能：hashCode() 方法应该尽可能高效，因为它会被频繁调用。

示例：正确重写 `hashCode()` 和 `equals()`

public class Person {
    private int id;
    private String name;
 
    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
 
    @Override 
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person other = (Person) obj;
        return id == other.id && Objects.equals(name, other.name);
    }
 
    @Override 
    public int hashCode() {
        int result = 17;
        result = 31 * result + id;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }
}

在这个例子中：