先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024b （备注Java）
正文
配一把钥匙:引用
内存管理:由JVM来管理的
1)堆:存储new出来的对象(包括成员变量)
2)栈:存储局部变量(包括方法的参数)
3)方法区:存储.class字节码文件(包括方法)
练习：
给Hero、Airplane、BigAirplane、Bee、Bullet、Sky
分别添加构造方法
————————————————————————————
1.引用类型数组:
1)Student[] stus = new Student[3]; //创建Student数组对象
stus[0] = new Student(“zhangsan”,25,“LF”); //创建Student对象 并调用Student
stus[1] = new Student(“lisi”,26,“JMS”);
stus[2] = new Student(“wangwu”,28,“SD”);
System.out.println(stus[0].address);
2)Student[] stus = new Student[]{
new Student(“zhangsan”,25,“LF”),
new Student(“lisi”,26,“JMS”),
new Student(“wangwu”,28,“SD”)
};
3)int[][] arr = new int[3][];-----------数组的数组
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[2];
arr[1][0] = 100;
4)int[][] arr = new int[3][4];----------数组的数组
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
arr[i][j] = (int)(Math.random()*100);
}
}
例如：
int[][] arr= new int[3][];//[3]是数组长度，[]代表每一个数组中都长度
arr[0] = new int[2]; //第一个数组的长度为2
arr[1] = new int[3]; //第二个数组都长度为3
arr[2] = new int[4];
arr[1][2] = 100; // 给第2个数组中第3个元素赋值为100
System.out.println(arr[1][2]);//输出第二个数组中第三个
int[][] arr1 = new int[3][4]; //一共有3个组数，每个数组都长度为4
for(int i = 0;i<arr1.length;i++){ //遍历数组arr1中都元素[3]
for(int j = 0;j<arr1[i].length;j++){//遍历数组arr1中每一个数组的长度，arr1[i]
arr1[i][j] = 250; // 给每一个数组赋值为250
System.out.println(arr1[i][j]);
2.继承:
1)作用:代码复用
2)通过extends来实现继承
3)超类/父类:所有派生类所共有的属性和行为
派生类/子类:派生类所特有的属性的行为
4)派生类继承超类后，派生类具有:派生类的+超类的
5)一个超类可以有多个派生类
一个派生类只能有一个超类-------单一继承
6)继承具有传递性
7)java规定:构造派生类之前必须先构造超类
在派生类的构造方法中若没有调用超类的构造方法
------则默认super()调用超类的无参构造方法
在派生类的构造方法中若调用了超类的构造方法
------则不再默认提供
注意:super()调用超类构造必须位于派生类构造的第一行
3.super:指代当前对象的超类对象
super的用法:
1)super.成员变量名------------访问超类的成员变量
2)super.方法名()--------------调用超类的方法-------明天讲
3)super()---------------------调用超类的构造方法
例：
class Person { //class创建类。
//超类/父类
String name;
int age;
String address;
Person(String name, int age, String address) { //构造方法
this.name = name;
this.age = age;
this.address = address;}
void sayHi() { //方法
System.out.println(“你好，我叫” + name + “，今年” + age + “岁了，家住” + address);
}}
class Student extends Person {//派生类/子类 使用extends继承
String stuId;
Student(String name, int age, String address, String stuId) {
super(name, age, address); // super调用超类的值
this.stuId = stuId; // this. 给stuld赋值。 super的超类已经赋过，所以不需要再赋值
}}
练习：
1.创建Person类，包含:
1)成员变量:name,age,address
2)构造方法:Person(3个参数){}
3)方法:sayHi(){输出3个数据}
2.创建Student类，继承Person，包含:
1)成员变量:stuId
2)构造方法:Student(4个参数){}
3.创建Teacher类，继承Person，包含:
1)成员变量:salary
2)构造方法:Teacher(4个参数){}
4.创建Doctor类，继承Person，包含:
1)成员变量:level
2)构造方法:Doctor(4个参数){}
5.创建Test类，main中:
1)创建Student数组ss，填充数据，遍历问好
2)创建Teacher数组ts，填充数据，遍历问好
3)创建Doctor数组ds，填充数据，遍历问好
public class Test {
public static void main(String[] args) {
Person[] ps = new Person[3];
ps[0] = new Student(“张发阳”,22,“宝兴”, “1634”);
ps[1] = new Teacher(“张三”, 35, “浙江”, 4122);
ps[2] = new Doctor(“李四”, 46, “上海”, “aaa”);
for(int i=0;i<ps.length;i++){
ps[i].sayHi();
}
}
}
class Person {
String name;
int age;
String address;
Person(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
void sayHi() {
System.out.println(“你好，我叫” + name + “，今年” + age + “岁了，家住” + address);
}}
class Student extends Person {
String stuId;
Student(String name, int age, String address, String stuId) {
super(name, age, address);
this.stuId = stuId;
}void sayHi() {
System.out.println(“我职业是教师，名叫” + name + “，” + “今年” + age + “岁了，家住” + address + “，学号为：” + stuId);
}}
class Teacher extends Person {
double salary;//工资
Teacher(String name, int age, String address, double salary) {
super(name, age, address);
this.salary = salary;
}
void sayHi() {
System.out.println(“我职业是教师，名叫” + name + “，” + “今年” + age + “岁了，家住” + address + “，工资为：” + salary);
}}
class Doctor extends Person {
String level;
Doctor(String name, int age, String address, String level) {
super(name, age, address);
this.level = level;
}
void sayHi() {
System.out.println(“我职业是医生，名叫” + name + “，” + “今年” + age + “岁了，家住” + address + “，任职：” + level);
}
}
——————————————————————————————
2018/8/14
1.向上造型；
1）超类型的引用指向派生类的对象
2）能点出来什么，看引用的类型
例：
public static void main(String[] args) {
Aoo o1 = new Aoo();
o1.a = 1;
o1.show();
//o1.b = 2; //编译错误，超类不能访问派生类的
Boo o2 = new Boo();
o2.b = 1;
o2.test();
o2.a = 2; //正确，派生类可以访问超类的
o2.show();
Aoo o3 = new Boo(); //向上造型
o3.a = 1;
o3.show();
//o3.b = 2; //编译错误，能点出来什么，看引用的类型
}}
class Aoo{
int a;
void show() {}
}
class Boo extends Aoo{
int b;
void test() {}
}
2.方法的重写（Override）：重新写，覆盖
1）发生在父子类中，方法名称相同，参数列表相同，方法体不同
2）重写发放被调用时，看对象的类型
//超类大，派生类小
class Coo{
void show() {}
double test() {return 0.0;}
Doo say() {return null;}
Coo sayHi() {return null;}
}
class Doo extends Coo{
//int show() {return 1;} //编译错误，void时必须相等
//int test() {return 0;} //编译错误，基本类型时必须相等
//Coo say() {return null;} //编译错误，引用类型必须小于或等于
Doo sayHi() {return null;} //正确
}
3.重写与重载的区别：-----常见面试题
1）重写:
1.1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
1.2）遵循“运行期绑定”，看对象的类型来调用方法
class Eoo{
void show() { //方法
System.out.println(“超类show”);
}}
class Foo extends Eoo{
void show() { //方法重写
System.out.println(“派生类show”);
}}
2）重载：
2.1）发生在一个类中，方法名称相同，参数列表不同，方法体不同
2.2）遵循“编译期绑定"，看参数/引用的类型来绑定方法
class Aoo(){ //??方法重载
void say(int age){System.out.println(“你好，我今年”+age+“岁了”);}
void sa(String name){System.out.println(“你好，我叫”+name);}
void sa(String name,String address){“你好，我叫”+name+“，家住”+address);}
}
//重写的演示
public static void main(String[] args) {
Goo goo = new Goo();
Eoo o = new Foo();
goo.test(o); //重载看参数/引用Eoo
}
}
class Goo{
void test(Eoo o) {
System.out.println(“超类型参数”);
o.show(); //重写看对象Foo
}
void test(Foo o) {
System.out.println(“派生类型参数”);
o.show();
}}
class Eoo{
void show() { //方法
System.out.println(“超类show”);
}}
class Foo extends Eoo{
void show() { //方法重写
System.out.println(“派生类show”);
}}
练习：
/*1.创建Person类，包含：
1）成员变量：name，age，address；
2）构造方法：Person（3个参数){}
3)方法：sayHi｛输出3个数据｝
2.创建Student类，继承Person，包含：
1）成员变量：stuId
2）构造方法：Student（4个参数）｛｝
3）方法：重写sayHi（）｛输出4个数据｝
3.创建Teacher类，继承Person，包含：
1）成员变量：salary
2）构造方法：Teacher（4个参数）｛｝
3）方法：重写sayHi（）｛输出4个数据｝
4.创建Doctor类，继承Person，包含：
1）成员变量：lever
2）构造方法：Doctor（4个参数）｛｝
3）方法：重写sayHi（）｛输出4个数据｝
5.创建Test类，main中：
创建Person数组ps，填充数据，遍历问好*/
class Person{
String name;
int age;
String address;
Person(String name,int age,String address){
this.name = name;
this.age = age;
this.address = address;
}
void sayHi(){
System.out.println(“你好，我叫”+name+“，今年”+age+“岁了，家住”+address);
}
}
class Student extends Person{
int stuId;
Student(String name,int age,String address,int stuId){
super(name,age,address);
this.stuId = stuId;
}
void sayHi(){
System.out.println(“我的职业是学生，名为”+name+“，今年”+age+“岁了，家住”+address+“，学号是：”+stuId);
}
}
class Teacher extends Person{
double salary;
Teacher(String name,int age,String address,double salary){
super(name,age,address);
this.salary = salary;
}
void sayHi(){
System.out.println(“我的职业是老师，名为”+name+“，今年”+age+“岁了，家住”+address+“,工资为”+salary);
}
}
class Doctor extends Person{
String level;
Doctor(String name,int age,String address,String level){
super(name,age,address);
this.level = level;
}
void sayHi(){
System.out.println(“我的职业是医生，名为”+name+“，今年”+age+“岁了，家住”+address+“,任职：”+level);
}
}
public class Test {
public static void main(String[] args){
Person[] ps = new Person[4];
ps[0] = new Person(“张发阳”,20,“宝兴兴兴”);
ps[1] = new Student(“张发阳”,25,“宝兴”,1634);
ps[2] = new Doctor(“张发阳”,35,“宝兴兴”,“副院长”);
ps[3] = new Teacher(“张发阳”,45,“宝兴兴兴”,3000);
for(int i =0;i<ps.length;i++){
ps[i].sayHi();
}
}}
———————————————————————————————————
笔记:
1.package:
1)作用:避免类名的冲突
2)包名可以有层次结构
3)类的全称: 包名.类名，同包中的类不能同名
4)建议:包名所有字母都小写
package a;
class Aoo{ } //全称a.Aoo
package b;
class Aoo{ } //全称b.Aoo 不在一个包，所以不报错
class Aoo{ } //错误，一个包里不可以重复类名
import:
1)同包中的类可以直接访问，
不同包中的类不能直接访问，想访问有如下两种方式:
1.1)先import声明类再直接使用类------建议
import oo.day05.Aoo; //声明类
public class Coo {
void show() {
Aoo o = new Aoo();
o.a = 1;
}}
1.2)类的全称------------------------太繁琐、不建议
void show() {
oo.day05.Aoo o = new oo.day05.Aoo();
oo.day05.Aoo.a = 1;
2.访问控制修饰符:
1)public:公开的，任何类
2)private:私有的，本类
3)protected:受保护的，本类、派生类、同包类
4)默认的:什么也不写，本类、同包类
说明:
1)类的访问修饰符只能是public或默认的
2)类中成员的访问修饰符如上四种都可以
修饰符 本类 同一个包中的类 子类 其他类
public 可以访问 可以访问 可以访问 可以访问
private 可以访问 不能访问 不能访问 不能访问
protected 可以访问 可以访问 可以访问 不能访问
默认 可以访问 可以访问 可以访问 不能访问
例：
public int a; //任何类
protected int b; //本类、派生类、同包类
int c; //本类、同包类
private int d; //本类
void show() {
a = 1;
b = 2;
c = 3;
d = 4;
}}
//演示private
class Boo{
void show() {
Aoo o = new Aoo();
o.a = 1;
o.b = 2;
o.c = 3;
//o.d = 4;
}}
3.final:最终的、不可改变的----应用率低
1)修饰变量:变量不能被改变
//演示final修饰方法
//演示final修饰变量
class Eoo{
final int a = 5;
final int b;
Eoo(){
b = 6;
}
void show() {
final int c;
//a = 55; //编译错误，final的变量不能被改变
}}
2)修饰方法:方法不能被重写
class Foo{
final void show() {}
void test() {}
}
class Goo extends Foo{
//void show() {} //编译错误，final修饰的方法不能被重写
void test() {}
}
3)修饰类:类不能被继承
//演示final修饰类
final class Hoo{}
//class Ioo extends Hoo{} //编译错误，final修饰的类不能被继承
class Joo{}
final class Koo extends Joo{}
4.static:静态的
1)静态变量:
1.1)由static修饰
1.2)属于类的，存储在方法区中，只有一份
1.3)常常通过类名点来访问
1.4)何时用:所有对象所共享的数据(图片、音频、视频等)
2)静态方法:
2.1)由static修饰
2.2)属于类的，存储在方法区中，只有一份
2.3)常常通过类名点来访问
2.4)静态方法没有隐式this传递，
静态方法中不能直接访问实例成员
2.5)何时用:方法的操作仅与参数相关而与对象无关
3)静态块:
3.1)属于类的，在类被加载期间自动执行，
类只被加载一次，所以静态块只执行一次
3.2)何时用:用于加载/初始化静态资源(图片、音频、视频等)
//static的演示
public static void main(String[] args) {
Loo o1 = new Loo();
o1.show();
Loo o2 = new Loo();
o2.show();
System.out.println(Loo.b); //2，建议类名点来访问
Moo.test(); //类名点来访问
Noo o4 = new Noo();
Noo o5 = new Noo();
}}
//演示静态块
class Noo{
static {
System.out.println(“静态块”);
}
Noo(){
System.out.println(“构造方法”);
}}
//演示静态方法
class Moo{
int a;
static int b;
void show() { //有this
System.out.println(this.a);
System.out.println(Moo.b);
}
static void test() { //没有this
//静态方法没有隐式this传递
//没有this意味着没有对象
//而实例变量a必须通过对象点来访问
//结论:静态方法中不能直接访问实例成员
//System.out.println(a); //编译错误
System.out.println(Moo.b);
}}
//演示静态变量
class Loo{
int a;
static int b;
Loo(){
a++;
b++;
}
void show() {
System.out.println(“a=”+a+“,b=”+b);
}}
内存管理: （背）
1)堆:new出来的对象(包括实例变量)
2)栈:局部变量(包括方法的参数)
3)方法区:.class字节码文件(包括方法、静态变量)
例：成员变量:
1)实例变量:没有static修饰，属于对象的，存储在堆中，
有几个对象就有几份
通过对象名点来访问
2)静态变量:由static修饰，属于类的，存储在方法区中，
只有一份
通过类名点来访问
—————————————————————————————
笔记:
1.static final常量:
1)必须声明同时初始化
2)类名点来访问、不能被改变
3)建议:常量名所有字母都大写，多个单词之前用_分隔
4)编译器在编译时将常量直接替换为具体的值，效率高
5)何时用:数据永远不变，并且经常使用
2.抽象方法:
1)由abstract修饰
2)只有方法的定义，没有具体的实现(连{}都没有)
3.抽象类:
1)由abstract修饰
2)包含抽象方法的类必须是抽象类
不包含抽象方法的类也可以声明为抽象类------我乐意
3)抽象类不能被实例化 ，但数组可以
4)抽象类是需要被继承的，派生类:
4.1)重写抽象类中的所有抽象方法-----建议
4.2)也声明为抽象类-----------------一般不这样做
5)抽象类的意义:
5.1)封装共有的属性和行为--------------代码复用
5.2)为所有派生类提供统一的类型--------向上造型
5.3)可以包含抽象方法，为所有派生类提供统一的入口，
派生类的具体实现不同，但入口是一致的
设计规则:
1)将派生类共有的属性和行为，抽到超类中--------抽共性
2)派生类的行为都一样，设计为普通方法
派生类的行为都不一样，设计为抽象方法
————————————————————————————————
常见面试题：
问： 内部类有独立.class吗?
答： 有
例：Mama$(发音：多嘞儿)baby.class //Mama外部类，baby内部类
1.成员内部类：应用率不高
1）类中套类，外面的称为Outer外部类，里面的成为Inner内部类
Class Aoo{ //外部类
Class Boo{//内部类
｝｝
使用方法：
public static void main(String[] args) {
Demo14 a = new Demo14();
Foo f = a.new Foo();
f.Doo();
}
2)内部类通常只服务于外部类，对外不具备可见性
3)内部类对象通常是在外部类中创建的
4)内部类中可以直接访问外部类的成员(包括私有的)
内部类中有个隐式的引用指向了创建它的外部类对象
eg: 外部类名.this
2.匿名内部类:
1)若想创建一个类(派生类)的对象，并且对象只创建一个，
此时该类不必命名，称为匿名内部类
2)在jdk1.8以前，匿名内部类中若想访问外面的变量，
该变量必须是final的
功能实现过程:
1.先写行为/方法:
1)若为某个对象所特有的行为，就将方法设计在对应的类中
2)若为所有对象所共有的行为，就将方法设计在超类中
最后
Java架构学习技术内容包含有：Spring，Dubbo，MyBatis, RPC, 源码分析，高并发、高性能、分布式,性能优化，微服务 高级架构开发等等。
还有Java核心知识点+全套架构师学习资料和视频+一线大厂面试宝典+面试简历模板可以领取+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书+2021年最新大厂面试题。
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
———————————————————————————
常见面试题：
问： 内部类有独立.class吗?
答： 有
例：Mama$(发音：多嘞儿)baby.class //Mama外部类，baby内部类
1.成员内部类：应用率不高
1）类中套类，外面的称为Outer外部类，里面的成为Inner内部类
Class Aoo{ //外部类
Class Boo{//内部类
｝｝
使用方法：
public static void main(String[] args) {
Demo14 a = new Demo14();
Foo f = a.new Foo();
f.Doo();
}
2)内部类通常只服务于外部类，对外不具备可见性
3)内部类对象通常是在外部类中创建的
4)内部类中可以直接访问外部类的成员(包括私有的)
内部类中有个隐式的引用指向了创建它的外部类对象
eg: 外部类名.this
2.匿名内部类:
1)若想创建一个类(派生类)的对象，并且对象只创建一个，
此时该类不必命名，称为匿名内部类
2)在jdk1.8以前，匿名内部类中若想访问外面的变量，
该变量必须是final的
功能实现过程:
1.先写行为/方法:
1)若为某个对象所特有的行为，就将方法设计在对应的类中
2)若为所有对象所共有的行为，就将方法设计在超类中
最后
Java架构学习技术内容包含有：Spring，Dubbo，MyBatis, RPC, 源码分析，高并发、高性能、分布式,性能优化，微服务 高级架构开发等等。
还有Java核心知识点+全套架构师学习资料和视频+一线大厂面试宝典+面试简历模板可以领取+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书+2021年最新大厂面试题。
[外链图片转存中…(img-zyKqEhfk-1713554001901)]
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-W9ygUl15-1713554001902)]
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
1027
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
