Java面试题-基础（2024最新版），抖音Java后端123面开挂

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

private static void fun2() {

  String ids0="	asd fghjkl 	";

  ids0 = ids0 == null?"" : ids0.trim();

  System.out.println(ids0);//asd fghjkl

System.out.println((name==null)?0:name.hashCode()));

}

引用类型使用？

1:导包：找到对应的类  类前边import 包名.类名;   java.lang包下的类可以不导包，直接用

2:定义变量，创建对象，为变量赋值

引用类型  变量名 = new 引用类型();

3:调用方法

变量名.方法名();

Random:随机数类

所属包：java.util.Random

创建对象赋值变量：Random r = new Random();

调用方法：int randomNumber = r.nextInt(100);

Scanner:键盘录入类

所属包：java.util.Scanner

创建对象赋值变量：Scanner sc = new Scanner(System.in);

调用方法：int enterNumber = sc.nextInt();

equal和==、=什么区别？

＝是赋值运算符

对于基本类型和引用类型 == 的作用效果是不同的：

• 基本类型：比较的是值是否相同；

• 引用类型：比较的是引用是否相同；

代码示例：

String x = “string”;

String y = “string”;

String z = new String(“string”);

System.out.println(x==y); // true

System.out.println(x==z); // false

System.out.println(x.equals(y)); // true

System.out.println(x.equals(z)); // true

代码解读：因为 x 和 y 指向的是同一个引用，所以 == 也是 true，而 new String()方法则重写开辟了内存空间，所以 == 结果为 false，而 equals 比较的一直是值，所以结果都为 true。

== 对于基本类型来说是值比较（两个变量的值是否相等）。

==对于引用类型来说是比较是否是同一对象（两个变量在堆中存储的地址是否相同）；

而 equals 默认情况下是引用比较，

public class Object { public boolean equals(Object obj) { return (this == obj); } } （默认的Object方法：）equals 本质上就是 ==

只是很多类重新了 equals 方法，比如 String、Integer 等把它变成了值比较，所以一般情况下 equals 比较的是值是否相等。

==比较的是2个对象的地址，而equals比较的是2个对象的内容。

显然，当equals为true时，==不一定为true；

重写equals为什么必须要重写hashCode?

因为默认的equals方法是Object的方法，比较的是内存地址；而默认的hashcode方法返回的是对象的内存地址转换成的一个整数。

相关类重写后的hashcode方法返回的新的哈希值与类的属性有关的。

假如只重写equals而不重写hashcode，那么Student类的hashcode方法就是Object默认的hashcode方法，由于默认的hashcode方法是根据对象的内存地址经哈希算法得来的，显然此时s1!=s2,故两者的hashcode不一定相等。

举个例子：

Student s1=new Student(“小明”,18);

Student s2=new Student(“小明”,18);

equals比较两对象内容是否相同，把两个内容相同的对象equals处理返回true，而hashcode方法根据对象的内存地址转换成一个数比较显然不相等。

原因：

1、默认的hashcode方法是根据对象的内存地址经哈希算法得来的；

2、Java规范的约定，在集合类中需要重写这两个方法；

关系：

equals()相等，hashcode()一定相等；

quals()不等，hashcode()可能相等;

如果不重写hashcode和equals方法的话，放入相同的key时（特殊情况下），就不知道取哪一个。

尽量用eclipse自动生成，尽量不要自己敲，很有可能出错。

说下Java堆、栈、内存的理解？

JVM内存的划分有五片：java分了5片内存。

1：寄存器。2：本地方法区。3：方法区。4：栈内存。5：堆内存。

栈：存储的都是局部变量 ( 函数中定义的变量，函数上的参数，语句中的变量 )；

只要数据运算完成所在的区域结束，该数据就会被释放。

堆：用于存储数组和对象，也就是实体。啥是实体啊？就是用于封装多个数据的。

1：每一个实体都有内存首地址值。

2：堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样。

3：垃圾回收机制。

https://blog.csdn.net/jasonwang18/article/details/70578647

Java中class解析过程？

if&switch&while&for的使用？

当判断固定个数的值的时候，可以使用if，也可以使用switch。

switch工作原理：用小括号中的变量的值依次和case后面的值进行对比，和哪个case后面的值相同了,就执行哪个case后面的语句，如果没有相同的则执行default后面的语句；

char ch = ‘A’; switch (ch) { case ‘B’: System.out.println(“case one”); break; case ‘A’: System.out.println(“case two”); break; }

while和for可以进行互换。

区别在于：如果需要定义变量控制循环次数。建议使用for。因为for循环完毕，变量在内存中释放。

for (int i = 0; i < 10; i++) { System.out.println(“hi girl”); }

Java中的方法覆盖（Overwrite）和方法重载（Overload）的区别？

重载Overload：同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同(即参数个数或类型不同)。

重写Override：发生在子类继承父的关系中,父类中的方法被子类继承.方法名,返回值类型,参数完全一样,但是方法体不一样.

表示子类中的方法可以与父类的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。

如何区分重载：当函数同名时，只看参数列表。和返回值类型没关系。

GC是什么? 为什么要用GC?好处有哪些？

（1）GC是垃圾收集的意思（Gabage['gɑːbɪdʒ] Collection）。

（2）内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的。Java程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：System.gc() 或Runtime.getRuntime().gc() 。

（3）垃圾回收可以有效防止内存泄漏，有效的使用可用的内存。垃圾回收器通常作为一个低优先级的线程运行，不可预知的情况下对内存堆中已死亡的或者长时间没有使用的对象进行清除和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。

回收机制：分代复制来及回收、标记来及回收、增量垃圾回收等方式

#Java语言没有提供释放已分配内存的显示操作方法。

谈谈面向对象的理解？

什么是面向对象及其特点：

面向对象：基于面向过程，找一个对象，帮帮你做事情。

1：将复杂的事情简单化。

2：面向对象将以前的过程中的执行者，变成了指挥者。

3：面向对象这种思想是符合现在人们思考习惯的一种思想。

java 的三大特点 也就是封装继承多态。

继承 可以看作是面向对象最显著的特征，继承是从已经有的类中派生出新的类 子类继承了父类的属性和行为，并且根据自己的需求扩展出新的行为，从而提高了代码的复用性， 多态 ： 封装继承几乎都是为了多态做准备的 ，在执行期间判断对象的实际类型，根据实际类型调用响应的方法。

封装 继承 多态？

封装：就是把普通的对象进行封装，对象的属性设为private私有的，对外提供get、set方法，其他类只能通过get、set对对象属性值进行操作。

继承：是发生在两个类之间，一个类继承另一个类是说这个类属于另一个类，具有另一个类的所有属性和方法，同时它还可以有另一个类不具备的方法和属性。

多态：是建立在继承的基础上的，一个父类对象可以产生多个不同的子类对象，根据这些子类对象的不同可以具备不同的方法，也就是说表现出了不同的形态即多态。

父类中的私有成员变量，无法在子类中直接访问，可以通过从父类中继承得到的protected、public方法（如getter、setter方法）来访问。

https://blog.csdn.net/evilcry2012/article/details/52230622

什么是内存泄露、内存溢出？

内存泄漏：就是忘记释放使用完毕的内存，让下次使用有一定风险。

1. 内存泄露是指程序中间动态分配了内存，但在程序结束时没有释放这部分内存，从而造成那部分内存不可用的情况，重启计算机可以解决，但也有可能再次发生内存泄露，内存泄露和硬件没有关系，它是由软件设计缺陷引起的。

2. 比如：缓存的应用，如果不设置上限的话，缓存的容量可能会一直增长。

3. 内存泄漏可以分为4类：

• 1. 常发性内存泄漏：发生内存泄漏的代码会被多次执行到。

• 2. 偶发性内存泄漏：发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。

• 3. 一次性内存泄漏：发生内存泄漏的代码只会被执行一次，或者由于算法上的缺陷，导致总会有一块仅且一块内存发生泄漏。

• 4. 隐式内存泄漏：。程序在运行过程中不停的分配内存，但是直到结束的时候才释放内存。（几周甚至几个月，不及时释放内存也可能导致最终耗尽系统的所有内存。）

内存溢出：对于整个应用程序来说，JＶＭ内存空间已经没有多余的空间分配给新的对象，造成内存数据溢出。

初始化和实例化区别?

初始化：

就是给已有的实例或者变量进行赋予初始值。

实例化指将一个类实例化成一个对象 。

初始化：int i=0; 实例化：class c = new class();

一个对象实例化过程：

Person p = new Person();

1，JVM会读取指定的路径下的Person.class文件，并加载进内存，

并会先加载Person的父类(如果有直接的父类的情况下)。

2，在堆内存中的开辟空间，分配地址。

3，并在对象空间中，对对象中的属性进行默认初始化。

4，调用对应的构造函数进行初始化。

5，在构造函数中，第一行会先到调用父类中构造函数进行初始化。

6，父类初始化完毕后，在对子类的属性进行显示初始化。

7，在进行子类构造函数的特定初始化。

8，初始化完毕后，将地址值赋值给引用变量.

多态的4种实现方式？

接口实现接口， 类实现类，重载和重写。

关键词instanceof用法？

双目运算符。当左边的对象是右边的类的实例或子类的实例。返回true，否则false.

关键字用法：A instanceof B ，返回值为boolean类型，用来判断A是否是B的实例对象或者B子类的实例对象。

如果是则返回true，如果不是，或者A是 null，返回false。

如：

Person p = new Person() ;

// Man m = new Man() ;

//Man是Person的子类

Animal a = new Animal() ;

m instanceof Man

//返回true

m instanceof Animal

//返回false

m instanceof Person

//返回true

修饰符有哪些？

权限修饰符：private、 default、protected、public

状态修饰符：static、final

抽象修饰符：abstract

public，private，proteced,default四种权限的区别?

	public	protected	default	private
本类	Y	Y	Y	Y
同一包---子类、无关类	Y	Y	Y	N
不同包---子类	Y	Y	N	N
不同包--无关类	Y	N	N	N

final、abstract、static、this、super的作用？

final（最终）：用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。内部类要访问局部变量，局部变量必须定义成final类型。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提高垃圾收集时的其他资源回收，例如关闭文件等。JVM不保证此方法总被调用。

static：是一个修饰符，用于修饰成员(成员变量和成员函数)，被static修饰的成员属于类，不属于单个这个类的某个对象。

特点：

1、被静态修饰的成员变量，其值属于类，被所有成员共享。

2、被静态修饰的成员，可以直接被类名所调用。类名.静态方式。（也就是说，静态的成员多了一种调用方式。）

3、用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大）。（而且优先于对象存在）

abstract：

抽象类的特点：

1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。

2：抽象方法只定义方法声明，并不定义方法实现。

3：抽象类不可以被创建对象(实例化)。

4：只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。

抽象类的细节：

1：抽象类中是否有构造函数？有，用于给子类对象进行初始化。

2：抽象类中是否可以定义非抽象方法？

可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。

3：抽象关键字abstract和哪些不可以共存？final , private , static

4：抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。

This：代表是本类类型的对象引用。

Super：代表是子类所属的父类中的内存空间引用。

super()和this()是否可以同时出现在构造函数中。

两个语句只能有一个定义在第一行，所以只能出现其中一个。

super()或者this():为什么一定要定义在第一行？

因为super()或者this()都是调用构造函数，构造函数用于初始化，所以初始化的动作要先完成。

局部变量：被final修饰，声明之后，可以赋值一次。

成员变量：被final修饰，声明时，就必须赋值，就是常量了。常量名字母要求全部大写。

final finally finalize区别？

关键字：enum，使用方法？

抽象类和接口的区别？

抽象类：含有abstract修饰的类即为抽象类，抽象类不能创建实例对象。含有abstract方法的类必须定义为抽象类，抽象类中的方法不必是抽象的。（抽象类中定义抽象方法必须在具体子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型）。

接口：可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。

下面比较一下两者的语法区别：

1. 抽象类可以有构造方法，接口中不能有。

2. 抽象类中可以有普通成员变量，接口中没有普通成员变量

3. 抽象类中可以包含静态方法，接口中不能包含静态方法

4. 一个类可以实现多个接口，但只能继承一个抽象类。

5. 抽象类中可以定义非抽象方法，子类可以直接继承使用；接口中必须都是抽象方法，需要子类去实现。

6. 抽象类中的抽象方法的访问类型可以使public、protected和默认类型，但接口中的抽象方法只能是public类型的，并且默认修饰即为public abstract类型。

7. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

构造方法是什么？有什么用？

API简介

— java.util.Math: 用于数学运算的工具类，属性和行为都是静态的。该类是final不允许继承。

static double ceil(double a) ; //返回大于指定数值的最小整数

static double floor(double a) ; //返回小于指定数值的最大整数

static long round(double a) ; //四舍五入成整数

static double pow(double a, double b) ; //a的b次幂

static double random(); //返回0~1的伪随机数

public static void main(String[] args) {

Random r = new Random();

for(int x=0; x<10; x++) {

//double d = Math.floor(Math.random()*10+1);

//int d = (int)(Math.random()*10+1);

int d = r.nextInt(10)+1;

System.out.println(d);

API— java.util.Date：日期类，月份从0-11；

API— java.lang.Runtime: 类中没有构造方法，不能创建对象。

但是有非静态方法。说明该类中应该定义好了对象，并可以通过一个static方法获取这个对象。用这个对象来调用非静态方法。这个方法就是 static Runtime getRuntime();

这个Runtime其实使用单例设计模式进行设计。

class  RuntimeDemo {

public static void main(String[] args) throws Exception {

Runtime r = Runtime.getRuntime();

Process p = r.exec(“notepad.exe SystemDemo.java”); //运行指定的程序

Thread.sleep(4000);

p.destroy();  //杀掉进程

}

}

String & StringBuffer 和 StringBuilder 的区别：

1、String字符串常量，StringBuffer字符串变量，StringBuilder字符串变量

(String是“字符创常量”，也就是不可改变的对象。

是对象不是原始类型.

为不可变对象,一旦被创建,就不能修改它的值.

对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.

String 是final类,即不能被继承.

String s = “abcd”;  s = s+1;  System.out.print(s);// result : abcd1)

string是可继承类吗 ?

因为Sting是这样定义的：public final class String extends Object，里边有final关键字，所以不能被 继承。

2、StringBuilder与 StringBuffer

StringBuilder： 效率高，线程不安全(单线程操作，使用StringBuilder)。

StringBuffer：线程安全的(多线程操作，使用StringBuffer 安全)

3、 对于三者使用的总结：

1.如果要操作少量的数据用 = String

2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder

3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

总结: 如果在程序中需要对字符串进行频繁的修改连接操作的话.使用StringBuffer性能会更高

在java中有3个类来负责字符的操作。

1.Character 是进行单个字符操作的，

2.String 对一串字符进行操作。不可变类。

3.StringBuffer 也是对一串字符进行操作，但是可变类。

IO流有哪些？区别是什么？常用操作？

流的操作只有两种：读和写。

字节流：InputStream  OutputStream

字符流：Reader  Writer

IO流操作：

close()和flush()的区别？

flush()：将缓冲区的数据刷到目的地中后，流可以使用。

close()：将缓冲区的数据刷到目的地中后，流就关闭了，该方法主要用于结束调用的底层资源。这个动作一定做。

介绍下递归？

递归：就是函数自身调用自身。

什么时候用递归呢？

当一个功能被重复使用，而每一次使用该功能时的参数不确定，都由上次的功能元素结果来确定。

简单说：功能内部又用到该功能，但是传递的参数值不确定。(每次功能参与运算的未知内容不确定)。

递归的注意事项：

1：一定要定义递归的条件。

2：递归的次数不要过多。容易出现 StackOverflowError 栈内存溢出错误。

其实递归就是在栈内存中不断的加载同一个函数。

public class jiecheng { public static void main(String[] args) { System.out.println(“阶乘的结果：”+jiecheng.multiply(10)); } public static int multiply(int n){ if(n==1){ return n; } else{ return n*multiply(n-1); } } }

正则表达式是什么？常见应用？

其实是用来操作字符串的一些规则。

好处：正则的出现，对字符串的复杂操作变得更为简单。

特点：将对字符串操作的代码用一些符号来表示。只要使用了指定符号，就可以调用底层的代码对字符串进行操作。符号的出现，简化了代码的书写。

最后，附一张自己面试前准备的脑图：

面试前一定少不了刷题，为了方便大家复习，我分享一波个人整理的面试大全宝典

• Java核心知识整理

• Spring全家桶（实战系列）

Step3：刷题

既然是要面试，那么就少不了刷题，实际上春节回家后，哪儿也去不了，我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。

以下是我私藏的面试题库：

很多人感叹“学习无用”，实际上之所以产生无用论，是因为自己想要的与自己所学的匹配不上，这也就意味着自己学得远远不够。无论是学习还是工作，都应该有主动性，所以如果拥有大厂梦，那么就要自己努力去实现它。

最后祝愿各位身体健康，顺利拿到心仪的offer！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
y(int n){ if(n==1){ return n; } else{ return n*multiply(n-1); } } }

正则表达式是什么？常见应用？

其实是用来操作字符串的一些规则。

好处：正则的出现，对字符串的复杂操作变得更为简单。

特点：将对字符串操作的代码用一些符号来表示。只要使用了指定符号，就可以调用底层的代码对字符串进行操作。符号的出现，简化了代码的书写。

最后，附一张自己面试前准备的脑图：

[外链图片转存中…(img-Tx9s72pR-1713419392793)]

面试前一定少不了刷题，为了方便大家复习，我分享一波个人整理的面试大全宝典

• Java核心知识整理

[外链图片转存中…(img-ryYs9DBf-1713419392794)]

• Spring全家桶（实战系列）

[外链图片转存中…(img-9gJWzD8c-1713419392794)]

Step3：刷题

既然是要面试，那么就少不了刷题，实际上春节回家后，哪儿也去不了，我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。

以下是我私藏的面试题库：

[外链图片转存中…(img-ObQnLzOw-1713419392795)]

很多人感叹“学习无用”，实际上之所以产生无用论，是因为自己想要的与自己所学的匹配不上，这也就意味着自己学得远远不够。无论是学习还是工作，都应该有主动性，所以如果拥有大厂梦，那么就要自己努力去实现它。

最后祝愿各位身体健康，顺利拿到心仪的offer！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-cZUzCRsd-1713419392796)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！