先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024b （备注Java）
正文
float f = 0.993434;(错误) 必须加入F|f
- short a=12; a++;(正确) a=a+3;(错误) 解释:算数运行会自动类型提升 自增自减运算不会自动类型提升
6.自动类型提升？
byte -> short -> int -> long -> float -> double
- 当两个操作数有一个为double时，运算结果为 double
没有double，出现float， 结果为float
没有float，出现long， 结果为long
没有long，出现int， 结果为int
除long类型外， 其余整数类型运算结果均为int类型
7.&&与 & 、|| 和 |有什么区别?
&&（与）、||(或)、!(非) ====> 逻辑运算
-
与: 两边同时为true 结果才是true
-
或: 两边只要有一个结果为true 结果就是true
-
非: 非真即假
&、|、~ 、^ =============> 位运算
int a = 1
0000 0000 0000 0000 0000 0000 0000 0001
int b = 2
0000 0000 0000 0000 0000 0000 0000 0010
1&2 = 0
1|2 = 3
~2 = -3
1^2 = 3
-
&(与): 从最高位运算，运算符两个位都为1，结果才为1，否则结果为0
-
|(或): 运算符两个位只要有一个为1，那么结果就是1，否则就为0
-
“~”(非): 表示位为0，结果是1，如果位为1，结果是0
-
“^”(异或): 表示的两个的位，相同则结果为0，不同则结果为1
8.冒泡排序 选择排序
1 3 2 6 7 4 5 9 必须背下来
冒泡排序思路: 两个相邻的元素比较,并且交换位置
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a.length-1; j++) {
if(a[j]>a[j+1]){
int tmp = a[j];
a[j] = a[j+1];
a[j+1] =tmp;
}
}
}
选择排序思路: 指定下标与所有数字比较
for (int i = 1; i < a.length; i++) {
for (int j = i; j < a.length; j++) {
if(a[i-1] > a[j]){
int tmp = a[i-1];
a[i-1] = a[j];
a[j] = tmp;
}
}
}
9.数组扩容的思想？
1.创建更大数组进行搬家 int[] a = {12,23,23,345}; int[] b = new int[a.lenght*2]
2.java.util.Arrays.copyOf(原数组名，新数组长度);
3.System.arraycopy(原数组名，起始下标，新数组名，起始下标，复制长度);
10.面向对象的三大特性
1.封装 继承 多态
-
封装: 提高类和系统安装性 体现: 属性私有 提供公开的GET和SET方法
-
继承: 建立类的层次和等级方便扩展 体现: 子类继承父类 单继承一个子类只允许存在一个父类
-
多态: 父类引用指向子类对象 体现: 父类引用调用父类中方法 实际执行时执行的是子类覆盖之后方法
11.什么多态
多态: 父类引用指向子类对象
class Animal{
public void eat(){… Animal eat}
}
class Dog extends Animal{
public void eat(){… Dog eat}
public void play(){…}
}
class Cat extends Animal{
public void eat(){… Cat eat}
public void runing(){…}
}
Animal a = new Dog();
a.eat(); //Dog eat
Animal b = new Cat();
b.eat(); //cat eat
引用调用引用类中声明方法 在实际执行时执行子类覆盖之后方法
12.关于构造方法?
构造方法
作用: 用来创建对象
特点:
1.构造方法没有返回值
2.方法名必须和类名一致
3.不允许手动调用,在创建对象时自动调用 new Student();
4.当在类中没定义任何构造方法时，系统会默认分配一个 公共无参的 构造方法 注意:一旦类中显示定义构造方法 默认的构造方法则不存在
13.this、super关键字
this: 当前引用 指的:我
-
this.属性名 this.方法名: 用于在构造方法或普通方法中，调用当前对象的属性或方法
-
this(): 只能用在构造方法中,只能出现在构造方法第一行 代表调用本类中构造方法
super: 父类引用 指的父类对象
-
super.属性 super.方法 : 用在子类的构造方法或普通方法中，调用父类的属性或方法
-
super() : 只能用在构造方法中,只能出现在构造方法第一行 代表调用父类中构造方法 注意:this() super()不能同时出现
14.继承时对象的创建过程？
对象创建过程
-
分配空间
-
初始化属性默认值
-
调用构造方法
继承时对象的创建过程
-
分配空间 (父子类空间一起分配)
-
初始化父类属性
-
调用父类构造方法(创建父类对象)
-
初始化子类属性
-
调用子类构造方法(创建子类对象)
15.java中继承关系
java中类单继承
- 一个类只能存在一个父类 但是可以实现多个接口
java中接口多继承
- 一个接口可以继承多个接口
为什么接口可以多继承
- 因为接口定义的都是抽象的方法，而且不能在接口中实现方法。所以，接口继承多个接口，并不会使接口的结构变得很复杂。
类 extends 父类 implemplents interface,interface1
为什么JAVA只能单继承？
- 因为在C++中一个类是可以继承自多个类,但这样的机制会使类的结构变的很复杂,所以JAVA将C++这一机制通过接口得以改善。
JAVA中不允许类多重继承,只能单一继承,但有些情况单一继承并不能表达出现实世界中的某些逻辑关系,所以就提出了通过接口来实现多重继承。
16.overload(重载)、override(覆盖)?
overload: 方法重载
- 方法名相同参数列表不同(参数个数,类型,顺序) 和 返回值无关
override: 方法覆盖 方法重写
- 方法名相同 参数列表相同 返回值相同 访问权限修饰相同或更宽 抛出异常相同或更少
18.instanceof关键字作用? transient关键字作用？
instanceof
- 用来判断引用实际类型是什么 用法: a instanceof Dog 返回值: 类型一致 true 不一致 false
if(a instanceof Dog){
}
Animal a = new Dog(); a intanceof Dog
Animal b = new Cat();
transient
- 用来作用于成员变量属性上,代表这个属性在对象序列化时不参与对象序列化
19.三大修饰符
static: 静态的
-
类 : 静态类
-
属性 : 静态属性 全类共享 可以直接使用类名.属性名 直接使用
-
方法 : 静态方法: 全类共享 可以直接使用类型.方法名 直接调用
-
代码块: 静态代码: 静态在类加载时候执行, 只执行一次
final: 最终的
-
类: 最终类: (断子绝孙) 该类不能被继承
-
属性: 最终的属性: 属性一旦被赋值不能被修改
-
方法: 最终方法: 可以被继承,不能被覆盖
try{}catch(Exception e){}finally{} //总是被执行
finallize() //在jvm垃圾回收自动调用
abstract: 抽象的
-
类: 抽象类: 不能通过new关键创建对象
-
方法: 抽象方法: 只有声明没有实现
注意:
1.抽象类中一定含有抽象方法 不对
2.存在抽象方法类一定时抽象类 对
3.抽象类中存在构造方法 对
4.抽象类中因为不能通过new创建对象,因此类中没有构造方法 不对
5.抽象类中构造方法用来干什么? 用来为子类继承时创建子类对象用的
6.String 类能不能被继承? 不能被继承 final 关键字
为什么使用final关键字修饰?
字符串类中所有方法都是线程安全的方法,如果允许继承,可能会破坏string
中线程安全
#面试
-
1.存在抽象方法类一定是抽象类 对 -
2.抽象类一定存在抽象方法 不对 -
3.被static修饰方法方法内只能使用外部静态成员 对 -
4.普通方法可以直接使用static修饰方法 对 -
5.static修饰方法可以直接使用外部普通方法 不对 -
6.jdk中String类可以被继承? 不能 为什么String要设计成final的 String 不可变字符串 String name="小陈" name+"xiaohei"; -
7.抽象类中没有构造方法? 存在,子类继承父类时 创建父类对象使用
20.静态代码块，动态代码块，构造方法的执行顺序
public class Student extends People{
//静态代码块: 类加载时候执行 只执行一次 类加载: jvm第一次使用到这个.class文件进行类加载 classLoader ===> jvm
static{
System.out.println(“1”);
}
//对象: 初始化属性 调用构造方法
//动态代码块: 作用:用来给类中属性 赋值的
{
System.out.println(“2”);
}
//构造方法: 创建对象的时候自动执行
public Student() {
System.out.println(“3”);
}
public static void main(String[] args) {
Student student = new Student();//5 1 6 4 2 3
}
}
class People{
static {
System.out.println(“5”);
}
{
System.out.println(“6”);
}
public People() {
System.out.println(“4”);
}
}
21.下面代码的执行顺序
public class Test{
private String name;
static{
System.out.println(“1”);
}
{
name = “小陈”;
System.out.println(“2”);
}
public Test() {
System.out.println(“3”);
}
public static void main(String[] args) {
new Test();
}
}
解释:
-
1.当jvm第一次读取类信息时会执行类加载,static代码块是在类加载时候执行,因此最先执行输出1
-
2.{}代码块: 初始化代码块,在创建对象时为属性进行初始化执行,因此创建对象之前要先经历属性初始化才创建对象因此输出2
-
3.构造方法: 在创建对象时自动调用,最后输出3
22.什么是类加载?
类加载
- 类加载，在JVM第1次使用某个类时，先在classpath下 找到对应的.class文件，读取 该.class文件中的内容(包/名/属性/方法…)到内存中 并且保存(类对象)起来的过程。 类加载只进行1次
23.简述 final finalized finally 的区别?
final 最终的
-
类: 修饰不能被继承
-
属性: 最终属性 一旦被赋值不能被修改
-
方法:最终方法 可以被继承不能覆盖
-
String类能不能被继承? 不能 原因是:被final关键字修饰的
-
String:为什么要设计成final? String不希望有子类,子类会破坏父类中方法规则 原因:字符串类中所有方法都是线程安全的,如果存在子类破坏父类中方法线程安全
finalized 垃圾回收时jvm自动执行的方法
finally 最终的 一般 try catch 进行连用 try{}finally{}
- finally 代码中的内容: 无论什么情况总是执行
24.接口和抽象类区别
interface 接口
-
1.接口之前可以多继承 interface A extends B,C… 2.类 implements A,B,…
-
2.接口中定义变量都是静态常量 接口中变量都是被 public static final String NAME = “xiaochen”; 修饰的 静态常量
-
3.接口中方法公开抽象方法 只有声明没有实现 (jdk8) (jdk8)以后,接口中方法可以存在默认实现
抽象类 abstract
-
1.类中含有构造方法
-
2.抽象类只能单继承
-
3.抽象类存在普通方法
-
4.抽象类中存在抽象方法 只有声明 没有实现的
25.”==”与equals有何区别？
==
- 比较地址内存地址
user1 == user2
equals
- 比较内容是否一致
user1.equals(user2); //比较对象:必须覆盖euqals 和 hashCode方法
26.StringBuilder与Stringbuffer的区别？
StringBuilder 、 StringBuffer
-
共同点: 都是用来进行字符串拼接的
-
不同点:
1.StringBuilder 线程不安全 效率高
2.StringBuffer 线程安全 效率低
27.简述ArrayList、LinkedList、Vector三者的区别?
ArrayList LinkedList Vector 都是List接口实现类 都是集合
-
ArrayList: 底层实现: 数组 特点:一段连续内存空间 根据下标快速查询 查询快(O(1)) 增删慢 O(n) 线程不安全
-
LinkedList: 底层实现: 链表 特点:指针概念将节点连接在一起 增删快(O(1)) 查询慢(O(n))
-
Vector: 底层实现: 数组 特点: 一段连续内存空间 根据下标快速查询 查询快(O(1)) 增删慢 O(n) 线程安全
28.HashMap和HashTable的区别？
hashmap
- 线程不安全的 允许key value 同时为null
hashtable
- 线程安全的 不允许key value 同时为null
ConcurrentHashMap(并发hashmap) 线程安全 效率 hashtable
- 线程安全的 效率远高于hashtable
Hashtable和ConcurrentHashMap有什么分别呢？它们都可以用于多线程的环境，
但是当Hashtable的大小增加到一定的时候，性能会急剧下降，因为迭代时需要被锁定很长的时间。数组+链表
因为ConcurrentHashMap引入了分割(segmentation)，不论它变得多么大，仅仅需要锁定map的某个部分，对表进行分段加锁16段
而其它的线程不需要等到迭代完成才能访问map。简而言之，在迭代的过程中，ConcurrentHashMap仅仅锁定map的某个部分，而Hashtable则会锁定整个map。
29.HashSet如何实现元素不重复?
自定义类型
- 需要在类中覆盖hashcode和equals方法
非自定义类型
- 内部底层自动覆盖hashcode 和 equals
30.简述流的分类？
方向
-
输入流: 将数据读入jvm中
-
输出流: 将jvm中数据写出
功能
-
节点流 : 实际负责传输数据的流
-
过滤流 : 增强节点流功能（处理流、装饰类），依赖节点流
单位
-
字节流: 读取一切数据
-
字符流: 读取文本类型的数据
InputStream is = new FileInputStream(“”)
OutputStream os = new FileOutputStream(“”)
文件拷贝代码
1.定义输入流 定义输出流
InputStream is = new FileInputStream(new File(“d://aa.txt”)); 900byte
OutputStream os = new FileOutputStream(new File(“e://bb.txt”));
2.文件拷贝
byte[] b = new byte[1024]; //1KB
int len = 0;
while(true){
len = is.read(b);
if(len=-1)break;
os.write(b,0,len);
}
//2.IOUtils.copy(is,os); //引入commons-io工具包
3.释放资源
is.close();
os.close();
31.什么是线程？
线程
-
进程: 一个进程中可以化分为多个线程 线程是程序调度基本单位
-
多线程: 可以提高程序运行效率
new Thread(()=>{
}).start();
java中实现多线程方式: 1.继承Thread类 2.实现runable接口 3.线程池 4.线程辅助类 FeatureTask Callable
线程状态 5种状态(操作系统角度)
-
NEW 新建状态
-
RUNNABLE start方法之后进入 可运行状态
-
RUNNING 获取cpu时间片 运行状态
-
BLOCKED Thread.sleep(1000); IO … 阻塞状态
-
DEAD 死亡状态
32.什么是线程安全？
线程安全
- 如果你的代码所在的进程中有多个线程在同时运行，
而这些线程可能会同时运行这段代码。
如果每次运行结果和单线程运行的结果是一样的，
而且其他的变量的值也和预期的是一样的，就是线程安全的。
一个线程安全的计数器类的
同一个实例对象在被多个线程使用的情况下也不会出现计算失误。
33.线程安全案例
- 类对象唯一，可以使用类对象加锁
类对象在jvm就一个，唯一
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gtCivnQq-1640409536714)(image/image.png)]
- 对象锁
public class TestThread {
private static int count = 0;
private static Object o = new Object();
//synchronized (对象) 对象锁
public static synchronized void main(String[] args) throws InterruptedException {
synchronized(TestThread.class){
// getstatic +1 value putstatic t1
Thread t1 = new Thread(() -> {
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o){
for (int i = 0; i < 10000; i++) {
count++;
}
}
});
Thread t2 = new Thread(() -> { //t2
synchronized (o) {
for (int i = 0; i < 10000; i++) {
count–;
}
}
});
t1.start();
t2.start();
t1.join();//阻塞main等待线程执行完成
t2.join();//阻塞main等待线程执行完成
System.out.println(count);
}
}
34.实现多线程方式
1.继承Thread类
Thread1 extends Thread {
public void run(){
// 线程的功能代码
}
}
//使用：a. 创建线程对象
Thread1 t1 = new Thread1();
//b. 启动线程
t1.start(); // 启动线程，JVM自动调用run方法
// t1.run(); //error. 相当于调用了一个对象中的方法
2.实现Runable接口
Thread2 implements Runnable{
//实现run方法
@Override
public void run(){
//线程的代码功能
}
}
//使用
Thread thread = new Thread(new Thread2());
thread.start();
3.实现 Callable 接口
Thread1 implements Callable {
public void run(){
// 线程的功能代码
}
}
//使用：a. 创建线程对象
Thread1 t1 = new Thread1();
//b. 启动线程
t1.start(); // 启动线程，JVM自动调用run方法
// t1.run(); //error. 相当于调用了一个对象中的方法
4.使用FeaturTask
- 获取线程执行任务结果
//线程任务对象
FutureTask futureTask = new FutureTask<>(new Callable() {
@Override
public Integer call() throws Exception {
System.out.println(Thread.currentThread().getName()+ “-----------”);
return 10;
}
});
new Thread(futureTask).start();
System.out.println(futureTask.get());
35.sleep() 和 wait() 有什么区别
共同点: 都是让线程进入等待状态 sleep 有限期等待 wait 无限期等待
sleep() 线程对象中方法
- 线程进入等待之后,不会释放对象锁,等待结束之后恢复线程继续执行
wait() Object类中方法
- 线程进入等待之后,释放掉当前对象锁,只有接收notify() 或者notfiyall() 之后才能恢复运行,恢复运行时重新进入等待队列获取锁表标记
36.通过反射获取类对象的3种方式
反射获取对象
- 1)通过类名.class 获取 Class对象
Class s = Student.class;
- 2)创建对象，通过对象 . getClass() 获取Class对象
Strudet student = new Student();
Class s = student.getClass();
- 3)通过 Class.forName(“包名.类名”); 获取Class对象
Class s = Class.forName(“java.util.HashSet”);
37.单例设计模式
//只能创建一个对象
懒汉式
class User{
private static User user;
private User(){}
public synchronized static User getInstance(){ //存在线程安全问题:必须加入线程锁
if(user == null){
user = new User();
}
return user;
}
}
恶汉式
class User{
private static final User user = new User();
private User(){}
public static User getInstance(){
return user;
}
}
38.单例模式案例
public class TestSingleton {
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(()->{
System.out.println(Dept.getInstance());
}).start();
}
//懒汉式: 每次使用使用创建 存在线程安全的问题
class Dept{
private static Dept dept;
private Dept(){}
//t1 bb t2 aa
public synchronized static Dept getInstance(){
if(dept==null){
dept = new Dept();
}
return dept;
}
}
//饿汉式 : 不管用还是不用 直接创建一个实例 不存在线程安全问题
class Emp{
private static final Emp emp = new Emp();
private Emp(){}//构造方法私有
//返回一个对象
public static Emp getInstance(){
return emp;
}
}
39.Oracle 中主键的自动生成策略是什么？如何创建？
sequence 序列 oracle中主键生成策略
-
创建 create sequence seq_user start with 1 increment by 2 maxvalue 100 minvalue 1;
-
使用 sequence
序列名.nextval 使用下一个序列值 insert into t_user values(seq_user.nextval
序列名 .currval //获取当前序列的数值 前提序列必须先执行过一次
select 序列名.currval from dual;
注意：序列一旦被创建可以在任意表中使用，值一旦产生不能重复获取。
mysql主键策略 自动生成 auto_increment mysql自动生成
create table t_user(
id int(4) primary key auto_incrment,
name
)
insert into t_user(‘name’) values(‘xiaochen’)
40.select语句执行顺序
最后的内容
在开头跟大家分享的时候我就说，面试我是没有做好准备的，全靠平时的积累，确实有点临时抱佛脚了，以至于我自己还是挺懊恼的。（准备好了或许可以拿个40k，没做准备只有30k+，你们懂那种感觉吗）
如何准备面试？
1、前期铺垫（技术沉积）
程序员面试其实是对于技术的一次摸底考试，你的技术牛逼，那你就是大爷。大厂对于技术的要求主要体现在：基础，原理，深入研究源码，广度，实战五个方面，也只有将原理理论结合实战才能把技术点吃透。
下面是我会看的一些资料笔记，希望能帮助大家由浅入深，由点到面的学习Java，应对大厂面试官的灵魂追问
这部分内容过多，小编只贴出部分内容展示给大家了，见谅见谅！
- Java程序员必看《Java开发核心笔记（华山版）》
- Redis学习笔记
- Java并发编程学习笔记
四部分，详细拆分并发编程——并发编程+模式篇+应用篇+原理篇
- Java程序员必看书籍《深入理解 ava虚拟机第3版》（pdf版）
- 大厂面试必问——数据结构与算法汇集笔记
其他像Spring，SpringBoot，SpringCloud，SpringCloudAlibaba，Dubbo，Zookeeper，Kafka，RocketMQ，RabbitMQ，Netty，MySQL，Docker，K8s等等我都整理好，这里就不一一展示了。
2、狂刷面试题
技术主要是体现在平时的积累实用，面试前准备两个月的时间再好好复习一遍，紧接着就可以刷面试题了，下面这些面试题都是小编精心整理的，贴给大家看看。
①大厂高频45道笔试题（智商题）
②BAT大厂面试总结（部分内容截图）
③面试总结
3、结合实际，修改简历
程序员的简历一定要多下一些功夫，尤其是对一些字眼要再三斟酌，如“精通、熟悉、了解”这三者的区别一定要区分清楚，否则就是在给自己挖坑了。当然不会包装，我可以将我的简历给你参考参考，如果还不够，那下面这些简历模板任你挑选：
以上分享，希望大家可以在金三银四跳槽季找到一份好工作，但千万也记住，技术一定是平时工作种累计或者自学（或报班跟着老师学）通过实战累计的，千万不要临时抱佛脚。
另外，面试中遇到不会的问题不妨尝试讲讲自己的思路，因为有些问题不是考察我们的编程能力，而是逻辑思维表达能力；最后平时要进行自我分析与评价，做好职业规划，不断摸索，提高自己的编程能力和抽象思维能力。
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
大家由浅入深，由点到面的学习Java，应对大厂面试官的灵魂追问
这部分内容过多，小编只贴出部分内容展示给大家了，见谅见谅！
- Java程序员必看《Java开发核心笔记（华山版）》
[外链图片转存中…(img-j0hqGKEa-1713023667258)]
- Redis学习笔记
[外链图片转存中…(img-wdnDy0v3-1713023667259)]
- Java并发编程学习笔记
四部分，详细拆分并发编程——并发编程+模式篇+应用篇+原理篇
[外链图片转存中…(img-hba7TBIz-1713023667259)]
- Java程序员必看书籍《深入理解 ava虚拟机第3版》（pdf版）
[外链图片转存中…(img-qFhKJok6-1713023667259)]
- 大厂面试必问——数据结构与算法汇集笔记
[外链图片转存中…(img-SEYYhlWX-1713023667260)]
其他像Spring，SpringBoot，SpringCloud，SpringCloudAlibaba，Dubbo，Zookeeper，Kafka，RocketMQ，RabbitMQ，Netty，MySQL，Docker，K8s等等我都整理好，这里就不一一展示了。
[外链图片转存中…(img-vkCFOLYp-1713023667260)]
2、狂刷面试题
技术主要是体现在平时的积累实用，面试前准备两个月的时间再好好复习一遍，紧接着就可以刷面试题了，下面这些面试题都是小编精心整理的，贴给大家看看。
①大厂高频45道笔试题（智商题）
[外链图片转存中…(img-dWa1miRX-1713023667261)]
②BAT大厂面试总结（部分内容截图）
[外链图片转存中…(img-De1gZKcB-1713023667261)]
[外链图片转存中…(img-zTX2Ufap-1713023667261)]
③面试总结
[外链图片转存中…(img-cTu7kN5Z-1713023667262)]
[外链图片转存中…(img-zzDy2Mxj-1713023667262)]
3、结合实际，修改简历
程序员的简历一定要多下一些功夫，尤其是对一些字眼要再三斟酌，如“精通、熟悉、了解”这三者的区别一定要区分清楚，否则就是在给自己挖坑了。当然不会包装，我可以将我的简历给你参考参考，如果还不够，那下面这些简历模板任你挑选：
[外链图片转存中…(img-b74rSUo5-1713023667262)]
以上分享，希望大家可以在金三银四跳槽季找到一份好工作，但千万也记住，技术一定是平时工作种累计或者自学（或报班跟着老师学）通过实战累计的，千万不要临时抱佛脚。
另外，面试中遇到不会的问题不妨尝试讲讲自己的思路，因为有些问题不是考察我们的编程能力，而是逻辑思维表达能力；最后平时要进行自我分析与评价，做好职业规划，不断摸索，提高自己的编程能力和抽象思维能力。
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-Oq3WYJIK-1713023667262)]
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
910
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
