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 to model a public library that tracks books and members.

题目。勾画一个类，用于建模一个跟踪藏书与会员的公共图书馆。

Step 1. Identify nouns (attributes). A library "has" a name and a collection of books. A book has a title and an ISBN.

第 1 步：识别名词（属性）。一个图书馆"有"一个名称和一批藏书。一本书有标题和 ISBN。

Step 2. Identify verbs (behaviors). A library can add a book, check out a book to a member, return a book, list available books.

第 2 步：识别动词（行为）。图书馆可以添加一本书、把书借给会员、还书、列出可借阅的书。

Step 3. Decide what to expose. Public methods form the API (addBook, checkOut). Private helpers do internal work. Instance variables are always private.

第 3 步：决定对外暴露什么。公有方法构成 API（addBook、checkOut）。私有辅助方法负责内部工作。实例变量永远是 private。

Step 4. Sketch the skeleton.

第 4 步：勾画骨架。

public class Library {
    private String name;
    private ArrayList<Book> books;

    public Library(String name) { /* ... *//* ... */ }
    public void addBook(Book b) { /* ... *//* ... */ }
    public boolean checkOut(String isbn) { /* ... *//* ... */ }
}

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, code published as open source under a permissive license (MIT, Apache) can be reused with attribution. Code under a copyleft license (GPL) requires that derivatives also be open-sourced. Code with no license, or a proprietary license, requires explicit permission (and often payment) before reuse.

知识产权，以宽松许可证（MIT、Apache）开源发布的代码，只要署名即可复用。以 copyleft 许可证（GPL）发布的代码，要求衍生作品也必须开源。没有许可证的代码或专有许可证下的代码，则必须在获得明确许可（通常还要付费）后才能复用。

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. Always private. 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 调用构造方法时，内存被分配，并返回一个对象引用。

Accessor (getter), returns a copy of an instance variable's value. Always non-void.

访问器（accessor / getter），返回某个实例变量（instance variable）值的副本。永远是非 void。

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. 把当前对象作为实参传给另一个方法。

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…> 这样的行为方法，使用各字段。"

You'll write this from scratch in ~25 minutes. The class is usually 25–50 lines of code. Partial credit is rubric-driven.

你要在约 25 分钟内从零写完。整个类一般有 25–50 行代码。部分给分严格按评分标准来。