Java基础二核心知识点梳理:面向对象、集合、多线程与IO实战

本文系统梳理Java基础二阶段六大核心模块:面向对象(继承、多态、接口与抽象类选型)、集合框架(ArrayList/LinkedList差异、HashMap原理与线程安全集合)、异常处理与泛型(分层思维、类型擦除)、多线程(synchronized/volatile区别、线程池参数机制)、IO流(字节/字符流选择、缓冲流与try-with-resources)及序列化(serialVersionUID、transient、反序列化风险)。强调技术选型逻辑与工程实践,规避常见陷阱。

Java基础二这个阶段,很多人会觉得很微妙。说它是基础吧,好像已经能写点小项目了;说它是进阶吧,又总感觉差点火候。实际上,基础二才是真正拉开差距的地方。我见过不少开发者在基础一阶段用if-else写得很溜,一到面向对象、集合、异常这些内容就开始囫囵吞枣,结果后面去看框架源码、排查线上问题的时候,每一步都在补课。这篇文章就从我自己踩过的坑出发,把基础二的核心知识点重新梳理一遍,重点放在“为什么要这么设计”和“实际开发中到底怎么用”上,而不是单纯罗列API。适合正在学Java、准备笔试面试、或者工作一两年想回头补地基的开发者。

1. 基础二到底在学什么,为什么很多人卡在这里

1.1 从“会写代码”到“写得明白”

基础一阶段,大多数人都在学变量、循环、数组、方法,写出来的代码是“从上到下执行”的线性思维。基础二开始引入面向对象、集合、异常、泛型、多线程、IO这些概念后,思维方式就变了:不再是一行一行执行,而是要理解对象之间的协作关系、数据结构的选择、资源的生命周期和并发场景下的正确性。

很多人卡住,不是因为某个语法看不懂,而是因为“语法点都认识,但不知道用在哪儿”。比如继承会写,但不知道什么时候该用;异常try-catch会写,但不知道什么时候不该捕获;集合会new,但不知道ArrayList和LinkedList到底差多少。基础二的核心不是记忆API,而是建立一套“根据场景做技术选型”的判断力。

1.2 基础二的完整知识地图

我习惯把基础二的内容分成六个大块:面向对象、集合框架、异常处理、泛型、多线程、IO与序列化。这六块不是孤立的,它们是后续看源码、写业务框架、做性能调优的底层语言能力。

  • 面向对象:继承、多态、接口、抽象类,解决“代码怎么组织”的问题。
  • 集合框架:List、Set、Map家族,解决“数据怎么存储和查找”的问题。
  • 异常处理:受检异常与非受检异常,解决“错误怎么传递和处理”的问题。
  • 泛型:类型参数化与类型擦除,解决“代码怎么复用且类型安全”的问题。
  • 多线程:Thread、锁、线程池,解决“多个任务怎么并发执行”的问题。
  • IO与序列化:字节流、字符流、对象序列化,解决“数据怎么进出程序”的问题。

这张地图看着大,但每块其实都有清晰的主线。顺着主线学,就不容易被零散的知识点带偏。

2. 面向对象进阶:继承、多态和接口的真正用法

2.1 继承要避免的坑

继承是面向对象里最容易上手、也最容易滥用的特性。很多初学者喜欢为了复用代码而继承,比如写一个动物类,再写一个狗类去继承它,感觉天经地义。但在实际开发里,继承关系一旦设计得不好,后续修改的成本非常高。

我踩过的一个典型坑是:父类里放了一个通用的业务方法,子类里重写时只改了部分逻辑,结果其他子类也跟着受影响。后来排查问题时发现,真正的问题出在父类的默认实现写得太“聪明”了,导致子类行为不可预测。继承的设计原则应该是:父类只放稳定的共性骨架,把容易变化的细节留给子类去重写,同时要清楚方法重写的可见性规则,比如重写方法的访问权限不能比父类更严格,这是编译器会强制的,但刚开始很容易忽略。

2.2 多态和接口的设计思路

多态的核心是“父类引用指向子类对象”,这句话背起来容易,真正理解需要结合场景。比如开发一个支付模块,一开始只支持一种支付方式,直接写一个实现类就够了。但如果后面要加第二种、第三种支付方式,就会发现面向接口编程的优势:主流程只依赖接口,新增支付方式时不需要修改现有逻辑,只需要新增实现类。

接口在这里起的作用是行为约定。它不关心内部怎么实现,只规定“你能干什么”。这种思维方式也直接对应到日常开发里的依赖倒置原则:高层模块不应该依赖低层模块,而是依赖抽象。写代码的时候,定义方法的入参和返回值尽量面向接口,而不是具体实现类,这样测试和替换成本都会低很多。

2.3 抽象类与接口怎么选

抽象类和接口的区别,几乎是基础二阶段的必考问题,但更重要的不是背结论,而是会选型。

  • 抽象类适合描述“同一类事物中有公共属性或公共实现”的场景,比如一个报表生成器的基类,提供公共的模板方法。
  • 接口适合描述“具备某类能力但彼此没有强归属关系”的场景,比如可序列化、可比较、可克隆。

一个经典的记忆方式是:抽象类是“is-a”关系,接口是“can-do”关系。实际开发中,能用接口优先用接口,因为接口更灵活,Java只支持单继承,但可以多实现接口。过度使用抽象类会让类继承树变得很深,维护起来很痛苦。

提示:判断设计是否合理,可以反问自己:如果我把这个类换成另一个实现类,调用方代码需要改吗?如果只需要换对象,不需要改逻辑,说明抽象做对了。

3. 集合框架:不是背API,而是做选型

3.1 集合框架的整体结构

Java集合框架大概是基础二中最实用的部分。很多人一想到集合就是ArrayList和HashMap,但遇到嵌套结构、去重、排序、并发修改时,就不知道该用什么了。

集合框架的顶层主要分成两条线:Collection和Map。Collection下面又分成List、Set、Queue。List是有序可重复的,Set是无序不可重复的,Map是键值对。理解这个分类之后,选型的第一步就是根据数据特点拍板:

  • 要存一组数据且需要按顺序访问,选List。
  • 要存一组数据但不能有重复,选Set。
  • 要存键值对应关系,选Map。
  • 要按某种规则排队处理,选Queue。

看起来简单,但实际场景往往叠加了性能、线程安全、遍历顺序、扩容容量多种约束。所以真正要学的不是背接口方法,而是知道每种实现类的数据结构长什么样。

3.2 ArrayList与LinkedList的真实差异

ArrayList和LinkedList是List下面最常对比的两个实现。不少刚起步的开发者以为LinkedList在很多场景下都比ArrayList快,其实这是一个误区。

ArrayList底层是连续数组,随机访问非常快,时间复杂度是O(1),但插入和删除需要移动元素,复杂度是O(n)。LinkedList底层是双向链表,插入和删除只需要改指针,理论上复杂度是O(1),但前提是你已经定位到了对应节点;如果你通过索引去访问,它会从头遍历,复杂度反而是O(n)。

实际开发中,绝大多数场景用ArrayList就够。链表的内存占用更大,每个节点还要存前后指针,缓存局部性也差。我见过有人盲目用LinkedList优化性能,结果线下测试反而更慢,原因就是大量使用了按索引查找。优化性能之前,一定要先分析访问模式,而不是凭感觉选结构。

3.3 HashMap的核心原理与扩容

HashMap是面试和工作中都绕不开的重点。它的底层结构是数组加链表,Java 8之后链表长度超过阈值会转成红黑树,目的是降低极端情况下的查询开销。

理解HashMap的关键是三个点:哈希算法、扩容机制、hash冲突处理。put一个键值对时,会先计算key的hash值,再根据数组长度取模定位到桶位置;发生哈希冲突时,相同桶位置的元素会以链表形式串联;当元素个数超过负载因子乘以容量时,会触发扩容,重新分配桶位置。

负载因子默认是0.75,这是时间和空间的折中。设置太大会减少扩容次数,但哈希冲突概率增大;设置太小会浪费空间。不要轻易改这个值,除非你非常清楚容器里的数据量和访问特征。

注意:在多线程环境下,HashMap的读写并不是线程安全的。并发修改有可能导致数据丢失,甚至在某些版本中扩容时可能出现循环链表问题。基础二阶段最容易犯的错就是直接在多线程场景里用HashMap,结果线上偶现死循环或者CPU飙高。

3.4 线程安全集合的选择

既然普通集合不线程安全,自然需要线程安全的替代方案。这个知识点看起来简单,但选错的情况特别多。

  • Hashtable:老古董,方法级加锁,并发性差,现在基本不用。
  • Collections.synchronizedMap:包了一层同步锁,也是全表锁,适合简单场景,但并发高时性能不理想。
  • ConcurrentHashMap:采用分段锁或者CAS加锁,读操作基本无锁,并发性能好,是高并发场景的主流选择。
  • CopyOnWriteArrayList:读多写少场景的利器,写时复制原数组,适合读多写少的配置类数据。

记住一个原则:不是所有共享数据都需要并发集合。如果数据本身就是线程封闭的,比如只在方法内部使用,那用普通集合就够了。盲目加锁反而降低可读性和性能。

4. 异常处理与泛型:让代码更健壮

4.1 异常处理的分层思维

异常的处理方式,是基础二阶段非常能体现工程素养的地方。很多人喜欢在每一层都try-catch,结果问题被层层吞掉,最后定位不到根因。

异常处理的正确思路是“该抛出时抛出,该处理时处理”。在底层方法中,如果当前层级没有足够的信息来决定如何处理异常,就应该向上抛出;在靠近用户入口的层,才统一捕获并转换成用户能理解的提示信息。

受检异常和非受检异常的区别也要搞清楚。受检异常强制调用方处理,比如IOException;非受检异常一般是不该出现的编程错误,比如空指针、数组越界。实际开发中,不要滥用受检异常,否则每个方法签名都挂一堆throws,调用方只能被迫try-catch,整个代码变得很难看。

4.2 泛型的边界与类型擦除

泛型解决了“类型不确定但又要保证类型安全”的问题,比如一个通用的List可以存任意类型,但取出来时不希望强转出错。泛型的边界包括上界和下界,比如 ? extends T 表示允许T和T的子类, ? super T 表示允许T和T的父类。这个规则通常称为PECS原则,即生产者使用extends,消费者使用super。

但泛型有一个很重要的特性是类型擦除。泛型信息在编译后会被擦除,运行时并不保留。这意味着你不能用 instanceof 去判断一个List里存的是String还是Integer,也不能创建泛型数组。很多人在写通用工具类时踩坑,就是没有理解类型擦除带来的限制。

提示:写泛型方法时,泛型声明要放在方法返回值之前,格式是 public <T> T doSomething(T value) 。这个语法容易写错,一旦写错,编译器报出来的错误信息对初学者很不友好。

5. 多线程与并发基础:从Thread到线程池

5.1 创建线程的几种方式

创建线程的方式传统说有三种:继承Thread、实现Runnable、实现Callable。继承Thread的写法最简单,但不推荐,因为Java是单继承,继承Thread后不能再继承其他类,而且继承方式把任务和线程耦合在了一起。

更推荐实现Runnable或Callable接口,这样可以把“要执行的任务”和“执行任务的线程”解耦。Callable和Runnable的区别是Callable有返回值,并且可以抛出受检异常。配合Future和FutureTask,可以拿到异步执行的结果。

实际开发中直接手动创建Thread场景很少,绝大多数情况应该使用线程池。手动创建线程的问题有两个:频繁创建销毁线程开销大,线程数量不可控,容易导致系统资源耗尽。

5.2 synchronized与volatile的区别

synchronized和volatile都是并发编程里的关键词,但很多人容易混淆。volatile解决的是可见性问题,它保证当一个线程修改变量后,其他线程能立即看到最新值;但它不保证原子性。synchronized解决的是原子性和可见性,它通过锁机制保证同一时间只有一个线程执行临界区代码。

举个例子,一个简单的计数器自增操作,用volatile修饰是不够的,因为自增包含读、加、写三步,期间可能被其他线程打断。所以这种场景需要synchronized或者AtomicInteger。

对volatile的常见记忆方式是:它适合“一个线程写、多个线程读”的标志位场景,比如开关变量。如果你需要一个复合操作是原子的,不要依赖volatile。

5.3 线程池参数解读

线程池是并发编程中非常实用的工具,但参数配置如果不理解,很容易出问题。线程池的核心参数有七个:核心线程数、最大线程数、空闲存活时间、时间单位、工作队列、线程工厂、拒绝策略。

理解线程池行为的关键是:任务提交时,如果当前线程数小于核心线程数,就创建新线程;如果达到核心线程数,任务进入队列等待;如果队列满了,且线程数还未达到最大线程数,就创建新线程;如果线程数已达到最大线程数且队列也满了,就执行拒绝策略。

拒绝策略有几种,比如直接抛出异常、让提交任务的线程自己执行、丢弃当前任务、丢弃最老的任务。具体用哪种,要看业务对任务丢失的容忍度。实际开发中,我当时为了图省事直接把核心线程数和最大线程数都设成一样,结果在高峰期大量任务排队,响应时间飙升。

注意:线程池中的线程不是越多越好。如果是CPU密集型任务,线程数一般设置成CPU核数加一;如果是IO密集型任务,可以设置成CPU核数的两倍左右,但也要配合压测验证。真正生产环境里的参数调整,一定是要结合具体业务流量和资源监控来做的。

6. IO流与序列化:文件操作的进阶

6.1 IO流分类与选择

IO流也是基础二的重要内容。Java的IO流分为字节流和字符流,分别以InputStream/OutputStream和Reader/Writer为基类。字节流处理二进制数据,比如图片、音频;字符流处理文本数据,比如txt、日志文件。使用原则很简单:操作二进制用字节流,操作文本用字符流,千万不要混用。

IO流里还有一层是缓冲流,比如BufferedInputStream、BufferedReader。缓冲流的意义是减少底层系统调用次数,把读写过程先放到内存缓冲区,攒一批再一次性写入或读取。日常开发中,读写文件强烈推荐加缓冲流,性能差距非常明显。

在Java 7之后,可以使用try-with-resources语法来管理流资源,也就是在try后的圆括号里创建流对象,代码块结束后会自动关闭资源。这个机制能避免因为忘记关闭流而导致的文件句柄泄漏。我见过不少线上问题就是文件句柄没关,最后把系统资源耗尽。

6.2 序列化要小心的坑

序列化指的是把对象转换成字节流,以便存储或传输。对应的反序列化是反方向操作。Java原生的序列化机制通过实现Serializable接口就能用,但这里有几个坑比较隐蔽。

第一个是serialVersionUID。定义一个long类型的serialVersionUID,可以在类结构发生变化时保持序列化版本一致。如果不显式定义,JVM会根据类结构自动生成一个,但一旦类结构变了,反序列化时可能抛出InvalidClassException。所以对于要长期存储或跨版本传输的类,一定要显式声明serialVersionUID。

第二个是序列化会保存整个对象图,包括所有引用到的对象。如果对象图里有不可序列化的字段,序列化就会失败。这时可以把不需要序列化的字段用transient修饰,或者自定义writeObject和readObject方法来控制序列化逻辑。

第三个是安全风险。反序列化时如果数据来源不可信,可能触发一些恶意代码。这一点在实际项目中通常会被强调,尤其是涉及网络传输的场景。不要对不可信的数据直接做原生反序列化,尽量使用受控的JSON等文本格式并做白名单校验。

7. 常见问题与排查技巧实录

7.1 编译报错排查思路

基础二阶段的编译报错,有几种典型情况。第一种是泛型类型不匹配,比如把List 传给一个接收List

第二种是异常处理不兼容,比如方法声明了throws Exception,但调用方没有捕获或者没有继续向上抛出,编译器会直接报错。第三种是继承关系访问权限问题,比如子类重写父类方法时,把public改成protected,这不合法。

排查编译错误最有效的方式是看第一个报错信息。IDE通常会同时显示数十条错误,但大部分是连锁反应,真正的问题往往是第一条。先修第一条,再重新编译,很多后续错误会自动消失。我一开始最蠢的做法是试图一条一条地从上往下修,结果越改越乱。

7.2 运行时异常的常见场景

运行时异常里最常遇到的就是NullPointerException、ClassCastException、ArrayIndexOutOfBoundsException。NullPointerException通常源于返回值没判空、集合元素为空、或者某个字段没有初始化。排查时尽量从堆栈信息的第一行往下看,定位到具体是哪个类哪个方法抛出的,再往前找调用链。

ClassCastException一般出现在强制类型转换不匹配的时候,比如把一个String对象强转成Integer。这通常意味着设计上就有问题,应该用泛型来规避掉强转,或者在做类型判断之后再转换。

排查运行时异常,不要只看异常类型,关键要看异常堆栈的完整输出。堆栈里会给出目标类名、方法名和行号,这是定位问题的第一现场。很多线上问题只要把完整堆栈贴到IDE里,很快就能看出哪一行代码出了问题。

7.3 内存与性能小陷阱

基础二阶段虽然不会接触太深的内存优化,但已经可以碰到一些隐患。最常见的是循环里拼接字符串用加号,这会在循环体内频繁创建新字符串对象,严重时会影响性能。应该使用StringBuilder或StringBuffer,后者线程安全但开销稍高,线程不冲突时优先用前者。

另一个陷阱是集合扩容机制带来的隐性开销。ArrayList默认容量是10,如果预计要存储较大数量的元素,可以在初始化时传入初始容量,减少扩容次数。HashMap同理,如果已知数据量,可以提前计算好初始容量,避免频繁扩容。

还有一些性能问题来自于不合理的锁竞争。平时写代码时选择的锁粒度太粗,比如把整个方法用synchronized修饰,会导致并发性能很差。优化方向是缩小锁的覆盖范围,只锁真正需要保护的代码块,而不是整个方法。

最后的几点个人体会

基础二这个阶段,最大的难点其实不是某一个知识点,而是从“单个语法”到“综合运用”的转变。我自己学的时候,习惯把重点放在两个地方:一是对着集合类和线程池源码去看它为什么要这么设计,二是刻意在写的每个小练习里用上接口和泛型,而不是都用最直观的ArrayList加if-else。这样过一遍之后再去看框架源码,明显能感觉到顺畅很多。最后再分享一个小技巧:准备一个专门记录踩坑的笔记,遇到一个编译错误或运行时异常,就把完整堆栈和解决思路记下来,隔一段时间翻一次,这些经验比任何教程都记得牢。基础二的知识点真的不难,难的是你有没有把它当成一套思维方式来学。

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址