AP CSA — Unit 3: Class Creation

Q1MEDIUM AP MC 3.9 this Keyword [1]

Consider the following constructor.考虑以下构造方法（constructor）。

public class Box {
  private int size;
  public Box(int size) {
    this.size = size;
  }
}

What does the statement this.size = size; do?语句 this.size = size; 的作用是什么？

(A) Assigns the value of the parameter size to the instance variable size.将参数 size 的值赋给实例变量（instance variable） size。
(B) Assigns the parameter size to itself; the instance variable is unaffected.把参数 size 赋给它自己；实例变量不受影响。
(C) Causes a compile-time error because the parameter and instance variable have the same name.出现编译错误，因为参数与实例变量同名。
(D) Creates a new local variable named size that is discarded.创建一个名为 size 的新局部变量然后被丢弃。

Q2MEDIUM AP MC 3.7 static Variables [1]

Which of the following statements about a static variable declared in a Java class is true?下列关于 Java 类中 static 变量的描述，哪一项是正确的？

(A) Each instance of the class has its own independent copy.该类的每个实例都拥有各自独立的一份。
(B) It is automatically initialized to null regardless of its declared type.无论声明类型为何，都会被自动初始化为 null。
(C) A single copy is shared by all instances of the class.所有实例共享同一份变量（类级别变量 class-level variable）。
(D) It can only be read, never modified, after initialization.初始化后只能被读取、不能被修改。

Q3MEDIUM AP MC 3.4 Default Constructor [1]

Consider a Java class that declares no constructors of its own. Which of the following is true?假设某个 Java 类没有声明任何自定义的构造方法（constructor）。下列哪一项是正确的？

(A) The class cannot be instantiated.该类无法被实例化。
(B) The compiler provides a no-argument default constructor with an empty body.编译器会自动提供一个无参、方法体为空的默认构造方法（default constructor）。
(C) The class will fail to compile.该类无法通过编译。
(D) The class can only be used as a static utility class.该类只能用作静态工具类。

Q4HARD AP MC 3.6 Aliasing + compound assignment [1]

Consider the following class and code.考虑以下类与代码。

public class Box {
  public int n;
  public Box(int n) { this.n = n; }
}

// in main:
Box a = new Box(5);
Box b = a;
b.n = 10;
a.n += b.n;
System.out.println(a.n + " " + b.n);

What is printed?输出是什么？（注意 b = a; 之后 a 与 b 是别名 aliasing，指向同一个对象。）

(A) 5 10
(B) 15 10
(C) 20 10
(D) 20 20

Q5HARD AP MC 3.7 static aggregate + instance mutator [1]

Consider the following class.考虑以下类。

public class Sensor {
  private static int total = 0;
  private int reading;
  public Sensor(int r) { reading = r; total += r; }
  public void update(int r) {
    total -= reading;
    reading = r;
    total += r;
  }
  public static int total() { return total; }
}

// in main:
Sensor s1 = new Sensor(10);
Sensor s2 = new Sensor(20);
s1.update(50);
s2.update(0);
System.out.println(Sensor.total());

What is printed?输出是什么？（注意 static 聚合变量与实例修改器 mutator 在每次 update 中如何维持总和。）

(A) 30
(B) 50
(C) 70
(D) 80

Q6HARD AP MC 3.8 Missing this. Trap [1]

Consider the following class.考虑以下类。

public class Point {
  private int x;
  public Point(int x) {
    x = x;        // note: no this.
  }
  public int getX() { return x; }
}

// in main:
Point p = new Point(7);
System.out.println(p.getX());

What is printed (or what happens)?输出是什么（或会发生什么）？（注意构造方法中没有写 this.。）

(A) 0
(B) 7
(C) -1
(D) A compile-time error: self-assignment is not allowed.编译错误：自赋值不被允许。

Q7HARD AP MC 3.6 Reassigning a ref param vs mutating [1]

Consider the following class and methods.考虑以下类与方法。

public class Box {
  public int n;
  public Box(int n) { this.n = n; }
}

public static void replace(Box b) {
  b = new Box(99);
}

public static void mutate(Box b) {
  b.n = 99;
}

// in main:
Box one = new Box(1);
Box two = new Box(2);
replace(one);
mutate(two);
System.out.println(one.n + " " + two.n);

What is printed?输出是什么？（关键区别：replace 重新赋值本地引用 reassign reference，mutate 通过引用就地修改对象 mutate via reference。）

(A) 1 2
(B) 1 99
(C) 99 99
(D) 99 2

Q8HARD AP MC 3.5 Mutator order with conditional cap [1]

Consider the following class.考虑以下类。

public class Score {
  private int v;
  public Score(int v) { this.v = v; }
  public void add(int n) { v += n; }
  public void cap(int max) { if (v > max) v = max; }
  public int get() { return v; }
}

Score s = new Score(10);
s.add(20);
s.cap(15);
s.add(5);
s.cap(50);
System.out.println(s.get());

What is printed?输出是什么？（按顺序逐步执行每个修改器调用，注意 cap 仅当超过 max 时才裁剪。）

(A) 15
(B) 20
(C) 30
(D) 35

Q9HARD AP MC 3.5 Fluent interface (return this) [1]

Consider the following class.考虑以下类。

public class Counter {
  private int n;
  public Counter()       { n = 0; }
  public Counter inc()   { n++; return this; }
  public Counter dec()   { n--; return this; }
  public int peek()      { return n; }
}

Counter c = new Counter();
int x = c.inc().inc().inc().dec().peek();
System.out.println(x + " " + c.peek());

What is printed?输出是什么？（每个修改器 return this;，构成链式接口 fluent interface，所有方法调用作用于同一个对象。）

(A) 0 2
(B) 2 0
(C) 2 2
(D) 4 4

Q10HARD AP MC 3.6 Object Equality (==) [1]

Consider the following class and code.考虑以下类与代码。

public class Pt {
  public int x, y;
  public Pt(int x, int y) { this.x = x; this.y = y; }
}

Pt p = new Pt(1, 2);
Pt q = new Pt(1, 2);
Pt r = p;
System.out.println((p == q) + " " + (p == r));

What is printed?输出是什么？（提示：== 比较对象的引用地址 reference equality，而不是字段值。）

(A) true true
(B) false true
(C) true false
(D) false false

Q11HARD AP MC 3.8 Local Variable Shadows [1]

Consider the following class.考虑以下类。

public class Tank {
  private int level = 100;
  public void drain() {
    int level = 0;     // local declaration
    level -= 10;
  }
  public int getLevel() { return level; }
}

Tank t = new Tank();
t.drain();
System.out.println(t.getLevel());

What is printed?输出是什么？（注意 drain 中重新声明了局部 level，会"遮蔽" shadow 同名实例变量。）

(A) 90
(B) 100
(C) -10
(D) 0

Q12HARD AP MC 3.7 static Accessing Instance [1]

Consider the following class declaration.考虑以下类的声明。

public class Counter {
  private int count = 0;
  public static int getCount() {
    return count;
  }
}

What is the result of attempting to compile and run this class?尝试编译并运行此类的结果是什么？

(A) It compiles and works correctly.能正确编译并运行。
(B) It compiles, but getCount() always returns 0.能编译，但 getCount() 永远返回 0。
(C) A compile-time error: a non-static field cannot be referenced from a static context.编译错误：非静态字段无法从静态上下文（static context）中访问。
(D) A run-time error: NullPointerException on the call to getCount().运行时错误：调用 getCount() 时抛出 NullPointerException。

Q13HARD AP MC 3.3 Encapsulation Access [1]

Consider the following class.考虑以下类。

public class Person {
  private String name;
  public Person(String name) { this.name = name; }
}

From a different class in the same package, a programmer writes:在同一个包中的另一个类里，某程序员写下：

Person p = new Person("Alice");
p.name = "Bob";   // line X

What happens at line X?在 line X 处会发生什么？（提示：private 字段的可见性 visibility。）

(A) It compiles; p.name is now "Bob".能通过编译；p.name 现在为 "Bob"。
(B) It compiles, but the assignment is silently ignored.能通过编译，但赋值被悄悄忽略。
(C) A compile-time error: name has private access in Person.编译错误：name 在 Person 中是私有访问（private access）。
(D) A run-time IllegalAccessException is thrown.运行时抛出 IllegalAccessException。

Q14HARD AP MC 3.6 Primitive vs Object Params [1]

Consider the following class and code.考虑以下类与代码。

public class Wrap {
  public int n;
  public Wrap(int n) { this.n = n; }
}

public static void modify(int x, Wrap w) {
  x   = 999;
  w.n = 999;
}

// in main:
int x = 5;
Wrap w = new Wrap(5);
modify(x, w);
System.out.println(x + " " + w.n);

What is printed?输出是什么？（提示：基本类型按值传递 pass by value，对象引用传的是地址副本——可以通过它修改对象，但重新赋值给参数本身不影响调用方。）

(A) 5 5
(B) 999 999
(C) 5 999
(D) 999 5

Q15HARD AP MC 3.7 static seq + aliasing + toString [1]

Consider the following class and code.考虑以下类与代码。

public class Tag {
  private static int seq = 0;
  private String label;
  private int id;
  public Tag(String label) {
    this.label = label;
    this.id = ++seq;
  }
  public String toString() { return "#" + id + ":" + label; }
}

// in main:
Tag a = new Tag("alpha");
Tag b = new Tag("beta");
Tag c = a;
a = new Tag("alpha");
System.out.println(a + " " + b + " " + c);

What is printed?输出是什么？（注意每个构造方法都会预增 ++seq，然后注意 c = a; 此时 a 仍然指向哪个对象。）

(A) #1:alpha #2:beta #1:alpha
(B) #3:alpha #2:beta #3:alpha
(C) #3:alpha #2:beta #1:alpha
(D) #1:alpha #2:beta #3:alpha

FRQ 2HARD CLASS DESIGN 3.3 / 3.4 / 3.5 / 3.8 [7 pts]

A vending machine is made up of independent slots. Each slot sells copies of a single item at a fixed price and keeps a running total of the money it has taken in. You will write a complete VendingSlot class to represent one such slot. All prices and amounts of money are whole numbers of cents.一台自动售货机由若干彼此独立的货道组成。每条货道以固定价格出售同一种商品，并持续累计自己已收取的金额。你需要编写一个完整的 VendingSlot 类来表示这样一条货道。所有价格与金额均为整数分（cent）。

A slot must keep track of exactly three things, and none of them may be readable or writable from outside the class:每条货道必须恰好记录以下三项内容，且它们都不得能够从类的外部被读取或修改：

• the name of the item it sells所售商品的名称
• the unit price of that item, in cents该商品的单价（单位：分）
• the total money collected so far, in cents迄今已收取的总金额（单位：分）

The class must support exactly the following constructor and method.该类必须恰好支持下列构造方法与方法。

Constructor / Method构造方法 / 方法 Description说明

VendingSlot(String itemName, int unitPrice) Creates a slot that sells the item called itemName at unitPrice cents each. A newly created slot has collected no money at all.
Precondition: unitPrice >= 0.创建一条货道，以每件 unitPrice 分的价格出售名为 itemName 的商品。新创建的货道尚未收取任何金额。
前置条件：unitPrice >= 0。

int sell(int quantity) Records the sale of quantity items from this slot.
The cost of the sale is quantity multiplied by the slot’s unit price. The method adds that cost to the total money this slot has collected, and returns the cost.
Precondition: quantity >= 0.记录本货道售出 quantity 件商品这一笔交易。
本笔交易的金额为 quantity 与该货道单价之积。该方法把这笔金额累加到货道已收取的总金额中，并返回这笔金额。
前置条件：quantity >= 0。

Constructor / Method构造方法 / 方法	Description说明
`VendingSlot(String itemName, int unitPrice)`	Creates a slot that sells the item called `itemName` at `unitPrice` cents each. A newly created slot has collected no money at all. Precondition: `unitPrice >= 0`.创建一条货道，以每件 `unitPrice` 分的价格出售名为 `itemName` 的商品。新创建的货道尚未收取任何金额。前置条件：`unitPrice >= 0`。
`int sell(int quantity)`	Records the sale of `quantity` items from this slot. The cost of the sale is `quantity` multiplied by the slot’s unit price. The method adds that cost to the total money this slot has collected, and returns the cost. Precondition: `quantity >= 0`.记录本货道售出 `quantity` 件商品这一笔交易。本笔交易的金额为 `quantity` 与该货道单价之积。该方法把这笔金额累加到货道已收取的总金额中，并返回这笔金额。前置条件：`quantity >= 0`。

The following table shows the required behavior for a slot created by VendingSlot slot = new VendingSlot("Pretzels", 125); when the calls are made in the order shown.下表给出由 VendingSlot slot = new VendingSlot("Pretzels", 125); 创建的货道，在按表中顺序依次调用时所要求的行为。

Statement语句	Value returned返回值	Total money collected afterwards执行后已收取的总金额
(just after construction)（刚创建时）	—	0
`slot.sell(2)`	250	250
`slot.sell(1)`	125	375
`slot.sell(0)`	0	375
`slot.sell(4)`	500	875

7 pts分 Write the complete VendingSlot class. Your implementation must include the class header, all necessary instance variables, the constructor, and the sell method, and must produce the results shown in the table.编写完整的 VendingSlot 类。你的实现必须包含类头、所有必要的实例变量、上述构造方法以及 sell 方法，并且必须产生表中所示的结果。

The money collected accumulates across calls — each sale adds to the previous total rather than replacing it. Note also that sell returns the cost of that one sale, not the running total.已收取的金额在多次调用之间不断累积 — 每笔交易都是在此前总额的基础上增加，而非将其覆盖。另请注意，sell 返回的是该单笔交易的金额，而不是累计总额。

Check solution →查看解析 →

Class Creation类的创建

Multiple Choice选择题（`Multiple Choice`）

Free-Response Question自由回答题（`Free Response`）

Class Creation类的创建

Multiple Choice选择题（Multiple Choice）

Free-Response Question自由回答题（Free Response）

Multiple Choice选择题（`Multiple Choice`）

Free-Response Question自由回答题（`Free Response`）