3.7.1

代码逐段解读：

代码整体功能

逐段解读

类与字段

• public class Person：定义一个公开类，类名与文件名应一致（Person.java）。

• private String name;、private String email;：实例变量/字段，每个 Person 对象独有。private 体现封装，外部不能直接访问，必须通过类的方法间接使用（本例中通过 print() 或在类内部访问）。

概念小结：实例变量属于对象（实例），不是属于类本身；不同对象各有一份拷贝。

构造器

• 构造器与类同名，没有返回类型。用于初始化新建对象的状态。

• 形参 initName、initEmail 是方法作用域变量，进入构造器时存在，用来给实例变量赋值。

• 也可以写成 this.name = initName; this.email = initEmail; 更直观地区分“左边是字段，右边是参数”。

实例方法

• print() 是实例方法：必须由对象来调用（如 p.print()）。

• 实例方法体里可以直接访问实例变量 name、email，因为“当前对象（this）”隐式存在。

• 功能：把“name: email”打印到标准输出。

静态方法（关键点）

• static 表示这是类方法，属于类本身而非某个具体对象，可用 Person.printStatic(...) 直接调用。

• 静态方法不能直接访问实例变量/实例方法，因为它没有隐含的“当前对象（this）”。
解决办法：把要操作的对象当作参数传进来（这里是 Person p）。

• System.out.println(p.name);：之所以能访问 p.name，是因为当前代码在 同一个类 内，private 的限制是“对外部类不可见”，类的内部代码对自己的私有字段可见。

• p.print();：通过传入的对象调用其实例方法。

常见坑：若 p 传入的是 null，这里会抛 NullPointerException。健壮写法可先判空：

程序入口

• main 是 JVM 的程序入口，必须是 public static void main(String[] args).

• new Person("Jana", "jana@gmail.com")：在堆上创建一个 Person 对象；局部变量 p（在栈上）保存它的引用。

• p.print();：用对象调用实例方法，输出“Jana: jana@gmail.com”。

• Person.printStatic(p);：用类名调用静态方法，把 p 作为参数传入，以便静态方法能“间接”访问实例数据。

运行流程（时间线）

1. 进入 main。

2. 调用构造器创建对象：把 name="Jana", email="jana@gmail.com" 存进该对象的实例字段。

3. 执行 p.print()：打印 Jana: jana@gmail.com。

4. 执行 Person.printStatic(p)：
• 先打印提示行。
• 再打印 p.name（即 Jana）。
• 再调用 p.print()，再次打印 Jana: jana@gmail.com。

实际输出（逐行）

关键知识点回顾

• 实例 vs. 静态：
• 实例成员（变量/方法）依赖对象；静态成员属于类，不需要对象就能访问。
• 静态方法里没有隐含的 this，不能直接访问实例字段/方法；若需要，把对象当参数传入。

• 访问控制：
• private 字段对类外不可见，但在同一个类内部（包括静态方法）依然可见。

• 作用域：
• 实例变量：对象级别，随对象生命周期而在。
• 方法参数与局部变量：方法/块级作用域，方法调用时创建，结束时销毁。

• 内存模型（简要）：
• new 创建的对象在堆上；p 是栈上的引用变量，指向该堆对象。

• 健壮性建议：
• 在静态方法里使用传入对象前先判空。
• 为封装性，通常提供 getName()/getEmail()，避免在外部类直接访问字段。

可扩展示例（更稳健的静态方法）

3.7.2

代码逐段解读

类与成员

• Person：定义一个表示“人”的类。

• name / email / phoneNumber：实例变量（对象级别，每个对象各自一份），用 private 封装，外部不能直接访问。

• personCounter：静态变量（类级别，所有对象共享一份）。初始为 0，对整个类只有一份存储。

语义：personCounter 用来统计创建了多少个 Person 实例。

静态方法

• printPersonCounter() 是 静态方法，属于类本身而非某个对象。

• 静态方法可以直接访问静态变量（如 personCounter），但不能直接访问实例变量（如 name），因为调用它时可能没有具体对象上下文。

构造器

• 构造器在创建对象时被调用：把传入的 3 个参数赋值给实例变量。

• personCounter++：每当创建一个新的 Person 对象，就把类级计数加一。因为它是静态变量，所有对象共享同一计数器，所以累加是全局的。

小提示：也可以写成 this.name = initName; 等，更直观地表明在给当前对象的字段赋值；功能等价。

字符串表示

• 重写 toString()：定义对象转为字符串时的显示格式，如 Sana: sana@gmail.com 123-456-7890。

• 若用于打印对象（System.out.println(p1)），会自动调用此方法。

规范上建议加 @Override 注解，避免拼写或签名错误：

测试主方法

• p1 创建：构造器运行一次，personCounter 从 0 变为 1。

• p2 创建：构造器再运行一次，personCounter 从 1 变为 2。

• Person.printPersonCounter()：以类名调用静态方法（推荐用法）。打印当前静态计数器的值。

程序实际输出

执行流程（时间线）

1. 类加载：personCounter 初始化为 0（类级别）。

2. main 开始执行。

3. new Person("Sana", ...)：
• 赋值 name/email/phoneNumber。
• personCounter++ → 1。

4. new Person("Jean", ...)：
• 赋值 name/email/phoneNumber。
• personCounter++ → 2。

5. 调用 printPersonCounter() → 打印 Person counter: 2。

关键概念对比

• 实例变量（name/email/phoneNumber）：每个对象一份，描述“这个人”的信息。

• 静态变量（personCounter）：类共享一份，描述“这个类”的全局状态（总共创建了多少人）。

• 静态方法：不依赖具体对象，可以通过类名调用；只能直接访问静态成员。

常见问题与改进建议

1. 封装计数器
将 personCounter 设为 private，提供只读访问：
这样避免外部随意修改该计数器（例如 Person.personCounter = -999 这类破坏性操作）。

2. toString 注解
加 @Override，并考虑统一格式或掩码（例如隐藏手机号中间几位）。

3. 使用 this
在构造器里用 this.name = initName; 可读性更好，避免与局部变量混淆。

4. 线程安全（进阶）
若在多线程环境中频繁创建 Person，personCounter++ 不是原子操作，可能出现计数不准。可以用 AtomicInteger：
或在单线程应用场景保持现状即可。

5. 静态方法调用方式
虽然可以写 p1.printPersonCounter()，但不推荐。语义上它是类方法，应使用 Person.printPersonCounter()。

一句话总结

• 每创建一个 Person 对象，类级计数器 personCounter 增 1；本例创建了两次，因此最后打印 Person counter: 2。静态成员属于类，实例成员属于对象；静态方法可直接访问静态成员但不能直接访问实例成员。

3.7.4

代码逐段解读

• temperature 是 实例字段。每次 new Temperature(...) 时都会各自拥有一份。

• maxTemp 是 静态字段（类变量）。全类共享一份，不随对象而重复。

• 这里将 maxTemp 设为 public static，并初始化为 0。初始化发生在类加载时（首次使用类时）。

• 构造器在每次 new Temperature(t) 时执行：
1. 记录该对象的当前温度；
2. 用该温度与全局最高温比较，必要时更新 maxTemp。

• 因为 maxTemp 是静态字段，任何一个对象更新它，对整个类可见。

• printMax() 是 静态方法：不依赖某个具体对象，可用 Temperature.printMax() 直接调用。

• 规则：静态方法不能直接访问实例成员（例如不能写 System.out.println(temperature);），因为调用静态方法时可能根本没有任何对象存在；它只能访问静态字段或通过传入对象参数后再访问该对象的实例字段。

• 这里打印的就是共享的 maxTemp。

• 运行流程（自上而下）：
1. 类首次使用，maxTemp 被初始化为 0。
2. new Temperature(75)：temperature=75；比较 75 > 0 成立，maxTemp 更新为 75。
3. new Temperature(100)：temperature=100；比较 100 > 75 成立，maxTemp 更新为 100。
4. Temperature.printMax() 打印 100。

核心概念与要点

1. 实例 vs. 静态

• 实例字段/方法：属于对象（t1.temperature 与 t2.temperature 互不影响）。

• 静态字段/方法：属于类本身（Temperature.maxTemp 只有一份，所有对象共享）。

1. 为什么静态方法不能直接访问实例字段？

• 因为调用静态方法并不需要对象；若允许访问，会产生“没有对象却访问对象状态”的矛盾。

• 若确实需要实例数据，把对象作为参数传入，再访问其字段/方法。

1. 可通过类名调用静态成员

• Temperature.printMax() 是推荐写法；虽然语法上 t1.printMax() 也能编译，但容易误导读者以为该方法依赖 t1 的状态。

边界与潜在问题

• 初始化为 0 的陷阱：
若你创建的所有温度都是负数，例如 -5、-3，由于 maxTemp 初始为 0，比较时 t > 0 均为假，maxTemp 会错误地一直停留在 0。
解决思路：
• 把初始值设为 Double.NEGATIVE_INFINITY；或
• 在第一个对象创建时无条件赋值；或
• 使用一个“是否已初始化”的标志位。

• 封装性：
目前 maxTemp 是 public，外部代码可以随意改写：Temperature.maxTemp = -999;。这会破坏不变式。
建议将其改为 private static，并提供只读的 getter 或受控更新逻辑。

• 并发场景（进阶）：
多线程同时创建 Temperature 对象时，if (t > maxTemp) maxTemp = t; 不是原子操作，可能导致竞态条件。需要同步或使用原子更新逻辑（如 synchronized、AtomicDouble 替代等）。单线程/教学示例可忽略。

3.7.6

概念要点

• 类与静态成员（static）
• numVerses 是一个public static int，属于类 Song 本身，而不是某个对象。整个程序只有这一份拷贝，所有静态方法读写的都是同一个计数器。
• chorus() 与 verse(...) 都是静态方法，可以用 Song.方法名(...) 直接调用，不需要创建 Song 的实例。

• 参数化输出
• verse(String number, String action) 把“第几只蚂蚁（one/two/three）”和“小家伙做了什么动作（suck his thumb / tie his shoe / climb a tree）”作为参数，从而用一段模板生成不同段落（verse）。

代码如何运行（执行流程）

1. 进入 main：
• System.out.println(Song.numVerses); 由于 numVerses 初值是 0，先打印一行 0。

2. 第一次调用 Song.verse("one", "suck his thumb")：
• numVerses++ → 从 0 变为 1。
• 打印行首的当前段号：1。
• 连续打印 3 行 “The ants go marching one by one ...” 的歌词结构（前两行带 “hurrah, hurrah”，第三行不带）。
• 打印小家伙的动作行：The little one stops to suck his thumb。
• 调用 chorus() 打印两行副歌（包括 4 个 “BOOM!”）。

3. 第二次调用 Song.verse("two", "tie his shoe")：
• numVerses 自增为 2，打印 2，然后与上面相同的模板，用 two/by two 与新动作生成第二段，再打印副歌。

4. 第三次调用 Song.verse("three", "climb a tree")：
• numVerses 自增为 3，打印 3，用 three/by three 与新动作生成第三段，再打印副歌。

• 行数统计：每个 verse 打印 7 行（段号 1 行 + 主歌词 4 行 + 副歌 2 行），3 段共 21 行；再加上最开始那行 0，总计 22 行。

程序的实际输出（精确到每一行）

注意：你的 chorus() 正确包含了 4 个 BOOM，能通过“副歌应为 BOOM! × 4”的测试（有些版本常见错误是只打印了 2 个 BOOM）。

设计点评与可改进处

• ✅ 静态用法正确：verse() 和 chorus() 只访问静态的 numVerses，并用 Song.方法名() 调用，符合“静态方法只能直接访问静态成员”的规则。

• ✅ 计数逻辑清晰：每调用一次 verse(...) 就自增一次 numVerses，并把当前段号打印在段首，满足“在每段开头打印当前段号”的要求。

• ✅ 参数化模板：number 与 action 让一套模板复用 3 次，减少重复。

• 🔧 封装性：numVerses 作为 public 可被外部任意修改；若希望更稳妥，考虑改成 private static 并提供只读 getter 或专用的重置方法（例如测试前 reset()）。

• 🔧 可维护性：如果今后需要更多段，可以把 (number, action) 放进数组，用循环驱动；副歌可提取为常量字符串，避免魔法字面量。

• 🔧 输出控制：如果评测平台严格比对，确保每行标点与空格、大小写完全一致；目前代码已符合给定期望。