很多人学 Java 都有种错觉：第一天装好 JDK、配好环境变量，跑通一个 Hello World，第二天就开始写各种业务逻辑。但真正工作几年回头看，基础概念恰恰是区分“会写代码”和“写得明白”的分水岭。Day2 这篇内容，就是想把 Java 基础概念里那些最容易被一带而过、却在面试和工作里反复踩坑的点，掰开揉碎讲透。适合刚学完环境配置的新手，也适合准备校招面试、想系统过一遍八股文的同学。我会用实际踩过的坑和正常文档里不会写的细节，帮你把这些概念变成你自己的东西。
1. 先从环境配置聊起：为什么你的 java 命令还是报错
既然标题是 Day2，默认你已经完成了 JDK 安装和 Hello World。但我敢打赌，很多人卡在的不是写代码，而是环境变量。特别是热搜词里反复出现“java环境变量配置”“java安装教程详细”，说明这关真的劝退了大量新手。我先把这个底层逻辑讲清楚，不然之后所有工具链的坑你都只能靠百度。
1.1 环境变量到底配置了什么
Windows 上配置 JAVA_HOME、Path、classpath 这三件事，很多人是照着教程瞎填的。JAVA_HOME 是一个“供其他软件查找 JDK 位置的指针”，比如 Tomcat、Maven、IDEA 都会通过它去找到 javac 和 java。Path 里追加%JAVA_HOME%\bin是为了让操作系统在任意目录下都能直接执行java -version这类命令，本质是告诉系统“去哪里找可执行文件”。classpath 在 JDK 1.5 之后已经基本不需要手动配置，但很多老教程还在让你配，导致明明配完反而连java命令都乱了。
我见过最有意思的报错是：明明java -version能输出版本号，但javac却提示“不是内部或外部命令”。原因很简单，你配置的 Path 指向的 bin 目录下，只有java.exe没有javac.exe。这种情况大概率是你装了 JRE 而不是 JDK，或者下载的是那种“精简版”的 JDK 安装包。记住一个结论：写 Java 代码必须有 JDK，而 JRE 只能运行别人编译好的 class 文件。所以下载时认准“Java SE Development Kit”字样，别手滑装了 JRE。
1.2 一个经典报错：NoClassDefFoundError 的真相
热搜里有个很扎眼的：“uncaught exception java.lang.noclassdeffounderror: java/applet/applet in thr”，还有“java sun.misc把不存在”和“drozer+找不到java”。这些看似是高版本 JDK 与老代码的兼容性问题，但背后反映的是类加载机制的基础概念没搞懂。
NoClassDefFoundError 的意思是：编译时这个类存在，但运行时的 classpath 里找不到它。很多新人以为这是“类没写对”，其实它跟 ClassNotFoundException（真正找不到这个类）不一样。举个例子：你编译了一个用了 Applet 的程序，在 JDK 8 下没问题，换到 JDK 11 运行就报java/applet/Applet找不到，因为高版本 JDK 已经移除了 Java Applet API。这告诉我们一个基础概念：编译期和运行期的类目录（classpath）必须一致。IDEA 里出现这个报错，第一步不是重装 JDK，而是看 Project Structure 里的 SDK 和依赖库是否匹配，再到运行配置里看 classpath 是不是被截断了。基础不牢的人会在这里耗掉一整个下午，而懂原理的人三十秒就能定位。
2. 标识符和命名规则：代码的可读性从取名开始
“java 标识符命名规则”能进热搜，说明这是初学阶段最高频也最琐碎的考点。但你别把它当成死记硬背的语法条款，它其实决定了你的代码能不能被所有人正常阅读。我见过团队里有人用拼音缩写类名，有人用数字开头，还有人把类名全小写——这些都不是“能不能跑”的问题，而是“代码值不值得维护”的问题。
2.1 标识符的语法规则
Java 标识符的硬性规则其实就四条：以字母、下划线_或美元符$开头，后续可以跟数字；不能和关键字重名；严格区分大小写；没有长度限制。这里的“字母”泛指 Unicode 字符，也就是说中文理论上可以做变量名。但不是所有能编译通过的写法都该出现在生产代码里，$开头的变量在逻辑上留给自动生成代码使用，你手动写一个$userId反而容易和框架生成的字段冲突。
我喜欢用一个比喻：标识符就像给变量起的“身份证号”。int 1number = 10;编译不通过，因为身份证号不能以数字开头；int class = 20;编译不通过，因为“class”是系统保留给“类”这个概念的专用字，你不能拿来命名别的场合。这些规则的存在不是为了刁难你，而是为了让编译器能快速区分“这是什么类型的东西”。你在 IDLE 里随手试几次报错，比背十遍规则记得更牢。
2.2 大小写敏感的坑与命名规范
Java 对大小写极其敏感，Name和name是两个完全不同的变量。这个特性带来一个经典翻车场景：队友写了个getuserInfo()，你调用getUserInfo()，IDE 还没智能提示到那个程度时，一个小方法名错误就能让整个编译挂掉。所以规范才要求：类名大驼峰（UserInfo），方法名小驼峰（getUserInfo），常量全大写加下划线（MAX_VALUE），变量名小驼峰（userName）。这不是审美问题，是一种“视觉编码”——看到CONNECT_TIMEOUT你就知道它是常量，看到UserService你就知道它是一个类类型。
我强烈建议新手在第一天就养成习惯：写一个类之前，先想清楚它的名字是名词性的（Car、Order）还是动词性的（Runnable、Closeable），这能反向帮你理清设计意图。你写class run的时候，自己都会疑惑“这是一个动作还是普通类”，这正是命名规范在强迫你思考“这个类到底是什么”。
3. 数据类型与变量：强类型语言的第一道门槛
Java 被称为强类型语言，这句话很多新手听过，但没体会到它的分量。所谓强类型，指的是每个变量在使用前必须先声明类型，并且不能在程序运行中随意改变类型。这跟 Python 那种动态类型完全是两套思维。Day2 这个阶段，你不需要背所有类型的取值范围表，但必须理解基本类型和引用类型在内存和使用方式上的天壤之别。
3.1 基本类型 vs 引用类型
Java 有八种基本类型：byte、short、int、long、float、double、char、boolean。它们的变量名直接对应一块内存地址上的值。而引用类型的变量存的是一个“地址”，这个地址指向堆内存里的某个对象。我用一个生活化类比：基本类型是“你的身高 175cm”，这个值直接刻在你身上；引用类型是“你家住在某某小区 3 栋 502”，你买的是“地址”而不是“房子本身”。
这个区别在开发中会引出很多经典坑。比如两个Integer对象用==比较，结果可能是 false，因为==比较的是地址，不是数值。前两天还有人问我为什么Integer a = 127; Integer b = 127; a == b是 true，而换成 128 就变 false。原因就是Integer缓存了 -128~127 这些常用数值，在这个范围内拿到的都是同一个对象引用，而范围外会 new 新对象。这就是“基础概念 + 源码细节”的经典组合，也是面试八股文最爱挖的地方。
3.2 类型转换中的精度丢失
类型转换分隐式和显式。int转long是自动的，因为大杯子能装小杯子；double转float可能会丢精度，所以需要强转。最容易被忽略的是“先把 int 相除再转类型”的问题：double result = 3 / 2;你以为是 1.5，结果是 1.0，因为等号右侧先把两个整数相除得到整数 1，再转成 double。正确写法是3.0 / 2或(double) 3 / 2，才能得到 1.5。
还有金融领域最忌讳的float和double直接参与金额计算，因为二进制无法精确表示部分十进制小数，0.1 + 0.2在 Java 里是0.30000000000000004。这种低级错误一旦出现在线上对账系统里，损失是按分计算的。所以基础阶段就要建立“什么时候用浮点，什么时候用 BigDecimal”的判断模型。浮点数适用于科学计算、允许误差的统计场景；涉及货币、数量等精确数值时，老老实实用BigDecimal。
4. 运算符与表达式：那些让你怀疑人生的细节
“java运算符”和“java运算符和表达式”都进了热搜，但这个知识点太容易被学成“看一眼就会”了。真到了做算法题或者写业务逻辑时，运算符优先级、自增自减的坑会分分钟教你做人。我挑两个典型场景展开，比罗列一整张优先级表更有用。
4.1 自增自减：i++ 与 ++i 的底层区别
很多人背口诀：“++i 是先加后用，i++ 是先用后加”。这句话没错，但真正写复杂表达式时，你需要的是对“操作数栈”的直觉。我用最笨的办法解释：int i = 0; int j = i++ + ++i;这个表达式的结果是什么？如果你直接算，大概率分神。我们分步看：i++先把 i 的当前值 0 压入栈，然后 i 变为 1；++i先把 i 加 1 变为 2，再压入栈；然后把两个栈顶元素相加，0 + 2 = 2，最终 j 是 2，i 也是 2。
这个例子想说明的是：自增自减不是“魔法”，它们就是在表达式求值过程中修改了变量的值，并且把“自增前的值”或“自增后的值”作为该位置的结果。在真实代码中，我强烈建议：不要在非单独语句的复杂表达式里使用自增自减。比如list.get(index++)这种虽然合法，但代码审查时会被喷得狗血淋头，因为它把“取数据”和“改变索引”两件事耦合在一起了，肉眼很难看出到底是先取还是先加。能用三行说清楚的事情，别用一行炫技。
4.2 短路运算与位运算的实际场景
逻辑运算符&&和||做短路求值：false && anything()直接返回 false，根本没机会执行右侧的anything()；true || anything()同理。这个特性除了提升性能，更重要的是可以安全地做“判空保护”：if (user != null && user.getName().equals("admin"))，如果 user 为 null，短路后不会执行右侧，从而避免空指针异常。这是每个 Java 开发每天都会用的模式，但你真让新手解释“为什么null && ...不报错”，很多人只会说“语法就是这样”。
位运算符&、|、^、<<、>>在实际业务里看起来用得少，但学这个唯一的意义是理解“计算机最底层的运算其实就是位运算”。比如value & 1可以判断奇偶，value << 1相当于乘以 2。HashMap 计算数组下标时(n - 1) & hash，就是利用&运算来替代取模，从而获得更低的开销。你不知道这些也能写 Java，但知道了这些，你读框架源码时才不会一头雾水。“java高级计算器”这个关键词也许就代表有人在这个方向跃跃欲试。
5. 面向对象第一课：类、对象和引用的三角关系
“java面向对象”“java 反射”“java设计模式”都是热搜词，但 Day2 我不打算直接讲设计模式，而是先把面向对象最核心的三角关系理清：类、对象、引用。这三者的区别如果只是停留在“类就是模板，对象就是实例”，那你写代码时还是会频繁出现NullPointerException，因为你对“引用”这个概念没有直觉。
5.1 类与对象的区别
类是图纸，对象是按照图纸生产出来的房子。图纸可以定义每个房间的尺寸、门的颜色，但它不是实体；房子里面的实际家具、住进去的人是对象的数据。你写class Student { String name; }，这只是一份图纸；你写new Student()才是按照图纸在堆内存里盖了一间房子，这个房子有自己独立的内存空间，也有自己的name字段。
这个“new 出来的对象各自独立”的概念，在写代码过程中特别容易被忽略。比如两个Student对象互相赋值s1 = s2，实际上是把 s1 这个“地址”换成了 s2 的地址，原本 s1 指向的房子变成了没人住的垃圾，稍后被 GC 回收。如果你不理解这一点，你就会误以为“s1 和 s2 是两个对象，改一个不影响另一个”。实际上它们指向同一个地址，改一个必然影响另一个。这个知识点在写缓存、写实体转换的时候几乎天天踩。
5.2 引用传递陷阱：Java到底是值传递还是引用传递
这是个面试高频问题，也是无数人吵不清的“八股”。结论：Java 只有值传递。方法参数传入的基本类型是值拷贝，传入的引用类型是引用地址的值拷贝。这个“值拷贝”意味着：在方法内部对形参重新赋值（param = new Object()），不影响外部实参；但通过形参去修改对象内部的字段（param.setXxx(...)），会影响外部实参。
用生活例子：你把家里的钥匙复制了一把给别人，别人可以用钥匙开门（改房间里的东西），但别人如果把这把钥匙烧了（把形参指向 new 对象），你自己手里的钥匙和房子都不受影响。所以在方法里想把“对象本身”换掉是做不到的，最多能换掉对象的属性。理解了这一点，很多 bug 的根源一眼就能看穿。比如你写了个changeName(Student student)，在方法里student = new Student(...)，外部调用者的对象永远不会被替换，但如果写的是student.setName(...)，外部就能感受到变化。
6. 集合框架入门：为什么基础阶段就要懂 ArrayList 和 HashMap
热搜词里“java集合”“java容器”“java中redis使用redistemplate的increment()报错不是integer or out of range”同时存在，说明集合概念直接关联到实际开发报错。Day2 不需要把整个集合框架背下来，但必须建立起“数组不够用，集合来补位”的思维方式。
6.1 数组的局限和集合的登场
数组一旦声明长度就固定，比如int[] arr = new int[10]，你想存第 11 个元素只能重新创建更大的数组，把旧元素拷贝过去。而ArrayList底层虽然也是数组，但它内部封装了扩容机制——默认容量 10，超过时按 1.5 倍扩容，并自动System.arraycopy拷贝旧元素。这个“自动扩容”的基本原理，就是集合的第一课。你不需要背源码，但要理解为什么ArrayList插入删除慢、随机访问快，因为底层是连续内存的数组；为什么LinkedList插入删除快、随机访问慢，因为底层是双向链表，节点之间手牵手连接。
业务选型时有个简单的直觉：如果场景以“遍历、按下标访问”为主，就用ArrayList；如果场景以“频繁在头部和中间插入删除”为主，才考虑LinkedList。但说实话，现代 JVM 和 CPU 缓存机制下，ArrayList在绝大多数场景都击败LinkedList，甚至很多时候插入删除也不慢。所以你不需要为了“理论”而强行使用LinkedList，这个结论进了大厂做业务后你会更有感触。
6.2 单列集合与双列集合的选型逻辑
集合框架分成两条主线：Collection（单列，每个元素独立）和Map（双列，键值对）。List关心顺序和重复，Set关心唯一性，Map关心键值映射。每一条线背后的数据结构都不一样：HashSet底层是HashMap，TreeSet底层是红黑树。知道这些继承关系和底层结构，才能回答好“Java集合”相关的面试题。
最常用也最容易踩坑的是HashMap。它的基本概念包括：数组 + 链表 + 红黑树（JDK 8 以后），默认负载因子 0.75，数组默认容量 16。为什么是 0.75？这是时间与空间折中的经验值，太高会减少扩容、节省空间但链表过长导致查询变慢，太低则反之。很多人在HashMap里存了大量数据后出现严重的性能问题，多半是因为没有自定义初始容量，导致高频扩容和 rehash。写代码时如果能预判数据量，最好用new HashMap<>(expectedSize)给一个合理初始容量，这个细节能避免很多 GC 和性能问题。
有趣的是，热搜里那条“java中redis使用redistemplate的increment()报错不是integer or out of range”，表面看是 Redis 操作报错，但根子还是基础概念没打通：RedisTemplate默认 JDK 序列化器，会将你传入的 long 类型序列化成带有类信息的二进制数据，Redis 端执行 INCR 时解析不了。这提醒我们：一切复杂框架的报错，最后都会回溯到最基础的数据类型、序列化、集合这些概念上。你以为你在学框架，其实你是在补基础。
7. 字符串的是与非：为什么“==”不靠谱，String 不可变又是什么
字符串是 Java 里最常用也最特殊的一个类，热搜词“java字符串多行写法”也许能代表一部分人对字符串语法的好奇，但我更想强调和基础概念强相关的两大深坑：相等比较和不可变性。几乎每个面试官都问过String s1 = "abc"; String s2 = "abc"; s1 == s2的结果。答案是 true，因为字符串字面量会进入常量池复用；但如果改成String s3 = new String("abc"); s1 == s3，结果就是 false，因为new一定在堆里新建对象。所以比较字符串内容永远用equals，不要用==。这不仅是笔试考点，也是实际开发中大量“值看起来一样但判断失败”的根因。
String 的不可变性指String对象创建后，它的值不可变。你看到的s += "b"并不是在原来字符串后面追加，而是创建了一个新的字符串对象，将引用指过去。这种设计的优点包括：字符串常量池可以安全复用、线程安全、适合作为HashMap的 key。缺点是频繁拼接字符串会产生大量丢弃的临时对象，拖累性能。所以循环里做字符串拼接时，优先用StringBuilder或StringBuffer。很多人记不住两者区别：StringBuilder非线程安全但快，StringBuffer加了同步锁但慢。单线程环境里别用后者，那是给自己上绞索。
“java字符串多行写法”这块，JDK 15 正式引入文本块，用三个双引号"""包裹，可以优雅地书写多行 JSON、SQL。但很多人不知道文本块不是普通字符串，它会在编译期对缩进和换行做规范化处理。初学者看到输出不符合预期时，不要慌，先检查是不是行尾空格被去掉了、缩进是否被自动调整。这也是字符串基础概念带出来的“进阶奇技淫巧”。
8. 常见运行时异常：看到异常先别慌，分类比背十万个报错重要
“uncaught exception java.lang.noclassdeffounderror: java/applet/applet in thr”“java: outofmemoryerror: insufficient memory”“java中数组越界异常”这些热搜词说明，异常处理是新手最大的噩梦。我的建议是：不要试图背住每个异常的真实全名，而是先学会按异常类别判断问题方向。
8.1 受检异常与非受检异常的判断逻辑
受检异常（checked exception）是编译器强制你处理的异常，比如IOException、SQLException。你写文件读取代码时如果不try-catch或throws，连编译都过不去。非受检异常（unchecked exception）是运行时异常，比如NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException，它们由RuntimeException派生，编译器不强制处理。但“不强制”不代表“不需要处理”。我见过很多五百行的方法里一个 try-catch 都没写，结果线上一个NPE直接把接口打挂。正确的思路是：可恢复的场景用 try-catch 包装并降级处理，不可恢复的场景要么及时向上抛，要么用统一异常处理器兜底。
还有一条铁律：异常别打日志之后再抛出同一个新的异常，否则日志里会同时出现两段堆栈，排查时让人精神分裂。曾经有同事在 catch 里logger.error(...)后又throw new RuntimeException(e)，结果监控平台告警里一条错误带着两个重复堆栈，我们花了大半天才定位到真实根因。这个坑不踩一次不长记性。
8.2 内存溢出与内存泄漏的差异
“OutOfMemoryError: insufficient memory”听起来就是“内存不够”，但你要区分两种子情况。java heap space表示堆内存满了，常见原因是大集合对象没被释放、一次性加载了大量数据、死循环里疯狂 new 对象。MetaSpace溢出通常和动态生成类、大量反射有关。排查时用jstat、jmap、jvisualvm这些 JDK 自带的工具看内存分布，比盲目调大-Xmx靠谱。调大堆内存只是止痛药，真正的病因往往是“对象引用被意外被长期持有”。
数组越界异常ArrayIndexOutOfBoundsException其实是最容易避免的一类异常，核心就是记住数组下标从 0 开始、最大下标是length - 1。但为什么那么多人还会犯？根源是“循环边界条件写错”：用<=而不是<，或者把长度取成size()而不是size()-1。最佳实践是用增强 for 循环或迭代器，让语言去管边界，你只管写业务逻辑。日常编码时配合防御性判断if (index >= 0 && index < list.size())，能从源头杜绝大部分越界问题。
9. 学习方法论：Day2 之后，如何一步步构建长期竞争力
前面聊了很多具体知识，最后我特别想聊聊“Day2”之后的学习节奏。因为基础概念不是看一遍就能固化下来的，它是一个“反复回环”的体系。你今天学了数据类型、运算符、集合、异常，明天学流程控制、数组、方法，后天可能会接触到类和对象、继承、多态，再后面碰到 IO、网络编程、并发。每学一个新主题，尽量回头看看今天的这些概念有没有被重新调用。比如学到反射时，回到对象创建看看new和反射创建对象的区别；学到 Redis 连接时，回到数据类型看看为什么键值会有序列化问题。这种“知识回环”，比按目录顺序刷视频课牢固得多。
实操层面，我建议每天抽出半小时写几个小的代码片段，不一定要做项目，但要把今天学的概念强行用一遍。比如今天学完运算符，你就写一个小函数计算一个整数的二进制、八进制、十六进制表示；学完集合，你就模拟一个学生成绩管理，用HashMap存姓名和分数，用ArrayList存所有学生对象，再试试哪些操作会抛异常，手动 debug 看看堆栈走向。这种刻意练习能让你快速积累异常处理的经验值，而不是等问题在自己项目里爆发时才手足无措。
最后分享一个我自己的小偏方：准备一个“报错笔记本”，每遇到一个看不懂的异常，就把它、堆栈里最关键的一行、触发时的上下文、解决方法记录下来。坚持一个月后，你会神奇地发现，新报错越来越少。因为 Java 基础概念的本质就那么多，大量异常都是那些概念的实际变体。你见多了，自然就不慌了。Day2 不是终点，而是你真正开始“有概念”地写 Java 的第一个里程碑。
