1. 先搞清楚变量到底是个啥
做Java开发这些年，我带过不少新人，发现一个特别有意思的现象：很多人写Java代码能跑起来，但你要是突然问他“变量到底是什么”，他反而会愣住。变量这个概念太基础了，基础到几乎没人认真讲，但恰恰是这种“地基知识”决定了你后面能走多远。Java里那句经典名言“Everything is an object”大家都听过，但很少有人告诉你，变量才是你操作这些对象的钥匙。
先说个最简单的类比。你把变量想象成一个贴了标签的盒子，盒子放在内存里，标签上写着名字。你往盒子里放东西，就是赋值；你从盒子里取东西用，就是读取。Java程序跑起来之后，所有计算、判断、流转，本质上都是在对变量做读写操作。没有变量，你连一个加法都做不了——总不能把数字都死写在代码里吧？同理，方法（Method）就是你给这些盒子设计的一系列操作规则：先拿哪几个盒子、怎么处理里面的值、最后得到什么结果、要不要把结果放回某个盒子里。变量管“存储数据”，方法管“处理数据”，这两样东西组合起来，就是Java程序的骨架。
这篇内容适合谁？刚学Java准备入门的小白、自学到一半感觉概念模糊的读者、甚至是有一定经验但想系统梳理一遍基础的老手。我尽量用大白话加实际代码，把变量和方法讲透。只要你跟着把代码敲一遍，再对照文里的错误案例踩一遍坑，后面学面向对象、集合框架、IO流这些东西，会顺手很多。
提示：本文所有代码基于JDK 8+，我用的是JDK 17，但涉及的内容在Java 5到Java 21都通用，不涉及新特性差异，放心用。
2. 变量全套细节：从声明到消亡
2.1 声明、初始化、赋值，三个动作别搞混
新手最容易翻车的地方，就是把“声明”“初始化”“赋值”三件事搅在一起。我经常在面试里问这个问题，十个应届生里有八个答不完整。先记住一句话：声明是告诉JVM“我要用一块内存了”，初始化是第一次往里面放值，赋值是往里面替换值。
int age; // 声明：盒子已经准备好了，但里面是空的（严格说是默认值0） age = 18; // 赋值：往盒子里放值 int score = 95; // 声明+初始化：一步到位，声明的同时放值 score = 96; // 赋值：替换值这里有个特别容易踩的坑：局部变量不初始化就直接用，编译直接报错。比如：
public void test() { int a; System.out.println(a); // 编译错误：Variable 'a' might not have been initialized }为什么局部变量必须初始化，而成员变量不用？因为成员变量有默认值（int默认0、boolean默认false、引用类型默认null），JVM在创建对象时自动帮你初始化了。但局部变量是方法内部的临时存储，JVM为了性能不会自动给你做这事儿，你不初始化就用，编译器直接拦你。这不是语法刁难，是防止你拿到一个不确定的值在那瞎算。
另一个常见误区是以为“声明了就应该有值”。记住：成员变量有默认值，但依赖默认值写业务代码是坏味道。比如你定义一个int类型的成员变量不初始化，默认是0，但业务里“0”可能是个合法值，也可能代表“未设置”，光靠默认值根本区分不了。我见过生产环境出事故，就是因为某个人依赖了默认值0，后来需求变动，0变成了一个有业务含义的值，直接逻辑错乱。规范做法是显式初始化，或者用包装类型Integer并用null表示“未设置”。
2.2 基本类型和引用类型，差的可不止“存储方式”
Java的变量类型分为两大类：基本类型（Primitive Type）和引用类型（Reference Type）。这可以说是整个Java类型系统最重要的一条分界线。
基本类型一共有8个：byte、short、int、long、float、double、char、boolean。它们是值语义，变量存的就是实实在在的数据本身。引用类型则相反，变量里存的是一个地址（引用），指向堆内存里真正的对象。String、数组、你自定义的类、集合框架里的东西，全是引用类型。
用生活类比来解释：基本类型就像你直接抄在便利贴上的电话号码，方便但信息量有限；引用类型像你在通讯录里存了一个联系人ID，通过ID能找到完整的联系人信息卡片。
int a = 10; int b = a; b = 20; // 此时a还是10，b是20。基本类型赋值是拷贝值，互不影响。 int[] arr1 = {1, 2, 3}; int[] arr2 = arr1; arr2[0] = 99; // 此时arr1[0]也变成99了。引用类型赋值是拷贝引用，两个变量指向同一块内存。这个差异如果理解不透，后面写代码会莫名其妙出一堆bug。尤其是做Java集合操作、传参的时候，大部分“怎么这个值被改了”的诡异问题，根源都在这里。
顺便提醒一句关于String的细节。String是引用类型，但有个特殊待遇：字符串常量池。你写String s1 = "hello"和String s2 = "hello"，其实两个变量指向同一个String对象。但如果你用new String("hello")，就会创建一个新对象。用双引号直接赋值和用new创建，行为不一样。这个地方面试考得极多，后面常见问题部分我会再展开。
2.3 变量作用域：局部变量、成员变量、静态变量的爱恨情仇
作用域决定了一个变量“在哪些地方能看见我”。Java的变量作用域主要分三种：局部变量、成员变量（实例变量）、静态变量（类变量）。
- 局部变量：定义在方法内部或代码块内部，出了花括号就消失。
- 成员变量：定义在类内部、方法外部，属于对象，每个对象一份。
- 静态变量：用static修饰，属于类，所有对象共享一份。
public class Person { static String species = "人类"; // 静态变量，所有Person对象共享 String name; // 成员变量，每个对象独立 int age; // 成员变量 public void sayHello() { String greeting = "你好"; // 局部变量 System.out.println(greeting + "，我是" + name); // 这里可以访问静态变量species、成员变量name，也能拿到局部变量greeting } }我见过最多的新手错误之一，是在方法里直接写一个跟成员变量同名的局部变量，然后以为能“修改”成员变量。这叫“变量遮蔽”（Shadowing）。在方法内部，局部变量会把同名成员变量“挡住”：
public class Test { int num = 10; public void change() { int num = 20; // 局部变量遮蔽了成员变量num System.out.println(num); // 输出20 } public void change2() { num = 30; // 直接操作成员变量 } }如果你想在方法里操作被遮蔽的成员变量，用this.num来显式指定。这个this关键字其实是“当前对象引用”的意思。很多教材把this讲得很玄乎，其实就是：当前正在执行的这个方法，是哪个对象调用的，this就指向谁。方法里this.num = 20就是在明确告诉编译器：改的是这个对象的num字段，不是局部变量。
理解静态变量的关键在于“共享”二字。静态变量在类加载时就分配内存，程序结束才释放，生命周期最长。做工具类、全局配置、常量定义都常用静态变量。但我也得提醒一句：别滥用静态变量存业务数据。多线程环境下静态变量是所有线程共享的，并发修改很容易出问题，无脑用static等于给自己埋雷。我们团队的要求是：静态变量只用来存常量、配置、工具状态，业务数据一律放实例变量或者方法参数里。
2.4 类型转换与自动装箱拆箱，别让隐式转换坑了你
变量声明时定了类型，但你总得让不同类型之间互相“变通”。Java的类型转换分两种：自动类型转换（隐式转换）和强制类型转换（显式转换）。
自动类型转换遵循一个原则：小范围转大范围，系统自动帮你转。int转long、float转double，没问题，因为数据不会丢失。
int num = 100; long bigNum = num; // 自动转换，没问题 double d = num; // 自动转换，没问题强制类型转换用于大范围转小范围，语法是(目标类型) 变量名。但这里有个大坑：强制转换可能丢失数据。
long bigNum = 3000000000L; // 30亿，int最大才21亿多 int intNum = (int) bigNum; // 强制转换后，变成一个负数或错误值，数据已丢失为什么？因为int只有32位，放不下30亿这个量级的数，强转时只保留低32位，高位直接截断。就像一个大西瓜硬要塞进一个小杯子，只能把一部分切掉扔掉。所以强制转换一定要想清楚：你确定这个值在这个范围内吗？不确定就别强转。
还有一个特别爱考的自动装箱与拆箱问题。Java给8个基本类型都配了对应的包装类：Integer、Long、Double、Boolean等。装箱就是基本类型转包装类，拆箱就是反着来。Java 5之后支持自动装箱拆箱，但正因为“自动”，新手经常会忽略包装类型的null问题：
Integer count = null; int result = count + 1; // 编译通过，但运行时报NullPointerException因为自动拆箱时，count是null，null没法拆箱，直接NPE。这种问题在把从数据库查出来的值直接做算术时极其常见。规避方案很简单：包装类型参与计算前，先判空。这个习惯我从工作第一年就养成了，十多年下来，靠它躲掉了无数次线上事故。
3. 方法：把逻辑装进盒子里
3.1 方法的定义、签名与重载，这一节是你必须背下来的基本功
前面说过，变量管“存储”，方法管“处理”。方法的核心价值在于：把一段可复用的逻辑封装起来，给它起个名字，需要的时候调用即可。不用重复写代码，这是编程走向工程化的第一步。
方法定义的完整结构：
修饰符 返回类型 方法名(参数列表) { // 方法体 }public static int add(int a, int b) { return a + b; }public static：修饰符，控制访问权限和归属。int：返回类型，这个方法返回一个整数。没有返回值用void。add：方法名，命名要见名知意，动词开头，驼峰风格。(int a, int b)：参数列表，调用时必须传入两个int值。
这里有一个非常重要的概念叫方法签名（Method Signature）。方法签名 = 方法名 + 参数列表（参数类型、顺序、个数）。注意：返回类型不属于方法签名的一部分。这句话很多人不理解，但它是理解“重载”的钥匙。
重载（Overload）是指：同一个类里，方法名相同，但参数列表不同（类型不同、个数不同、顺序不同，三者至少满足一个）。重载是Java编译期多态的体现，编译器根据你传的参数类型和数量，自动匹配调用哪个方法。
public class Calculator { public int add(int a, int b) { return a + b; } // 重载：参数个数不同 public int add(int a, int b, int c) { return a + b + c; } // 重载：参数类型不同 public double add(double a, double b) { return a + b; } }面试里有个经典问题：“能不能只靠返回类型不同来重载？”答案是不能，因为编译器无法判断你想调哪个。你写int result = obj.add(1, 2);的时候，如果同时有int add(int,int)和double add(int,int)，Java根本不知道你想拿哪个，编译都过不去。
还有个重载相关的细节：参数顺序不同也可以构成重载。比如add(int a, double b)和add(double a, int b)是两个不同签名。但实际工作中我不建议这么干，太容易让人混淆，代码可读性很差。
3.2 参数传递：值传递 vs 引用传递，这是Java最大的坑之一
网上关于“Java到底是值传递还是引用传递”的争论，从Java诞生就没停过。我直接给结论：Java只有值传递（Pass by Value）。但这里的“值”分两种情况：基本类型传递的是“数据值本身”，引用类型传递的是“引用地址的值”。很多人的困惑在于：引用类型在方法里改了对象的属性，外面能看到变化，这不是引用传递吗？
其实不是的。引用传递的意思是“把变量本身传进去，方法里重新给变量赋值会影响外面的变量”。而Java里，你传引用类型参数时，传的是引用的“拷贝”，方法里对这个引用重新赋值（指向新对象），外面的变量不受影响。
public class Test { public static void main(String[] args) { StringBuilder sb = new StringBuilder("hello"); changeValue(sb); System.out.println(sb.toString()); // 输出：hello world，对象内容变了 StringBuilder sb2 = new StringBuilder("hello"); changeReference(sb2); System.out.println(sb2.toString()); // 输出：hello，sb2还是指向原来的对象 } public static void changeValue(StringBuilder s) { s.append(" world"); // 通过引用修改对象内容，外部可见 } public static void changeReference(StringBuilder s) { s = new StringBuilder("completely new"); // 重新赋值，外部不可见 } }这个例子建议反复敲几遍。很多人工作两三年了还在这里翻车，尤其是做参数校验、缓存更新这类场景时，容易把引用重新赋值的事搞混。
我再提供一个更直观的理解方式：把变量想成一张写着地址的纸条，方法调用时，是把纸条复印了一份传给方法。方法拿复印件去“按照地址找到那间房子，往里面放东西”，外面的人能看到房子里多了东西；但方法如果“把复印件上的地址改成一个新地址”，外面那张原纸条上的地址没有任何变化。
3.3 返回值、void与return，写清楚比写“能用”重要十倍
方法的返回值用来把处理结果交回调用方。返回类型是void时，方法不返回任何值，只做操作，比如打印日志、修改传入对象的属性。return关键字有两个作用：返回结果并结束方法；直接结束方法（void方法中）。
public int getResult(int x) { if (x < 0) { return -1; // 提前返回，后面代码不再执行 } return x * 2; }我写代码有个习惯：方法尽量只有一个出口（Single Return Principle），虽然Java不像C++那样强制，但多出口方法在复杂业务里真的很难维护。为什么？因为每多一个return，读代码的人就得多记一条分支。不过也别走极端，像上面这种简单的条件判断，提前return反而更清晰。关键是把度把握好：逻辑简单、分支一眼能看完时，提前return完全没问题；逻辑复杂、层叠嵌套时，尽量把判断收敛。
返回值相关的还有一个新手容易忽视的点：返回可变对象时要小心外部修改。比如你写了一个getList()方法，返回内部的List，外部拿到后直接add元素，你的内部数据就被污染了。安全做法是返回Collections.unmodifiableList(list)或者返回副本。这个坑我在重构老项目时踩过无数次，经常查半天才发现是某个get方法把内部集合暴露了。
3.4 静态方法与实例方法：用错的后果比你想的严重
用static修饰的方法是静态方法，也叫类方法，归属于类本身，不依赖任何对象就可以调用。实例方法是归属于对象的方法，必须先new对象再调用。
public class MathUtils { public static int add(int a, int b) { return a + b; } } public class Student { public String getName() { return "张三"; } } // 调用方式 MathUtils.add(1, 2); // 静态方法，直接通过类名调用 Student s = new Student(); s.getName(); // 实例方法，必须先new关键规则是：静态方法里不能直接访问实例成员变量和实例方法。因为静态方法不依赖于对象，而实例成员是对象的属性，你都没有对象怎么拿属性？反过来，实例方法里可以直接访问静态变量和静态方法，因为静态成员对所有对象共享。
这里有个实际工作中的教训：别在静态方法里用“实例字段”做缓存。我见过有人写个静态工具类，里面搞了个HashMap当缓存，结果多线程环境下数据全乱了。静态方法是无状态的，强行加状态就是在自找麻烦。如果要缓存，用专门的缓存组件或者用static final的不可变常量，别用static的普通集合对象。
4. 变量和方法结合：从需求到代码的完整实战
4.1 实战案例：设计一个“学生成绩管理系统”的迷你版
理论讲再多，不如写个看着有完整业务感的例子。我们来做一个迷你版的学生成绩管理，核心需求就三条：
- 能录入一个学生的姓名、数学成绩、语文成绩。
- 能计算这个学生的总分、平均分。
- 能打印成绩单。
这个需求虽然简单，但它完整覆盖了：类定义、成员变量、静态变量、构造方法、普通方法、静态方法、封装、对象创建。非常适合入门练手。
先定义Student类：
public class Student { // 成员变量：每个学生对象独有一份 private String name; private double mathScore; private double chineseScore; // 静态变量：所有学生共享，用来记录创建了多少个学生对象 private static int studentCount = 0; // 构造方法：创建对象时调用，完成初始化 public Student(String name, double mathScore, double chineseScore) { this.name = name; this.mathScore = mathScore; this.chineseScore = chineseScore; studentCount++; // 每创建一个学生，计数加1 } // 实例方法：计算总分，依赖当前对象的成绩数据 public double getTotalScore() { return this.mathScore + this.chineseScore; } // 实例方法：计算平均分 public double getAverageScore() { return getTotalScore() / 2.0; } // 静态方法：获取学生总数，不依赖任何对象 public static int getStudentCount() { return studentCount; } // 实例方法：打印学生信息 public void printReport() { System.out.println("姓名：" + this.name); System.out.println("数学：" + this.mathScore + "，语文：" + this.chineseScore); System.out.println("总分：" + getTotalScore() + "，平均分：" + getAverageScore()); } }再写一个测试类：
public class Main { public static void main(String[] args) { Student s1 = new Student("张三", 90, 85); Student s2 = new Student("李四", 78, 92); s1.printReport(); System.out.println("---"); s2.printReport(); System.out.println("---"); System.out.println("学生总数：" + Student.getStudentCount()); } }运行效果：
姓名：张三 数学：90.0，语文：85.0 总分：175.0，平均分：87.5 --- 姓名：李四 数学：78.0，语文：92.0 总分：170.0，平均分：85.0 --- 学生总数：2这个例子你要仔细感受几个点：
第一，成员变量是每个对象独立的数据。张三的数学成绩和李四的数学成绩互不干扰，都是各自对象的字段。这就是变量按对象隔离的核心思想。
第二，静态变量是全局共享的。studentCount不属于某个具体学生，而是属于Student这个类本身。所以用Student.getStudentCount()来访问，而不是s1.getStudentCount()——语法上实例也能调静态方法，但不推荐，因为语义上静态方法就不该绑定在某个对象上。
第三，方法内部通过this访问成员变量。我们前面聊过变量遮蔽，这里不用 this 也行，因为参数名和字段名不同。但假如构造方法写成public Student(String name, double mathScore, double chineseScore)，参数名和字段名一致，你就必须用this.name = name来区分“赋值给字段”和“赋值给参数”。
4.2 变量和方法的协作：代码重构的第一课
上面的Student类已经能干活了，但作为一个有经验的人，我还想再进一步：把“打印成绩单”和“计算成绩”分离。为什么？因为一个方法只做一件事，是最容易维护的代码结构。
我看到新手写代码最常见的毛病，就是在一个方法里干三件事：算总分、算平均分、拼字符串、打印、还顺便写了日志。这一坨逻辑，改起来牵一发动全身。更合理的做法是把计算逻辑放在核心方法里，打印逻辑单独提炼：
public String buildReport() { return String.format("姓名：%s\n数学：%.1f，语文：%.1f\n总分：%.1f，平均分：%.1f", this.name, this.mathScore, this.chineseScore, getTotalScore(), getAverageScore()); }把打印改成返回一个字符串，让调用方决定是打印到控制台还是写到文件还是存数据库。这样Student类就彻底跟“输出方式”解耦了。方法的职责边界清晰，是比写出能跑的代码重要得多的能力。一线开发每天最花时间的不是写新代码，而是读别人的代码。方法职责清晰，读起来就像看目录；职责混乱，读起来就像猜谜。
4.3 经典面试题的变形：基于这个案例能考出哪些花样
这个Student案例其实是很多面试题的母版。我梳理几个常见变形，帮大家对面试有个概念：
问题一：Student.getStudentCount()和s1.getStudentCount()有什么区别？
功能上没有区别，因为静态方法属于类，两种写法都能访问。但s1.getStudentCount()这种写法是危险的，它给读者传递了一个错误信号：这个方法依赖对象s1的状态。如果有一天你在静态方法里访问了实例字段，而调用方用的是s1.静态方法()这种写法，代码可能会出问题（本质上还是不能访问，编译过不去）。所以业界约定：静态方法一律通过类名调用，绝不通过实例调用。
问题二：如果我在printReport方法里写name而不写this.name，会怎样？
如果方法内没有同名的局部变量，那么编译时name会自动绑定到成员变量，输出结果相同。这个语法糖就是隐式this。但如果方法里突然冒出来一个局部变量也叫name，行为就变了。所以我的习惯是，在实例方法中访问成员变量时显式写this，能避免遮蔽问题，更关键的是能明确告诉读代码的人：这是字段，不是局部变量。
问题三：能不能把studentCount改成实例变量？
能，但语义就变了。改成实例变量后，每个学生对象各有一个count字段，初始值都是0（或显式初始化），创建对象时只会给自己那个count+1，永远都是1。除非你逻辑上就是想记录“每个学生自己的一些计数”，否则这就是个逻辑bug。这类题目考的就是静态变量和实例变量的区别。
5. 写代码时必踩的坑：变量与方法的实战排雷
5.1 变量相关的高频问题速查
| 问题表现 | 根本原因 | 解决方式 |
|---|---|---|
| 编译报错“Variable might not have been initialized” | 局部变量使用前未初始化 | 声明时赋默认值，或在使用前确保所有路径都已赋值 |
| 运行时报NullPointerException | 包装类型变量为null，自动拆箱失败 | 参与计算前判空，或使用Optional |
| 输出的值跟预期不符，像是“另一个变量” | 变量遮蔽，局部变量跟成员变量同名 | 实例方法中用this显式访问成员变量 |
| 改了对象的值，另一个变量也变了 | 引用类型赋值拷贝的是引用，两个变量指向同一对象 | 需要独立数据时显式创建新对象/拷贝数组/拷贝集合 |
| 静态变量值被莫名其妙改了 | 所有对象共享同一个静态变量，一处修改处处可见 | 静态变量只存常量和配置，别存会变的业务数据 |
5.2 方法相关的高频问题速查
| 问题表现 | 根本原因 | 解决方式 |
|---|---|---|
| 编译报错“duplicate method” | 方法名相同、参数列表也相同，即使返回类型不同也不能重载 | 修改参数列表，或修改方法名 |
| 方法里改了传入对象的属性，调用方数据变了 | 引用类型参数传的是引用，方法内修改会影响外部对象 | 不是bug，是特性。想阻止外部修改，可传入副本或使用不可变对象 |
| 静态方法里无法访问实例变量 | 静态方法不依赖对象，而实例变量属于对象 | 把方法改成实例方法，或把需要的数据作为参数传入 |
| 调用方法时实参和形参类型对不上 | 类型不匹配，或类型范围不能自动转换 | 检查类型，需要时做强制转换但注意数据丢失 |
5.3 一处隐蔽到让人抓狂的String陷阱
字符串比较，是Java新手甚至一些资深开发都容易踩坑的地方。我先直接给结论：字符串内容比较用equals()，不要用==。
String s1 = new String("hello"); String s2 = new String("hello"); System.out.println(s1 == s2); // false：两个对象地址不同 System.out.println(s1.equals(s2)); // true：内容相同 String s3 = "hello"; String s4 = "hello"; System.out.println(s3 == s4); // true：两个字面量指向常量池中的同一个对象第一组例子好理解，两个new出来的对象，地址肯定不同。第二组例子为啥是true？因为Java有一个字符串常量池的机制：用双引号直接写字符串字面量时，JVM会先检查常量池里有没有内容相同的字符串，有就直接复用。所以s3和s4指向同一个对象。
但问题在于：如果你用String s5 = new String("hello")，它也会先查常量池，发现已经有“hello”了，但还是会new一个独立对象出来。所以s5和s3指向的两个不同的对象。
这里要记住两条实用经验：第一，字符串内容比较一律用equals()，别用==。第二，拼接字符串时，+操作在底层会创建新的String对象，拼接多了性能差且产生大量垃圾对象。你可能会觉得“只是几个字符串而已”，但请看这个场景：
public String buildSql(List<String> ids) { String sql = "SELECT * FROM user WHERE id IN ("; for (int i = 0; i < ids.size(); i++) { if (i > 0) sql += ", "; sql += "\'" + ids.get(i) + "\'"; } sql += ")"; return sql; }当ids集合有一千个元素时，每执行一次+=就会创建一个新String对象，老对象被垃圾回收，带来堆积的分配和回收开销。正确做法是用StringBuilder或StringBuffer：
public String buildSql(List<String> ids) { StringBuilder sb = new StringBuilder("SELECT * FROM user WHERE id IN ("); for (int i = 0; i < ids.size(); i++) { if (i > 0) sb.append(", "); sb.append('\'').append(ids.get(i)).append('\''); } sb.append(')'); return sb.toString(); }单线程用StringBuilder，多线程用StringBuffer（或者用局部变量就别担心线程安全问题）。这个优化在老代码里尤其常见，我接手过几个项目的慢SQL，排查下来发现就是这种拼接导致的额外开销。虽然这不是变量方法的直接知识点，但它属于“方法内部怎么操作变量”的重要一环。
5.4 命名规范：变量和方法的名字，就是你代码的说明书
最后想认真聊聊命名这件事。很多人觉得命名不重要，能跑就行。我工作时间越长越清楚：代码写给人看的，顺便给机器执行。变量和方法的名字，是你写给未来同事（包括三个月后的自己）的说明书。
Java社区有约定俗成的命名规范：
- 变量名：小驼峰，比如
studentName、totalScore、maxRetryCount。有意义、有业务含义。别用s、x、temp这种毫无信息量的名字。 - 方法名：小驼峰，动词开头，比如
getTotalScore()、printReport()、calculateAverage()。命名要能准确描述方法行为。 - 常量：全大写加下划线，比如
MAX_RETRY_COUNT、DEFAULT_TIMEOUT。 - 类名：大驼峰，比如
StudentManager、HttpClientUtils。
一个好变量名能省掉大量注释。举个例子：
public boolean check(int a, int b) { // 这个方法是干嘛的？a和b是啥？返回值啥意思？猜去吧 }同样的逻辑，改成这样：
public boolean isAdultByAge(int age, int legalAge) { return age >= legalAge; }不用一个注释，意思一目了然。命名这东西不花钱，但价值极高。我面试别人的时候，只要看到变量名是a、b、c这种，基本直接扣分——不是说不能用，但在工程代码里这就是态度问题。写代码的第一读者是三个月后的自己，请对自己的同事友好一点。
关于变量和方法这块，我现在带新人时最爱说的一句话是：“你写的每一行代码，其实都是在对变量做操作，对方法做调用。把这两个基本功练扎实，后面学什么都快。”确实是这样，Java里那些看起来高大上的框架和技术，底层全是对象的创建、变量的赋值、方法的调用。SSH、SSM、SpringBoot，剥到最后都是这些最基础的东西。
如果读完这篇，你能理解变量的内存语义、方法的重载规则、值传递的本质、以及变量遮蔽这个坑，那我这些年的经验就没白写。Java学习路上没有捷径，但基础打牢了，后续的每一步都会顺畅很多。
查询的优化实战)
