先自我介绍一下,小编浙江大学毕业,去过华为、字节跳动等大厂,目前阿里P7
深知大多数程序员,想要提升技能,往往是自己摸索成长,但自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年最新Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新
如果你需要这些资料,可以添加V获取:vip1024b (备注Java)
正文
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)若为所有对象所共有的行为,就将方法设计在超类中
2.页面/窗口调用:
1)若为定时触发的,则在定时器中调用
2)若为事件触发的,则在侦听器中调用
程序的运行结果与你所预期的结果不同:
1)打桩: System.out.println(数据);
2)Debug调试:
————————————————————————————————
笔记:
1.接口:
1)是一种数据类型(引用类型)
2)由interface定义
3)只能包含常量和抽象方法
4)接口不能被实例化
5)接口是需要被实现/继承的,实现类/派生类:
必须重写所有抽象方法
6)一个类可以实现多个接口,用逗号分隔
若又继承又实现时,应先继承后实现
7)接口继承接口(可以继承多个接口)
设计规则:
1)将所有派生类所共有的属性和行为,抽到超类中-----抽共性
2)派生类的行为都一样,设计为普通方法
派生类的行为都不一样,设计为抽象方法
3)将部分派生类所共有的行为,抽到接口中
符合既是也是原则时,需使用接口
接口是对继承单根性的扩展----------实现多继承
————————————————————————————
笔记:
1.多态:
1)多态的意义: //抽象方法一定是多态
1.1)同一类型的引用指向不同的对象时,有不同的实现
----行为的多态:cut()、run()、step()…
1.2)同一个对象被造型为不同的类型时,有不同的功能
----对象的多态:我、你、水…
2)向上造型/自动类型转换:
2.1)超类型的引用指向派生类的对象
2.2)能造型成为的类型有: 超类+所实现的接口
2.3)能点出来什么,看引用的类型
3)强制类型转换,成功的条件只有如下两种:
3.1)引用所指向的对象,就是该类型
3.2)引用所指向的对象,实现了该接口或继承的该类
4)强转时若不符合如上条件,则发生ClassCastException类型转换异常,
建议在强转之前先通过instanceof(实例)来判断引用的对象是否是该类型
基本类型之间强制类型转换,
---------一定正确,但有可能溢出或丢失精度
引用类型之间强制类型转换,
---------有可能会失败报错
超类大,派生类小
自动:小类型到大类型
强制:大类型到小类型
—————————————————————————————————
正课:
1.内存管理:由JVM来管理的------了解
1)堆:
1.1)存储new出来的对象(包括实例变量)
1.2)垃圾:没有任何引用指向的对象
垃圾回收器(GC)不定时到内存中清扫垃圾,
回收过程是透明的(看不到的),
不一定一发现垃圾就立刻回收,
调用System.gc()可以建议JVM尽快调度GC来回收
1.3)内存泄漏:不再使用的对象还没有被及时的回收
建议:对象不再使用时应及时将引用设置为null
1.4)实例变量的生命周期:
创建对象时存储在堆中,对象被回收时一并被回收
2)栈:
2.1)存储正在调用的方法中的局部变量(包括方法参数)
2.2)调用方法时会为该方法在栈中分配一块对应的栈帧,
栈帧中存储局部变量(包括方法参数)
当方法调用结束时,栈帧被清除,局部变量一并失效
2.3)局部变量的生命周期:
调用方法时存储在栈中,方法结束时与栈帧一并被清除
3)方法区:
3.1)存储.class字节码文件(包括方法、静态变量)
3.2)方法只有一份,通过this来区分具体的调用对象
+++++++++++++++++++++++++++++++++++++
总结:
面向对象三大特征:
1.封装:
1)类:封装的是对象的属性和行为
2)方法:封装一段特定的是业务逻辑功能实现
3)访问控制修饰符:封装的是具体的访问权限
2.继承:
1)作用:代码复用
2)超类:所有派生类所共有的属性和行为
接口:部分派生类所共有的行为
派生类:派生类所特有的属性和行为
3)单一继承、多接口实现,传递性
3.多态:
1)意义:
1.1)行为的多态(所有抽象方法都是多态的)
1.2)对象的多态(所有对象都是多态的)
2)向上造型、强制类型转换、instanceof判断
3)多态的表现形式:
3.1)重写:根据对象的不同来表现多态
3.2)重载:根据参数的不同来表现多态
设计游戏思路(面向对象课程安排):
Shoot射击游戏第一天:
1.创建了6个对象类,创建World类测试
(理论:
1.什么是类?什么是对象?
2.如何创建类?如何创建对象?如何访问成员?
项目:
3.创建了6个对象类,并创建World类测试)
Shoot射击游戏第二天:
1.给6个对象类添加构造方法,并测试
(理论:
1.方法的重载
2.构造方法
3.this
5.null和NullPointerException
6.引用类型之间画等号
项目:
4.给6个对象类添加构造方法,并测试)
Shoot射击游戏第三天:
1.设计小敌机数组、大敌机数组、小蜜蜂数组、子弹数组,并测试
2.设计超类FlyingObject,6个对象类继承
3.给FlyingObject类设计两个构造方法,6个对象类分别调用
( 理论:
1.引用类型数组
3.继承
5.super
项目:
2.设计小敌机数组、大敌机数组、小蜜蜂数组、子弹数组,并测试
4.设计FlyingObject超类,6个对象类继承
6.给FlyingObject超类设计两个构造方法,6个对象类分别调用)
Shoot射击游戏第四天:
1.将小敌机数组、大敌机数组、小蜜蜂数组合为FlyingObject数组,并测试
2.在6个对象中重写step()
3.画窗口
(理论:
1.向上造型
3.方法的重写
4.重写与重载的区别
项目:
2.将小敌机数组、大敌机数组、小蜜蜂数组合为FlyingObject数组,并测试
5.在6个派生类中重写超类的step()方法
6.画窗口)
Shoot射击游戏第五天:
1.给类中成员添加访问控制修饰符
2.给6个对象设计图片属性
(理论:
1.package和import
2.访问控制修饰符
4.final
5.static
项目:
3.给类中成员添加访问控制修饰符
6.给6个对象设计图片属性)
Shoot射击游戏第六天:
1.设计窗口的宽和高为常量,适当地方做修改
2.画对象:
1)想画对象得获取对象的图片,每个对象都能获取图片,
意味着获取图片行为为共有行为,设计为超类FlyingObject中,
每个对象获取图片的行为都是不一样的,所以设计为抽象方法
----在FlyingObject中设计抽象方法getImage()来获取对象的图片
2)对象在获取图片时需要考虑对象在不同状态下获取不同的图片,
所以要给对象设计状态,每个对象都有状态,
所以将状态设计在超类中,而状态一般都是常量
----在FlyingObject中设计三个常量,state变量表示当前状态
在获取图片时需要先对对象的状态进行判断,
每个对象都得判断,所以将判断状态行为设计在超类中,
每个对象判断状态的方式都是一样的,所以设计为普通方法
----在FlyingObject中设计isLife()、isDead()、isRemove()来判断对象的状态
3)----重写FlyingObject中的抽象方法getImage():
3.1)天空Sky,直接返回image即可
3.2)子弹Bullet:
3.2.1)若活着的,直接返回image即可
3.2.2)若死了的,则删除
3.3)英雄机Hero:
3.3.3)若活着的,返回images[0]和images[1]的来回切换
3.4)小敌机Airplane:
3.4.1)若活着的,直接返回images[0]
3.4.1)若死了的,返回images[1]到images[4]的轮转,4后则删除
3.5)大敌机Airplane:
3.5.1)若活着的,直接返回images[0]
3.5.1)若死了的,返回images[1]到images[4]的轮转,4后则删除
3.6)小蜜蜂Airplane:
3.6.1)若活着的,直接返回images[0]
3.6.1)若死了的,返回images[1]到images[4]的轮转,4后则删除
4)图片有了则可以开画了,每个对象都能画,
意味着画为共有的行为,所以设计在超类中,
每个对象画的方式都是一样的,所以设计为普通方法
----在FlyingObject中设计paintObject()实现画对象
5)天空Sky每次需要画两张图,所以重写超类的paintObject()
----在Sky中重写paintObject()
6)在World类中调用paintObject()实现往窗口上画对象
----在World中重写paint()方法
(理论:
1.static final常量
3.抽象方法
4.抽象类
项目:
2.设计窗口的宽和高为常量,适当地方做修改
5.画对象)
Shoot射击游戏第七天:
1.敌人入场:
1)敌人是由窗口产生的,所以在World中创建nextOne()生成敌人对象
2)敌人入场为定时发生的,在run()中调用enterAction()实现敌人入场
在enterAction()中:
每400毫秒,获取敌人对象,扩容并装到最后一个元素上
2.子弹入场:
1)子弹是由英雄机发射出来的,所以在Hero中创建shoot()生成子弹对象
2)子弹入场为定时发生的,在run()中调用shootAction()实现子弹入场
在shootAction()中:
每300毫秒,获取子弹对象,扩容并数组追加
3.飞行物移动:
1)飞行物移动为所有对象所共有的行为,所以在超类中设计抽象方法step()
派生类中重写step()
2)飞行物移动为定时发生的,在run()中调用stepAction()实现飞行物移动
在stepAction()中:
天空动,遍历敌人敌人动,遍历子弹子弹动
(理论:
1.成员内部类
2.匿名内部类
项目:
3.敌人入场
4.子弹入场
5.飞行物移动)
最后
小编在这里分享些我自己平时的学习资料,由于篇幅限制,pdf文档的详解资料太全面,细节内容实在太多啦,所以只把部分知识点截图出来粗略的介绍,每个小节点里面都有更细化的内容!
程序员代码面试指南 IT名企算法与数据结构题目最优解
这是” 本程序员面试宝典!书中对IT名企代码面试各类题目的最优解进行了总结,并提供了相关代码实现。针对当前程序员面试缺乏权威题目汇总这一-痛点, 本书选取将近200道真实出现过的经典代码面试题,帮助广“大程序员的面试准备做到万无一失。 “刷”完本书后,你就是“题王”!
《TCP-IP协议组(第4版)》
本书是介绍TCP/IP协议族的经典图书的最新版本。本书自第1版出版以来,就广受读者欢迎。
本书最新版进行」护元,以体境计算机网络技不的最新发展,全书古有七大部分共30草和7个附录:第一部分介绍一些基本概念和基础底层技术:第二部分介绍网络层协议:第三部分介绍运输层协议;第四部分介绍应用层协议:第五部分介绍下一代协议,即IPv6协议:第六部分介绍网络安全问题:第七部分给出了7个附录。
Java开发手册(嵩山版)
这个不用多说了,阿里的开发手册,每次更新我都会看,这是8月初最新更新的**(嵩山版)**
MySQL 8从入门到精通
本书主要内容包括MySQL的安装与配置、数据库的创建、数据表的创建、数据类型和运算符、MySQL 函数、查询数据、数据表的操作(插入、更新与删除数据)、索引、存储过程和函数、视图、触发器、用户管理、数据备份与还原、MySQL 日志、性能优化、MySQL Repl ication、MySQL Workbench、 MySQL Utilities、 MySQL Proxy、PHP操作MySQL数据库和PDO数据库抽象类库等。最后通过3个综合案例的数据库设计,进步讲述 MySQL在实际工作中的应用。
Spring5高级编程(第5版)
本书涵盖Spring 5的所有内容,如果想要充分利用这一领先的企业级 Java应用程序开发框架的强大功能,本书是最全面的Spring参考和实用指南。
本书第5版涵盖核心的Spring及其与其他领先的Java技术(比如Hibemate JPA 2.Tls、Thymeleaf和WebSocket)的集成。本书的重点是介绍如何使用Java配置类、lambda 表达式、Spring Boot以及反应式编程。同时,将与企业级应用程序开发人员分享一些见解和实际经验,包括远程处理、事务、Web 和表示层,等等。
JAVA核心知识点+1000道 互联网Java工程师面试题
企业IT架构转型之道 阿里巴巴中台战略思想与架构实战
本书讲述了阿里巴巴的技术发展史,同时也是-部互联网技 术架构的实践与发展史。
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
需要这份系统化的资料的朋友,可以添加V获取:vip1024b (备注Java)
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
最新更新的**(嵩山版)**
[外链图片转存中…(img-vrPjLS6Q-1713554026873)]
MySQL 8从入门到精通
本书主要内容包括MySQL的安装与配置、数据库的创建、数据表的创建、数据类型和运算符、MySQL 函数、查询数据、数据表的操作(插入、更新与删除数据)、索引、存储过程和函数、视图、触发器、用户管理、数据备份与还原、MySQL 日志、性能优化、MySQL Repl ication、MySQL Workbench、 MySQL Utilities、 MySQL Proxy、PHP操作MySQL数据库和PDO数据库抽象类库等。最后通过3个综合案例的数据库设计,进步讲述 MySQL在实际工作中的应用。
[外链图片转存中…(img-6JGSy2sG-1713554026873)]
Spring5高级编程(第5版)
本书涵盖Spring 5的所有内容,如果想要充分利用这一领先的企业级 Java应用程序开发框架的强大功能,本书是最全面的Spring参考和实用指南。
本书第5版涵盖核心的Spring及其与其他领先的Java技术(比如Hibemate JPA 2.Tls、Thymeleaf和WebSocket)的集成。本书的重点是介绍如何使用Java配置类、lambda 表达式、Spring Boot以及反应式编程。同时,将与企业级应用程序开发人员分享一些见解和实际经验,包括远程处理、事务、Web 和表示层,等等。
[外链图片转存中…(img-f2uhh7M7-1713554026873)]
JAVA核心知识点+1000道 互联网Java工程师面试题
[外链图片转存中…(img-CoxZoG1G-1713554026873)]
[外链图片转存中…(img-OEfRH8hA-1713554026874)]
企业IT架构转型之道 阿里巴巴中台战略思想与架构实战
本书讲述了阿里巴巴的技术发展史,同时也是-部互联网技 术架构的实践与发展史。
[外链图片转存中…(img-U48tLATU-1713554026874)]
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
需要这份系统化的资料的朋友,可以添加V获取:vip1024b (备注Java)
[外链图片转存中…(img-F48Zv4jA-1713554026874)]
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!