先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024b （备注Java）
正文
如果我们写了一个构造器，在编译后就不会在构造出来一个构造器 。
【演示】
public class Student{
private String name;
public Student(String name){
this.name = name;
}
}
main:
//编译报错,因为没有无参构造器
Student s = new Student();
封装
==
如果我们想看电视，我们需要去了解电视里面的二极管的构造吗？当然不是，我们只需要拿到开关，按下开关键就可以。
电视制造商为了方便我们使用电视，把复杂的内部细节全部封装起来，只给我们暴露简单的接口。
就比如开关。
白话说就是：该露的露，该藏的藏。
**专业术语：**我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允外部干涉。低耦合：仅暴露少量的方法给外部使用。
封装（隐藏的数据）
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
封装的步骤
1.需要使用private来修饰需要封装的变量。
2.提供一个公开的方法设置或者访问私有属性
设置 通过set方法，命名格式： set属性名（）; 属性的首字母要大写
访问 通过get方法，命名格式： get属性名（）; 属性的首字母要大写
【演示】
//对象能在类的外部"直接"访问
public class Student{
public String name;
public void println(){
System.out.println(this.name);
}
}
public class Test{
public static void main(String[] args){
Student s = new Student();
s.name = “tom”;
}
}
在类中一般不会把数据直接暴露在外部的,而使用private(私有)关键字把数据隐藏起来。
【演示】
public class Student{
private String name;
}
public class Test{
public static void main(String[] args){
Student s = new Student();
//编译报错,在类的外部不能直接访问类中的私有成员
s.name = “tom”;
}
}
如果在类的外部需要访问这些私有属性 , 那么可以在类中提供对于的 get 和 set 方法 , 以便让用户在类的外部可以间接的访问到私有属性。
//set负责给属性赋值
//get负责返回属性的值
public class Student{
private String name;
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
}
public class Test{
public static void main(String[] args){
Student s = new Student();
s.setName(“tom”);
System.out.println(s.getName());
}
}
作用和意义
1.提高程序的安全性，保护数据。
2.隐藏代码的实现细节。
3.同一用户的调用接口。
4.提高系统的可维护性。
5.便于调用者调用。
良好的封装，便于修改内部代码，提高可维护性。
良好的封装，可进行数据完整性检测，保证数据的有效性。
方法的重载
一般类中有多个方法，但是也有很多方法重名，但是参数类型不同，这种情况就叫做方法的重载，方法的重载可以提高调用方法的灵活性。
【演示：println的方法重载】
public class Test{
public void test(String str){
}
public void test(int a){
}
}
方法的重载必须满足一下条件：
1.满足方法名称相同。
2.方法的参数列表类型不同。
3.方法返回值可以相同也可以不同。
在java中**,判断一个类中的俩个方法是否相同,主要参考俩个方面😗*方法名字和参数列表
下面是我自己写的一个小例子，大家可以看看嘿嘿嘿嘿。
继承
==
现实世界中继承无处不在。
比如动物可以分为哺乳动物，爬行动物等。
而哺乳动物还可以在继续分为：灵长动物，鲸等。
继承的本质事对某一批的抽象，和对现实世界的更好建模。
为什么需要继承？
继承的好处是什么？
第一好处：继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象。
第二好处：为了提高代码的复用性。
extands 的意思是 “ 扩展 ” 。子类是父类的扩展。
【注】JAVA中类只有单继承，没有多继承！ 接口可以多继承！
继承
–
1.继承事类和类之间的关系，除了继承还有组合，依赖，聚合等。
2.继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
public class student extends Person{
}
3.子类和父类之间,从意义上讲应该具有"is a"的关系。
4.类和类之间的继承是单继承。
一个子类只能"直接"继承一个父类,就像是一个人只能有一个亲生父亲
一个父类可以被多子类继承,就像一个父亲可以有多个孩子
注:java中接口和接口之间,有可以继承,并且是多继承。
5.父类中的属性和方法可以被子类继承
子类中继承了父类中的属性和方法后,在子类中能不能直接使用这些属性和方法,是和这些属性和方
法原有的修饰符(public protected default private)相关的。
例如 :
父类中的属性和方法使用public修饰,在子类中继承后"可以直接"使用
父类中的属性和方法使用private修饰,在子类中继承后"不可以直接"使用
Object类
Java中每一个类都是直接或间接的继承了Object这个类。
System.out.println(任何对象 instanceof Object);
//输出结果:true
//注:任何对象也包含数组对象
例如:
//编译后,Person类会默认继承Object
public class Person{
}
//Student是间接的继承了Object
public class Student extends Person{
}
在Object类中,提供了一些方法被子类继承,那么就意味着,在java中,任何一个对象都可以调用这些被继承过来的方法（因为Object是所以类的父类）
例如:toString方法、equals方法、getClass方法等。
注：Object类中的每一个方法之后都会使用到。
Super****关键字
子类继承父类以后，在子类中可以使用this来表示或者访问或调用子类中的属性或方法，使用super可以访问或者调用父类中的属性和方法。
super的使用
【访问父类中的属性】
public class Person{
protected String name = “zs”;
}
public class Student extends Person{
private String name = “lisi”;
public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}
【调用父类中的方法】
public class Person{
public void print(){
System.out.println(“Person”);
}
}
public class Student extends Person{
public void print(){
System.out.println(“Student”);
}
public void test(){
print();
this.print();
super.print();
} }
【调用父类中的构造器】
public class Person{
}
public class Student extends Person{
//编译通过,子类构造器中会隐式的调用父类的无参构造器
//super();
public Student(){
}
}
父类没有无参构造
public class Person{
protected String name;
public Person(String name){
this.name = name;
}
}
public class Student extends Person{
//编译报错,子类构造器中会隐式的调用父类的无参构造器,但是父类中没有无参构造器
//super();
public Student(){
}
}
【显式的调用父类的有参构造器】
public class Person{
protected String name;
public Person(String name){
this.name = name;
}
}
public class Student extends Person{
//编译通过,子类构造器中显式的调用父类的有参构造器
public Student(){
super(“tom”);
}
}
注：不管是显式还是隐式的父类的构造器,super语句一定要出现在子类构造器中第一行代码。所以this和super不可能同时使用它们调用构造器的功能,因为它们都要出现在第一行代码位置。
【super使用的注意的地方】
1.用super调用父类构造方法，必须是构造方法中的第一个语句。
2.super只能出现在子类的方法或者构造方法中。
3.super 和 this 不能够同时调用构造方法。（因为this也是在构造方法的第一个语句）。
【super 和 this 的区别】
1.代表的事物不一样:
this ：代表所属方法的调用者对象。
super：代表父类对象的引用空间。
2.使用前提不一致：
this：在非继承的条件下也可以使用。
super：只能在继承的条件下才能使用。
3.调用构造方法：
this：调用本类的构造方法。
super：调用的父类的构造方法
方法的重写
方法的重写（override）
1. 方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不能被重写.
2.静态方法不能重写。
1. 父类的静态方法不能被子类重写为非静态方法 //编译出错
2. 父类的非静态方法不能被子类重写为静态方法；//编译出错
3. 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)
【例子】
A类继承B类
A和B中都一个相同的静态方法test
B a = new A();
a.test();
//调用到的是B类中的静态方法test
A a = new A();
a.test();
//调用到的是A类中的静态方法test
可以看出静态方法的调用只和变量声明的类型相关
这个和非静态方法的重写之后的效果完全不同
1. 私有方法不能被子类重写，子类继承父类后,是不能直接访问父类中的私有方法的,那么就更谈不上重写了。
【例子】
public class Person{ private void run(){
}
}
//编译通过,但这不是重写,只是俩个类中分别有自己的私有方法
public class Student extends Person{
private void run(){
}
}
重写的语法
1.方法名必须相同。
2.参数列表必须相同。
3.访问控制修饰符可以被扩大,但是不能被缩小： public protected default private。
4.抛出异常类型的范围可以被缩小,但是不能被扩大。
ClassNotFoundException —> Exception
5.返回类型可以相同,也可以不同,如果不同的话,子类重写后的方法返回类型必须是父类方法返回类型的子类型。
例如：父类方法的返回类型是Person,子类重写后的返回类可以是Person也可以是Person的
子类型
为什么要重写？
子类继承父类中的方法，但是父类中的方法并不满足子类的功能需求，所以子类中要把方法进行重写。
总结：
方法重写的时候，必须存在继承关系。
方法重写的时候，方法名和形式参数 必须跟父类是一致的。
方法重写的时候，子类的权限修饰符必须要大于或者等于父类的权限修饰符。( private < protected <public，friendly < public )
方法重写的时候，子类的返回值类型必须小于或者等于父类的返回值类型。( 子类 < 父类 ) 数据类型没有明确的上下级关系
方法重写的时候，子类的异常类型要小于或者等于父类的异常类型。
多态
==
认识多态
多态是OOP（面向对象）中一个重要的特性，主要是用来实现动态联编的，换句话说就是程序的最终状态就有在执行过程中才被决定而非在编译期间就决定了。这对于大型系统来说能提高系统的灵活性和扩展性。
相同类域的不同对象,调用相同的方法,执行结果是不同的：
1.一个对象的实际类型是确定的
例如：
Person s1 = new Student;
//和
Student s2 = new Student;
//是不相同的
2.可以指向对象的引用的类型有很多
一个对象的实现类型虽然是确定的,但是这个对象所属的类型可能有很多种。
例如：Student继承了Person类
Studnet s1 = new Student;
Person s2 = new Student;
Object s3 = new Student;
因为Person和Object都是Student的父类。
注：一个对象的实际类型是确定,但是可以指向这个对象的引用的类型,却是可以是这对象实际类型的任意父类型
1.一个父类引用可以指向它的任何一个子类对象
例如：
Object o = new AnyClass();
Person p = null;
p = new Student();
p = new Teacher();
p = new Person();
2.多态中的方法调用
例如：
public class Person{
public void run(){
}
}
public class Student extends Person{
}
3.调用到的run方法,是Student从Person继承过来的run方法
main:
Person p = new Student();
p.run();
例如：
public class Person{
public void run(){
}
}
public class Student extends Person{
public void run(){
//重写run方法
}
}
//调用到的run方法,是Student中重写的run方法
main:
Person p = new Student();
p.run();
注：子类继承父类,调用a方法，如果a方法在子类中没有重写,那么就是调用的是子类继承父类的a方法, 如果重写了,那么调用的就是重写之后的方法。
子类中独有方法的调用
public class Person{
public void run(){
}
}
public class Student extends Person{
public void test(){
}
}
main:
Person p = new Student();
//调用到继承的run方法 p.run();
//编译报错,因为编译器检查变量p的类型是Person,但是在Person类中并没有发现test方法,所以编 译报错.
p.test();
注：一个变量x,调用一个方法test,编译器是否能让其编译通过,主要是看声明变量x的类型中有没有定义test方法,如果有则编译通过,如果没有则编译报错.而不是看x所指向的对象中有没有test方法.
原理：编译看左边，运行不一定看右边。
编译看左边的意思： java 编译器在编译的时候会检测引用类型中含有指定的成员，如果没有就会报错。子类的成员是特有的，父类的没有的，所以他是找不到的。
子类和父类引用指向对象的区别
Student s = new Student();
Person p = new Student();
Object o = new Student();
变量s能调用的方法是Student中有的方法(包括继承过来的),变量p能调用的方法是Person中有的方法(包括继承过来的)。
但是变量p是父类型的,p不仅可以指向Student对象,还可以指向Teacher类型对象等,但是变量s只能指Studnet类型对象,及Student子类型对象。变量p能指向对象的范围是比变量s大的。
Object类型的变量o,能指向所有对象,它的范围最大,但是使用变量o能调用到的方法也是最少的,只能调用到Object中的声明的方法,因为变量o声明的类型就是Object.
注：：java中的方法调用,是运行时动态和对象绑定的,不到运行的时候,是不知道到底哪个方法被调用的。
重写，重载和多态的关系
重载是编译时多态
调用重载的方法,在编译期间就要确定调用的方法是谁,如果不能确定则编译报错。
重写是运行时多态
调用重写的方法,在运行期间才能确定这个方法到底是哪个对象中的。这个取决于调用方法的引用,在运行期间所指向的对象是谁,这个引用指向哪个对象那么调用的就是哪个对象中的方法。(java中的方法调用, 是运行时动态和对象绑定的)
多态的注意事项
1.多态是方法的多态，属性没有多态性。
2.编写程序时，如果想调用运行时类型的方法，只能进行类型转换。不然通不过编译器的检查。但是如果两个没有关联的类进行强制转换，会报：ClassCastException。 比如：本来是狗，我把它转成猫。就会报这个异常。
3.多态的存在要有3个必要条件：要有继承，要有方法重写，父类引用指向子类对象。
多态存在的条件
1.有继承关系
2.子类重写父类方法
3.父类引用指向子类对象
补充一下第二点，既然多态存在必须要有“子类重写父类方法”这一条件，那么以下三种类型的方法是没有办法表现出多态特性的（因为不能被重写）：
1.static方法，因为被static修饰的方法是属于类的，而不是属于实例的。
2.fifinal方法，因为被fifinal修饰的方法无法被子类重写。
3.private方法和protected方法，前者是因为被private修饰的方法对子类不可见，后者是因为尽管被protected修饰的方法可以被子类见到，也可以被子类重写，但是它是无法被外部所引用的，一个不能被外部引用的方法，怎么能谈多态呢。
方法绑定
执行调用方法时，系统根据相关信息，能够执行内存地址中代表该方法的代码。分为静态绑定和动态绑定。
静态绑定
在编译期完成，可以提高代码执行速度。
动态绑定
通过对象调用的方法，采用动态绑定机制。这虽然让我们编程灵活，但是降低了代码的执行速度。这也是JAVA比C/C++速度慢的主要因素之一。JAVA中除了fifinal类、fifinal方、static方法，所有方法都是JVM在运行期才进行动态绑定的。
多态：如果编译时类型和运行时类型不一致，就会造成多态。
instanceof****和类型转换
instanceof
public class Person{ public void run(){
} }
public class Student extends Person{
}
public class Teacher extends Person{
}
main:
Object o = new Student();
System.out.println(o instanceof Student);//true
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true
System.out.println(o instanceof Teacher);//false
System.out.println(o instanceof String);//false
---------------------------
Person o = new Student();
System.out.println(o instanceof Student);//true
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true
System.out.println(o instanceof Teacher);//false
//编译报错
System.out.println(o instanceof String);
---------------------------
Student o = new Student();
System.out.println(o instanceof Student);//true
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true
//编译报错
System.out.println(o instanceof Teacher);
//编译报错
System.out.println(o instanceof String);
【分析1】
System.out.println(x instanceof Y);
该代码能否编译通过,主要是看声明变量x的类型和Y是否存在子父类的关系.有"子父类关"系就编译通过, 没有子父类关系就是编译报错.
之后学习到的接口类型和这个是有点区别的。
【分析2】
System.out.println(x instanceof Y);
输出结果是true还是false,主要是看变量x所指向的对象实际类型是不是Y类型的"子类型".
main:
Object o = new Person();
System.out.println(o instanceof Student);//false
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true
System.out.println(o instanceof Teacher);//false
System.out.println(o instanceof String);//false
类型转换
public class Person{ public void run(){
}
}
public class Student extends Person{
public void go(){
}
}
public class Teacher extends Person{
}
【为什么要类型转换】
//编译报错,因为p声明的类型Person中没有go方法
Person p = new Student();
p.go();
//需要把变量p的类型进行转换
Person p = new Student();
Student s = (Student)p;
s.go();
或者//注意这种形式前面必须要俩个小括号
((Student)p).go();
【类型转换中的问题】
//编译通过 运行没问题
Object o = new Student();
Person p = (Person)o;
//编译通过 运行没问题
Object o = new Student();
Student s = (Student)o; //编译通过,运行报错 Object o = new Teacher(); Student s = (Student)o;
即: X x = (X)o;
运行是否报错,主要是变量o所指向的对象实现类型,是不是X类型的子类型,如果不是则运行就会报错。
【总结】
1.父类引用可以指向子类对象，子类引用不能指向父类对象。
2.把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型。 如Father father = new Son();
3.把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型。
如father就是一个指向子类对象的父类引用，把father赋给子类引用son 即Son son =（Son） father；
其中father前面的（Son）必须添加，进行强制转换。
4.upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法，子类方法有效。
5.向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想。
修饰符
===
static****修饰符
1.static****变量
在类中，使用static修饰的成员变量,就是静态变量,反之为非静态变量。
静****态变量和非静态变量的区别
静态变量属于类的,"可以"使用类名来访问,非静态变量是属于对象的,"必须"使用对象来访问.
public class Student{
private static int age;
private double score;
public static void main(String[] args) {
Student s = new Student();
//推荐使用类名访问静态成员
System.out.println(Student.age);
System.out.println(s.age);
System.out.println(s.score);
}
}
静态变量对于类而言在内存中只有一个,能被类的所有实例所共享。实例变量对于类的每个实例都有一份, 它们之间互不影响.
public class Student{
private static int count;
private int num;
public Student() {
count++;
num++;
}
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
Student s3 = new Student();
Student s4 = new Student();
//因为还是在类中,所以可以直接访问私有属性
System.out.println(s1.num);
System.out.println(s2.num);
System.out.println(s3.num);
System.out.println(s4.num);
System.out.println(Student.count);
System.out.println(s1.count);
System.out.println(s2.count);
System.out.println(s3.count);
System.out.println(s4.count);
}
}
在加载类的过程中为静态变量分配内存,实例变量在创建对象时分配内存，所以静态变量可以使用类名来直接访问,而不需要使用对象来访问。
2.static****方法
在类中，使用static修饰的成员方法,就是静态方法,反之为非静态方法。
静态****方法和非静态方法的区别
静态方法数属于类的,"可以"使用类名来调用,非静态方法是属于对象的,"必须"使用对象来调用.
静态方法"不可以"直接访问类中的非静态变量和非静态方法,但是"可以"直接访问类中的静态变量和静态方法。
注意：:this和super在类中属于非静态的变量.(静态方法中不能使用)
public class Student{
private static int count;
private int num;
public void run(){
}
public static void go(){
}
public static void test(){
//编译通过
System.out.println(count);
go();
//编译报错
System.out.println(num);
run();
}
}
非静态方法"可以"直接访问类中的非静态变量和非静态方法,也"可以"直接访问类中的静态变量和静态方法。
public class Student{
private static int count;
private int num;
public void run(){
}
public static void go(){
}
public void test(){
//编译通过
System.out.println(count);
go();
//编译通过
System.out.println(num);
run();
}
}
思考：为什么静态方法和非静态方法不能直接相互访问? 加载顺序的问题！
父类的静态方法可以被子类继承,但是不能被子类重写。
public class Person {
public static void method() {
}
}
//编译报错
public class Student extends Person {
public void method(){
}
}
例如:
public class Person {
public static void test() {
System.out.println(“Person”);
}
}
//编译通过,但不是重写
public class Student extends Person {
public static void test(){
System.out.println(“Student”);
}
}
main:
Perosn p = new Student();
p.test();
//输出Person
p = new Person();
p.test();
//输出Perosn
和非静态方法重写后的效果不一样
父类的非静态方法不能被子类重写为静态方法 ；
public class Person {
public void test() {
System.out.println(“Person”);
}
}
//编译报错
public class Student extends Person {
public static void test(){
System.out.println(“Student”);
}
}
3.代码块和静态代码块
【类中可以编写代码块和静态代码块】
public class Person {
{
//代码块(匿名代码块)
}
static{
//静态代码块
}
}
【匿名代码块和静态代码块的执行】
因为没有名字,在程序并不能主动调用这些代码块。
匿名代码块是在创建对象的时候自动执行的,**并且在构造器执行之前。**同时匿名代码块在每次创建对象的时候都会自动执行.
静态代码块是在类加载完成之后就自动执行,并且只执行一次。
注：:每个类在第一次被使用的时候就会被加载,并且一般只会加载一次.
public class Person {
{
System.out.println(“匿名代码块”);
}
static{
System.out.println(“静态代码块”);
}
public Person(){
System.out.println(“构造器”);
}
}
main:
Student s1 = new Student();
Student s2 = new Student();
Student s3 = new Student();
//输出
静态代码块
匿名代码块
构造器
匿名代码块
构造器
匿名代码块
构造器
【匿名代码块和静态代码块的作用】
匿名代码块的作用是给对象的成员变量初始化赋值,但是因为构造器也能完成这项工作,所以匿名代码块使用的并不多。
静态代码块的作用是给类中的静态成员变量初始化赋值。
例如：
public class Person {
public static String name;
static{
name = “tom”;
}
public Person(){
name = “zs”;
}
}
main:
System.out.println(Person.name);
//tom
注：在构造器中给静态变量赋值,并不能保证能赋值成功,因为构造器是在创建对象的时候才指向,但是静态变量可以不创建对象而直接使用类名来访问.
4.创建和初始化对象的过程
Student s = new Student();
【Student类之前没有进行类加载】
1.类加载,同时初始化类中静态的属性 。
2.执行静态代码块。
3.分配内存空间,同时初始化非静态的属性(赋默认值,0/false/null) 。
4.调用Student的父类构造器。
5.对Student中的属性进行显示赋值(如果有的话)。
6.执行匿名代码块。
7.执行构造器。
8.返回内存地址。
注：子类中非静态属性的显示赋值是在父类构造器执行完之后和子类中的匿名代码块执行之前的时候
public class Person{
private String name = “zs”;
public Person() {
System.out.println(“Person构造器”);
print();
}
public void print(){
System.out.println("Person print方法: name = "+name);
}
}
public class Student extends Person{
private String name = “tom”;
最后
毕竟工作也这么久了 ，除了途虎一轮，也七七八八面试了不少大厂，像阿里、饿了么、美团、滴滴这些面试过程就不一一写在这篇文章上了。我会整理一份详细的面试过程及大家想知道的一些问题细节
美团面试经验
字节面试经验
菜鸟面试经验
蚂蚁金服面试经验
唯品会面试经验
因篇幅有限，图文无法详细发出
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
一般只会加载一次.**
public class Person {
{
System.out.println(“匿名代码块”);
}
static{
System.out.println(“静态代码块”);
}
public Person(){
System.out.println(“构造器”);
}
}
main:
Student s1 = new Student();
Student s2 = new Student();
Student s3 = new Student();
//输出
静态代码块
匿名代码块
构造器
匿名代码块
构造器
匿名代码块
构造器
【匿名代码块和静态代码块的作用】
匿名代码块的作用是给对象的成员变量初始化赋值,但是因为构造器也能完成这项工作,所以匿名代码块使用的并不多。
静态代码块的作用是给类中的静态成员变量初始化赋值。
例如：
public class Person {
public static String name;
static{
name = “tom”;
}
public Person(){
name = “zs”;
}
}
main:
System.out.println(Person.name);
//tom
注：在构造器中给静态变量赋值,并不能保证能赋值成功,因为构造器是在创建对象的时候才指向,但是静态变量可以不创建对象而直接使用类名来访问.
4.创建和初始化对象的过程
Student s = new Student();
【Student类之前没有进行类加载】
1.类加载,同时初始化类中静态的属性 。
2.执行静态代码块。
3.分配内存空间,同时初始化非静态的属性(赋默认值,0/false/null) 。
4.调用Student的父类构造器。
5.对Student中的属性进行显示赋值(如果有的话)。
6.执行匿名代码块。
7.执行构造器。
8.返回内存地址。
注：子类中非静态属性的显示赋值是在父类构造器执行完之后和子类中的匿名代码块执行之前的时候
public class Person{
private String name = “zs”;
public Person() {
System.out.println(“Person构造器”);
print();
}
public void print(){
System.out.println("Person print方法: name = "+name);
}
}
public class Student extends Person{
private String name = “tom”;
最后
毕竟工作也这么久了 ，除了途虎一轮，也七七八八面试了不少大厂，像阿里、饿了么、美团、滴滴这些面试过程就不一一写在这篇文章上了。我会整理一份详细的面试过程及大家想知道的一些问题细节
美团面试经验
[外链图片转存中…(img-tpV220yH-1713540706108)]
字节面试经验
[外链图片转存中…(img-By5eW8r2-1713540706109)]
菜鸟面试经验
[外链图片转存中…(img-oRmhf1Qq-1713540706109)]
蚂蚁金服面试经验
[外链图片转存中…(img-yzlz5v8l-1713540706109)]
唯品会面试经验
[外链图片转存中…(img-B0mK4n2v-1713540706110)]
因篇幅有限，图文无法详细发出
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-TeYWbPEn-1713540706110)]
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
102
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
