Data Abstraction, separates what data represents from how it's stored. An instance variable like balance names the concept without exposing implementation.

数据抽象，将数据"代表什么"与"如何存储"分离开来。像 balance 这样的实例变量（instance variable）只为概念命名，而不暴露具体实现。

Procedural Abstraction, gives a name to a process (method). You use a method knowing what it does, not how. This enables code reuse and method decomposition.

过程抽象，为某个过程（方法）赋予名称。你只需知道方法做了什么，而不必关心如何做。这便于代码复用与方法分解。

Problem. Sketch a class that records grades, keeps a running total, and reports the average.

题目。勾画一个记录成绩、维护累计总分并报告平均分的类。

Step 1. Identify nouns (attributes). The tracker has a count and a total.

第 1 步：识别名词（属性）。这个追踪器有一个 count 和一个 total。

Step 2. Identify verbs (behaviors). It can add a grade and calculate the average.

第 2 步：识别动词（行为）。它可以添加一个成绩并计算平均分。

Step 3. Decide what to expose. Public methods form the API. Keep instance variables private unless the specification says otherwise.

第 3 步：决定对外暴露什么。公有方法构成 API。除非题目规范另有说明，否则实例变量应保持 private。

Step 4. Sketch the skeleton.

第 4 步：勾画骨架。

public class GradeTracker {
    private int count;
    private int total;

    public GradeTracker() { count = 0; total = 0; }
    public void add(int grade) { total += grade; count++; }
    public double average() { if (count == 0) return 0.0; return (double) total / count; }
}

Parameter generalization. A method written for one fixed value can be generalized by turning that value into a parameter. A countAbove90() method works for exactly one cutoff; countAbove(int cutoff) does the same job for any cutoff the caller supplies, so one method replaces many near-duplicates.

Changing internals without changing the interface. A class can change its internal representation later while preserving its constructor and method signatures. Here, add(int grade) hides whether grades are stored in a list or only summarized by count and total; callers see the same behavior.

用参数实现通用化。只针对某个固定值编写的方法，可以把该值改成形参来实现通用化。countAbove90() 只适用于一个固定分数线；countAbove(int cutoff) 则能按调用方给出的任意分数线完成同样的工作，于是一个方法就取代了许多近乎重复的方法。

改变内部实现而不改变接口。类可以在不改变构造方法和各方法签名的前提下，改变内部表示。这里 add(int grade) 隐藏了成绩究竟是存入列表，还是只用 count 与 total 做汇总；调用方看到的行为保持不变。

System Reliability, a program should perform as expected under all stated conditions, not just the happy path. Test with edge cases, invalid input, and boundary values to maximize reliability. A reliability gap is a failure for a stated condition.

系统可靠性，程序应当在所有规定条件下都按预期运行，而不仅仅是顺利路径。要用边界情况、非法输入和临界值来测试以最大化可靠性。可靠性缺口指的是在某个规定条件下出现失败。

Unintended Consequences, a program built for one purpose can cause harm outside its intended scope. A recommendation algorithm optimised for engagement can amplify misinformation; a routing app's optimum may cause traffic chaos on residential streets. The harm was not intended by the designer but emerged from the design.

意料之外的后果，为某种目的设计的程序可能在其预期范围之外造成危害。以"参与度"为目标优化的推荐算法可能放大错误信息；以最优路径为目标的导航 App 可能让住宅街道交通陷入混乱。这种危害并非设计者所期望，而是从设计中浮现出来。

Intellectual Property, AP materials describe responsible reuse: check the license, follow its terms, and give attribution where required. Permissive and copyleft licenses have different conditions, so the safe exam-ready behavior is to treat "no explicit permission" as "do not reuse" unless the problem states otherwise.

知识产权，AP 官方材料强调负责任地复用代码：查看许可证、遵守其条款，并在需要时注明出处。宽松许可证与 copyleft 许可证的条件不同，因此备考时应掌握的安全做法是：除非题目另有说明，否则“没有明确许可”就应视为“不可复用”。

Plagiarism, copying another student's submitted code (even partially, even modified) without attribution is plagiarism, a serious academic-integrity violation. Cite the source of any code you didn't write yourself, including snippets adapted from documentation or online forums.

抄袭，未署名地复制其他同学提交的代码（哪怕只是部分、哪怕做过修改）就是抄袭，属于严重的学术诚信违规。任何并非你本人编写的代码都应标注出处，包括根据文档或在线论坛改编的代码片段。

Problem. "Write a class Student with a name (String), grade (int 9–12), and methods to access each."

题目。"编写一个类 Student，包含 name（String）、grade（int 9–12），以及访问每个字段的方法。"

Step 1. Class declaration. Always public class.

第 1 步：类声明。总是写 public class。

Step 2. Instance variables. private unless the specification says otherwise. Types come from the prompt: String name, int grade.

第 2 步：实例变量。除非规范另有说明，否则使用 private。类型来自题干：String name、int grade。

Step 3. Constructor. Public. Parameters match the data the prompt says the class needs. Use this. when the parameter shadows the field.

第 3 步：构造方法。public。形参与题干所述类所需的数据一致。当形参与字段同名时，使用 this.。

Step 4. Accessors. One per private field. Return type matches the field type. Body is a single return.

第 4 步：访问器。每个私有字段一个。返回类型与字段类型一致。方法体只有一行 return。

public class Student {
    private String name;
    private int grade;

    public Student(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }

    public String getName() { return name; }
    public int getGrade() { return grade; }
}

State = the object's attributes and their current values (has-a relationship).

状态 = 对象的属性及其当前值（has-a 关系）。

When a constructor is called with new, memory is allocated and an object reference is returned.

当用 new 调用构造方法时，内存被分配，并返回一个对象引用。

Suppose the specification defines a Player's complete initial state by its name and supplies getName() plus a one-String constructor. A Roster constructor can then make its own Player without relying on an ArrayList copy constructor:

假设规范说明 Player 的完整初始状态只由姓名确定，并提供 getName() 和一个接收单个 String 的构造方法。那么 Roster 的构造方法可以创建自己的 Player，而不依赖 ArrayList 的拷贝构造方法：

public class Roster {
    private Player captain;

    public Roster(Player p) {
        captain = new Player(p.getName());
    }
}

The copied Player is a different object, but it is created only from the methods and constructors supplied by the specification.

复制出的 Player 是另一个对象，但它只使用规范所提供的方法和构造方法来创建。

Accessor (getter), returns a value associated with an instance variable. It is always non-void. For a reference field, Java returns a copy of the reference, not a new object; the specification determines whether a fresh object is required.

访问器（accessor / getter），返回与某个实例变量相关的值，并且总是非 void。对于引用字段，Java 返回的是引用的副本，而不是新对象；是否需要新对象由规范决定。

Mutator (setter), changes an instance variable's value. Usually void.

修改器（mutator / setter），修改某个实例变量的值。通常是 void。

public class Dog {
    private String name;
    public Dog(String n) { name = n; }
    public String getName() { return name; }
    public void setName(String n) { name = n; }
}

public static void rename(Dog d) {
    d.setName("Max");  // mutates the original Dog// 修改原始 Dog 对象
}

Dog rex = new Dog("Rex");
rename(rex);
System.out.println(rex.getName());  // prints: Max// 打印：Max

Why? The parameter d is a copy of the reference to the same Dog object as rex. d.setName(...) mutates that object. rex "sees" the change because both names still refer to the same heap object.

原因。形参 d 是 rex 所指 Dog 对象的引用副本。d.setName(...) 修改了该对象。rex 能"看到"这个变化，因为这两个名字仍然指向堆上同一个对象。

public static void replace(Dog d) {
    d = new Dog("Replaced");  // reassigns the LOCAL copy// 重新赋值的是本地副本
}

Dog rex = new Dog("Rex");
replace(rex);
System.out.println(rex.getName());  // prints: Rex (unchanged!)// 打印：Rex（未变！）

Why? d = new Dog(...) only changes what the local parameter d points to. The caller's rex reference is unchanged. You can't reassign your way to "replacing" the caller's object. This is the AP trap that catches the most students.

原因。d = new Dog(...) 只改变本地形参 d 所指的对象。调用方的 rex 引用并未改变。你无法靠重新赋值来"替换"调用方的对象。这是抓走最多学生的 AP 陷阱。

Dog rex = new Dog("Rex");
Dog buddy = rex;       // alias: buddy and rex refer to the SAME object// 别名：buddy 和 rex 指向同一个对象
buddy.setName("Buddy");
System.out.println(rex.getName());  // prints: Buddy// 打印：Buddy

Why? buddy = rex copies the reference, not the object. Both names refer to the same Dog object. A mutation through one is visible through the other. This is "aliasing" and is the same mechanism as passing an object to a method.

原因。buddy = rex 复制的是引用，不是对象。两个名字指向同一个 Dog 对象。通过其中一个所做的修改，通过另一个也能看到。这就是"别名（aliasing）"现象，与把对象传给方法是同一种机制。

Scope rules:

作用域（scope）规则：

Instance variables → accessible throughout the entire class.

实例变量 → 在整个类中都可访问。

Local variables → accessible only in the block where declared.

局部变量 → 只在其声明所在的代码块内可访问。

Parameters → local to their method/constructor.

形参 → 仅在其所属的方法/构造方法中有效。

public class Counter {
    private int count = 100;  // instance variable// 实例变量

    public void increment(int count) {  // parameter shadows field// 形参遮蔽字段
        count++;            // increments the PARAMETER, not the field// 自增的是形参，不是字段
        this.count++;       // increments the FIELD// 自增的是字段
    }

    public int getCount() { return count; }  // field// 字段
}

Counter c = new Counter();
c.increment(5);
                  // parameter starts at 5, becomes 6 (ignored)// 形参从 5 自增到 6（被忽略）
                  // field starts at 100, becomes 101// 字段从 100 自增到 101
System.out.println(c.getCount());  // prints: 101// 打印：101

Takeaway. Without this., a bare count inside increment refers to the parameter. The field is reachable only via this.count. This is the most common cause of "constructor doesn't seem to work" bugs.

要点。在 increment 内部，如果不加 this.，光写 count 指的是形参。字段只能通过 this.count 才能访问。这是"构造方法好像没生效"这类 bug 最常见的原因。

Common uses of this:

this 的常见用法：

1. Disambiguate instance variables from parameters with the same name.

1. 区分实例变量与同名的形参。

2. Pass the current object as an argument to another method.

2. 把当前对象作为实参传给另一个方法。

Problem. Write an isHeavierThan method for a Dog class with a private weight field, comparing the calling object against another Dog passed in.

题目。为带私有 weight 字段的 Dog 类编写 isHeavierThan 方法，把调用它的对象与传入的另一个 Dog 比较。

public boolean isHeavierThan(Dog other) {
    return this.weight > other.weight;  // this = calling object, other = parameter// this = 调用对象，other = 形参
}

Dog rex = new Dog("Rex", 30);
Dog fido = new Dog("Fido", 18);
rex.isHeavierThan(fido);  // this = rex, other = fido → true// this = rex，other = fido → true

Takeaway. Writing this.weight is optional here (no shadowing parameter named weight), but it makes explicit which object's field is on which side of the comparison — a habit that prevents mistakes once methods get more complex.

要点。这里写 this.weight 并非必需（没有同名的 weight 形参造成遮蔽），但它明确标出了比较式两侧分别是哪个对象的字段——方法变复杂后，这个习惯能避免出错。

Typical FRQ #2 prompt structure:

典型的 FRQ #2 题干结构：

"Write a class X that has <list of attributes>. Include a constructor that <assigns the attributes from parameters>. Include accessor methods <getName, getAge, ...>, mutator methods <setAge with validation>, and a behavior method <summary, isAvailable, ...> that uses the fields."

"编写一个类（class）X，它包含 <属性清单>。包含一个 <从形参为属性赋值> 的构造方法（constructor）。包含访问器方法（accessor）<getName、getAge…>、修改器方法（mutator）<带校验的 setAge>，以及一个 <summary、isAvailable…> 这样的行为方法，使用各字段。"

Read the complete specification before coding, then verify every requested attribute, constructor, method signature, precondition, and behavior.

编码前先读完整规范，再逐项核对所需属性、构造方法、方法签名、前置条件和行为。