Reading 12: 接口、泛型与枚举（Interfaces, Generics, Enums）

/**
 * MyString represents an immutable sequence of characters.
 */
public interface MyString {

    // We'll skip this creator operation for now
    // /**
    //  * @param b a boolean value
    //  * @return string representation of b, either "true" or "false"
    //  */
    // public static MyString valueOf(boolean b) { ... }

    /**
     * @return number of characters in this string
     */
    public int length();

    /**
     * @param i character position (requires 0 <= i < string length)
     * @return character at position i
     */
    public char charAt(int i);

    /**
     * Get the substring between start (inclusive) and end (exclusive).
     * @param start starting index
     * @param end ending index. Requires 0 <= start <= end <= string length.
     * @return string consisting of charAt(start)...charAt(end-1)
     */
    public MyString substring(int start, int end);
}

class SimpleMyString implements MyString {   // 也可以放在独立的 SimpleMyString.java 中

    private char[] a;

    /**
     * Create a string representation of b, either "true" or "false".
     * @param b a boolean value
     */
    public SimpleMyString(boolean b) {
        a = b ? new char[] { 't', 'r', 'u', 'e' }
              : new char[] { 'f', 'a', 'l', 's', 'e' };
    }

    // private constructor, used internally by producer operations
    private SimpleMyString(char[] a) {
        this.a = a;
    }

    @Override public int length() { return a.length; }

    @Override public char charAt(int i) { return a[i]; }

    @Override public MyString substring(int start, int end) {
        char[] subArray = new char[end - start];
        System.arraycopy(this.a, start, subArray, 0, end - start);
        return new SimpleMyString(subArray);
    }
}

class FastMyString implements MyString {   // 原定义为 public class FastMyString implements MyString

    private char[] a;
    private int start;
    private int end;

    /**
     * Create a string representation of b, either "true" or "false".
     * @param b a boolean value
     */
    public FastMyString(boolean b) {
        a = b ? new char[] { 't', 'r', 'u', 'e' }
              : new char[] { 'f', 'a', 'l', 's', 'e' };
        start = 0;
        end = a.length;
    }

    // private constructor, used internally by producer operations.
    private FastMyString(char[] a, int start, int end) {
        this.a = a;
        this.start = start;
        this.end = end;
    }

    @Override public int length() { return end - start; }

    @Override public char charAt(int i) { return a[start + i]; }

    @Override public MyString substring(int start, int end) {
        return new FastMyString(this.a, this.start + start, this.start + end);
    }
}

/** Represents an immutable curve in the plane. */
public interface Curve {

    /** @return true if the point (x,y) lies on this curve */
    public boolean contains(double x, double y);

    /**
     * @return a curve formed by connecting this with that
     * 注意：返回类型必须是 Curve，不能写成 ArrayCurve，否则接口就不再 representation-independent。
     */
    public Curve join(Curve that);
}

/** Implementation of Curve. */
class ArrayCurve implements Curve {   // 也可以是独立的 ArrayCurve.java

    /** make a one-point curve */
    public ArrayCurve(double x, double y) { /* ... */ }

    @Override public boolean contains(double x, double y) { /* ... */ return false; }

    @Override public Curve join(Curve that) { /* ... */ return this; }

    /** extend this curve with a segment to the point (x,y) */
    public void add(double x, double y) { /* ... */ }
}

import java.util.ArrayList;
import java.util.List;

class InterfaceMethodsDemo {

    static void demo() {
        // static 方法属于接口自身：List.of() 是 List 接口里的静态方法
        List<String> names = List.of("glorp", "fleeb");

        List<String> mutable = new ArrayList<>(names);

        // default 方法：接口提供的共享实现，实现类无需自己写
        mutable.removeIf(s -> s.startsWith("g"));   // Collection 的 default 方法
        mutable.replaceAll(String::toUpperCase);    // List 的 default 方法

        System.out.println(mutable);                // [FLEEB]

        // 静态错误：接口没有 rep，不能被 new（原文举的就是 new List<String>()）
        // List<String> bad = new List<String>();
    }
}

/**
 * 原文的 MyString 接口加上创建者操作：静态工厂方法。
 * 客户端从此只看见 MyString，看不见 FastMyString。
 */
public interface MyString {

    /**
     * @param b a boolean value
     * @return string representation of b, either "true" or "false"
     */
    public static MyString valueOf(boolean b) {
        return new FastMyString(b);
    }

    /** @return number of characters in this string */
    public int length();

    /**
     * @param i character position (requires 0 <= i < string length)
     * @return character at position i
     */
    public char charAt(int i);

    /**
     * Get the substring between start (inclusive) and end (exclusive).
     * @param start starting index
     * @param end ending index. Requires 0 <= start <= end <= string length.
     * @return string consisting of charAt(start)...charAt(end-1)
     */
    public MyString substring(int start, int end);
}

class MyStringClient {
    static void demo() {
        MyString s = MyString.valueOf(true);        // 不打破抽象屏障
        System.out.println("The first character is: " + s.charAt(0));  // 't'
        System.out.println("The whole string is: " + s.substring(0, s.length()));
    }
}

/** An immutable rectangle. */
public interface ImmutableRectangle {
    /** @return the width of this rectangle */
    public int getWidth();
    /** @return the height of this rectangle */
    public int getHeight();
}

/** An immutable square: 每个正方形都真的是矩形，规格被完整满足。 */
class ImmutableSquare implements ImmutableRectangle {
    private final int side;
    /** Make a new side x side square. */
    public ImmutableSquare(int side) { this.side = side; }
    /** @return the width of this square */
    @Override public int getWidth() { return side; }
    /** @return the height of this square */
    @Override public int getHeight() { return side; }
}

/** A mutable rectangle. */
public interface MutableRectangle {
    public int getWidth();
    public int getHeight();
    /** Set this rectangle's dimensions to width x height. */
    public void setSize(int width, int height);
}

// A mutable square. 原文写作：implements MutableRectangle /* hopefully? */
class MutableSquare implements MutableRectangle {
    private int side;

    public MutableSquare(int side) { this.side = side; }

    @Override public int getWidth() { return side; }
    @Override public int getHeight() { return side; }

    /**
     * Set this square's dimensions to width x height.
     * Requires width = height.                    // ← 违法：加强了前置条件
     */
    @Override public void setSize(int width, int height) {
        if (width != height) {
            throw new IllegalArgumentException("width != height");
        }
        this.side = width;
    }
}

public class FastMyString implements MyString {
    // rep 与构造器见上文

    @Override
    public String toString() {
        String s = "";
        for (int i = 0; i < this.length(); ++i) {
            s += this.charAt(i);
        }
        return s;
    }
}

class DispatchDemo {
    static void demo() {
        FastMyString fms = new FastMyString(true);   // 这个值代表 4 字符串 "true"
        System.out.println(fms.toString());          // "true"

        Object obj = new FastMyString(true);
        System.out.println(obj.toString());          // 动态分派：仍然是 "true"
        // System.out.println(obj.length());         // 静态错误：Object 没有 length()
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;

/**
 * A mutable set.
 * @param <E> type of elements in the set
 */
public interface Set<E> {

    // example creator operation
    /**
     * Make an empty set.
     * @param <F> type of elements in the set
     * @return a new set instance, initially empty
     */
    public static <F> Set<F> make() {
        return new SimpleSet<F>();
    }

    // example observer operations

    /**
     * Get size of the set.
     * @return the number of elements in this set
     */
    public int size();

    /**
     * Test for membership.
     * @param e an element
     * @return true iff this set contains e
     */
    public boolean contains(E e);

    // example mutator operations

    /**
     * Modifies this set by adding e to the set.
     * @param e element to add
     */
    public void add(E e);

    /**
     * Modifies this set by removing e, if found.
     * If e is not found in the set, has no effect.
     * @param e element to remove
     */
    public void remove(E e);
}

/** A generic implementation that keeps its elements in a list. */
public class SimpleSet<E> implements Set<E> {

    private final List<E> elementList = new ArrayList<>();

    @Override public int size() { return elementList.size(); }

    @Override public boolean contains(E e) { return elementList.contains(e); }

    @Override public void add(E e) { if (!contains(e)) { elementList.add(e); } }

    @Override public void remove(E e) { elementList.remove(e); }

    /**
     * Picks an element from the set.
     * @return the element most recently added but not yet removed
     * @throws NoSuchElementException if set is empty
     */
    public E pick() throws NoSuchElementException {
        if (elementList.isEmpty()) {
            throw new NoSuchElementException("pick on empty set");
        }
        return elementList.get(elementList.size() - 1);
    }
}

/** Represents a mutable set of characters; rep is a String.
 * 原文只列出 contains/add 与 "// ..."；这里补全 size/remove 使其完整可编译。 */
public class CharSet implements Set<Character> {

    private String s = "";

    @Override
    public boolean contains(Character e) {
        checkRep();
        return s.indexOf(e) != -1;
    }

    @Override
    public void add(Character e) {
        if (!contains(e)) s += e;
        checkRep();
    }

    @Override
    public int size() { return s.length(); }

    @Override
    public void remove(Character e) {
        int i = s.indexOf(e);
        if (i != -1) s = s.substring(0, i) + s.substring(i + 1);
        checkRep();
    }

    /** Rep invariant: s has no repeated characters. */
    private void checkRep() {
        for (int i = 0; i < s.length(); ++i) {
            assert s.indexOf(s.charAt(i)) == i : "rep invariant violated: repeated character";
        }
    }
}

class SetDemo {
    static void demo() {
        Set<String> strings = Set.make();       // 编译器推断 Set<String>
        strings.add("glorp");
        strings.add("glorp");
        System.out.println(strings.size());     // 1

        // Set<Integer> numbers = Set.make();   // 同一份泛型实现服务另一种元素类型
        // strings.add(42);                     // 静态错误：int 不能转换为 String

        Set<Character> chars = new CharSet();   // 非泛型实现：E 已被替换为 Character
        chars.add('a');
        System.out.println(chars.contains('a'));  // true
    }
}

import java.util.HashMap;
import java.util.Map;

/**
 * 补充示例：A mutable bag (multiset)，同一元素可以出现多次。
 * @param <E> type of elements in the bag
 */
public interface Bag<E> {

    /** @param e element to add; modifies this bag by adding one occurrence of e */
    public void add(E e);

    /** @param e element to remove; if e is not found, has no effect */
    public void remove(E e);

    /** @return the total number of occurrences of all elements in this bag */
    public int size();

    /** @param e an element @return true iff this bag contains at least one occurrence of e */
    public boolean contains(E e);
}

/**
 * Rep: counts maps each element to the number of times it occurs.
 * Rep invariant: every value in counts is strictly greater than 0.
 * Abstraction function: AF(counts) = 每个元素 e 出现 counts.get(e) 次的多重集。
 * Safety from rep exposure: counts 是 private final，从不返回或别名给客户端。
 */
class MapBag<E> implements Bag<E> {

    private final Map<E, Integer> counts = new HashMap<>();

    @Override
    public void add(E e) {
        counts.put(e, counts.getOrDefault(e, 0) + 1);
        checkRep();
    }

    @Override
    public void remove(E e) {
        Integer n = counts.get(e);
        if (n == null) { return; }
        if (n == 1) { counts.remove(e); } else { counts.put(e, n - 1); }
        checkRep();
    }

    @Override
    public int size() {
        int total = 0;
        for (int n : counts.values()) { total += n; }
        return total;
    }

    @Override
    public boolean contains(E e) { return counts.containsKey(e); }

    private void checkRep() {
        for (int n : counts.values()) {
            assert n > 0 : "rep invariant violated: a count is not positive";
        }
    }
}

/** 静态工厂：客户端只看到接口，看不到 MapBag。 */
final class Bags {
    private Bags() { }                     // 不可实例化的工具类

    /** @param <F> type of elements in the bag @return a new, empty bag */
    public static <F> Bag<F> empty() { return new MapBag<F>(); }
}

/** 补充说明：擦除带来的常见限制。 */
class ErasureDemo<E> {

    // 不能写 new E[10]；只能用 Object[] 加转换，并且会得到 unchecked 警告
    @SuppressWarnings("unchecked")
    private E[] elements = (E[]) new Object[10];

    private int n = 0;

    /** @param e an element; requires n < elements.length */
    void add(E e) { elements[n++] = e; }

    /** @param index an index @return the element at index */
    E get(int index) { return elements[index]; }

    static void demo() {
        ErasureDemo<String> a = new ErasureDemo<>();
        ErasureDemo<Integer> b = new ErasureDemo<>();
        // 运行时看不到类型实参：两者的类对象完全相同
        System.out.println(a.getClass() == b.getClass());   // true

        Object obj = a;
        @SuppressWarnings("unchecked")
        ErasureDemo<Integer> lie = (ErasureDemo<Integer>) obj;  // 转换处不报错
        // lie.add(42);                                          // 之后才可能出现 ClassCastException
    }

    /** 补充说明：通配符——只读取元素的“生产者”视角，可接受 List<? extends Number>。 */
    static double sumOf(java.util.List<? extends Number> numbers) {
        double sum = 0;
        for (Number x : numbers) { sum += x.doubleValue(); }
        return sum;
    }
}

// Java 对应写法：名义子类型化（nominal subtyping）
// 必须显式声明 implements；少写这一句就是静态错误，而不是“结构兼容”。
public class AccidentalString implements MyString {
    private final String a;

    public AccidentalString(String s) { this.a = s; }

    @Override public int length() { return a.length(); }
    @Override public char charAt(int i) { return a.charAt(i); }
    @Override public MyString substring(int start, int end) {
        return new AccidentalString(a.substring(start, end));
    }
}

/** 一个真正的枚举类：有 rep、有观察者、有生产者（sp21 原文第 1540 行起）。 */
public enum Month {
    // the values of the enumeration, written as calls to the private constructor below
    JANUARY(31),
    FEBRUARY(28),
    MARCH(31),
    APRIL(30),
    MAY(31),
    JUNE(30),
    JULY(31),
    AUGUST(31),
    SEPTEMBER(30),
    OCTOBER(31),
    NOVEMBER(30),
    DECEMBER(31);

    // rep
    private final int daysInMonth;

    // enums also have an automatic, invisible rep field:
    // private final int ordinal;
    // which takes on values 0, 1, ... for each value in the enumeration.

    // rep invariant:
    //   daysInMonth is the number of days in this month in a non-leap year
    // abstraction function:
    //   AF(ordinal, daysInMonth) = the (ordinal+1)th month of the Gregorian calendar
    // safety from rep exposure:
    //   all fields are private, final, and have immutable types

    // Make a Month value. Not visible to clients, only used to initialize the constants above.
    private Month(int daysInMonth) {
        this.daysInMonth = daysInMonth;
    }

    /**
     * @param isLeapYear true iff the year under consideration is a leap year
     * @return number of days in this month in a normal year (if !isLeapYear)
     *         or leap year (if isLeapYear)
     */
    public int getDaysInMonth(boolean isLeapYear) {
        if (this == FEBRUARY && isLeapYear) {
            return daysInMonth + 1;
        } else {
            return daysInMonth;
        }
    }

    /**
     * @return first month of the semester after this month
     */
    public Month startOfNextSemester() {
        switch (this) {
            case JANUARY:
                return FEBRUARY;
            case FEBRUARY:   // cases with no break or return
            case MARCH:      // fall through to the next case
            case APRIL:
            case MAY:
                return JUNE;
            case JUNE:
            case JULY:
            case AUGUST:
                return SEPTEMBER;
            case SEPTEMBER:
            case OCTOBER:
            case NOVEMBER:
            case DECEMBER:
                return JANUARY;
            default:
                throw new RuntimeException("can't get here");
        }
    }
}

/** 原文的另一个枚举：用于注册选学期。 */
enum Semester { IAP, SPRING, SUMMER, FALL }

/** 罗盘方向；原文用它演示 switch 与枚举值。 */
enum Direction { NORTH, SOUTH, EAST, WEST }

class EnumDemo {
    /** @param day a day of the week @return true iff it is a weekend day */
    static boolean isWeekend(java.time.DayOfWeek day) {
        // 每个枚举值在内存中只有一个对象，所以 == 与 equals 等价，而且更 fail-fast
        return day == java.time.DayOfWeek.SATURDAY || day == java.time.DayOfWeek.SUNDAY;
    }

    /** @param direction a compass point @return the animal you would meet there */
    static String animalAt(Direction direction) {
        switch (direction) {
            case NORTH: return "polar bears";
            case SOUTH: return "penguins";
            case EAST:  return "elephants";
            case WEST:  return "llamas";
            default:    throw new AssertionError("unreachable");
        }
    }

    static void demo() {
        System.out.println(Month.JANUARY.ordinal());              // 0
        System.out.println(Month.JANUARY.name());                 // "JANUARY"
        System.out.println(Month.FEBRUARY.getDaysInMonth(true));  // 29
        System.out.println(isWeekend(java.time.DayOfWeek.SATURDAY));  // true
        System.out.println(animalAt(Direction.SOUTH));            // "penguins"
        // Month firstMonth = java.time.DayOfWeek.MONDAY;         // 静态错误：类型不同
    }
}

// 补充说明：以下 API 超出 6.031 原文范围。
import java.util.Collections;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.Set;

/** 原文的 Semester 枚举 + 补充的 EnumSet 用法。 */
enum Semester { IAP, SPRING, SUMMER, FALL }

class RegistrationOffice {

    /** EnumSet：位向量实现，类型安全，迭代顺序固定为声明顺序。 */
    private final EnumSet<Semester> offered =
            EnumSet.of(Semester.IAP, Semester.SPRING, Semester.FALL);

    /**
     * @param semester the semester to register for
     * @param year the calendar year
     * @throws IllegalArgumentException if semester is not offered this year
     */
    public void startRegistrationFor(Semester semester, int year) {
        if (!offered.contains(semester)) {
            throw new IllegalArgumentException("semester not offered: " + semester);
        }
        System.out.println("Registering for " + semester + " " + year);
        // 对比：客户端无法传 "FAll" 或 Month.JANUARY —— 都是静态错误
    }

    /** @return an unmodifiable view of the semesters offered this year */
    public Set<Semester> semestersOffered() {
        return Collections.unmodifiableSet(offered);   // 不暴露 rep
    }
}

/** EnumMap：为枚举键优化的映射，内部就是按 ordinal 索引的数组。 */
class DirectionSurvey {

    /** 构造时必须显式传入枚举类型对象（类型擦除）。 */
    private final EnumMap<Direction, Integer> counts = new EnumMap<>(Direction.class);

    DirectionSurvey() {
        for (Direction d : Direction.values()) {   // values()：按声明顺序的全部取值
            counts.put(d, 0);
        }
    }

    /** @param d the direction observed; modifies this survey by counting one more observation */
    void record(Direction d) {
        counts.put(d, counts.get(d) + 1);
    }

    /** @param d a direction @return the number of observations recorded in direction d */
    int count(Direction d) {
        return counts.get(d);      // 每个枚举值都已建键，不会返回 null
    }
}

/** 问题集 2 的真实结构：IntervalSet 是接口，两个实现类各有自己的 rep。 */
public interface IntervalSet<L> {

    /** @param label a label @param start start of the interval @param end end of the interval */
    public void insert(L label, long start, long end);

    /** @param label a label @return true iff this set contains label */
    public boolean contains(L label);

    /** @return a new, empty interval set; 客户端不必知道实现类是哪一个 */
    public static <L> IntervalSet<L> empty() {
        return new RepMapIntervalSet<L>();
    }
}

/** 一个实现：用 Map 做 rep（ps2 指定了它的表示）。 */
class RepMapIntervalSet<L> implements IntervalSet<L> {
    private final java.util.Map<L, long[]> intervals = new java.util.HashMap<>();
    @Override public void insert(L label, long start, long end) {
        intervals.put(label, new long[] { start, end });
    }
    @Override public boolean contains(L label) { return intervals.containsKey(label); }
}

/** 抽象类的合适用法：共享同一套测试逻辑，子类只填一个“空实例”钩子。 */
abstract class IntervalSetTest {

    /** @return a new empty instance of the implementation under test */
    protected abstract IntervalSet<String> emptyInstance();

    /** 共享的测试逻辑：对任何实现都成立。 */
    public void testInitialLabelsEmpty() {
        IntervalSet<String> set = emptyInstance();
        assert !set.contains("labelA");
    }
}

/** 子类只填空，从而把同一套测试跑在不同实现上。 */
class RepMapIntervalSetTest extends IntervalSetTest {
    @Override protected IntervalSet<String> emptyInstance() {
        return new RepMapIntervalSet<String>();
    }
}

/** 接口定义 ADT 的操作集合；规格里不能出现任何表示细节。 */
public interface LabeledSet {

    /** @param label a label @return true iff this set contains label */
    public boolean contains(String label);

    /** @param label a label; modifies this set by adding label if not already present */
    public void add(String label);

    /** @param label a label; modifies this set by removing label if present, else no effect */
    public void remove(String label);

    /** @return the number of distinct labels in this set */
    public int size();
}

/** 实现一：哈希表，查找平均 O(1)，元素无序。 */
class HashSetLabeledSet implements LabeledSet {
    private final java.util.Set<String> labels = new java.util.HashSet<>();
    @Override public boolean contains(String label) { return labels.contains(label); }
    @Override public void add(String label) { labels.add(label); }
    @Override public void remove(String label) { labels.remove(label); }
    @Override public int size() { return labels.size(); }
}

/** 实现二：有序树，单次操作 O(log n)，但可直接产出有序序列。 */
class TreeSetLabeledSet implements LabeledSet {
    private final java.util.Set<String> labels = new java.util.TreeSet<>();
    @Override public boolean contains(String label) { return labels.contains(label); }
    @Override public void add(String label) { labels.add(label); }
    @Override public void remove(String label) { labels.remove(label); }
    @Override public int size() { return labels.size(); }
    /** @return the labels in lexicographic order */
    public java.util.List<String> sortedLabels() {
        return new java.util.ArrayList<>(labels);
    }
}

class LabeledSetDemo {
    static void demo() {
        // 客户端只依赖接口：换实现只需改这一行
        LabeledSet set = new HashSetLabeledSet();
        set.add("glorp");
        set.add("glorp");
        System.out.println(set.size());        // 1

        // Java 集合类的对应事实：接口 + 多个实现
        java.util.Set<String> hashed = new java.util.HashSet<>();               // 无序，平均 O(1)
        java.util.Set<String> sorted = new java.util.TreeSet<>();               // 有序，O(log n)
        java.util.Set<String> insertionOrder = new java.util.LinkedHashSet<>(); // 保持插入顺序
        hashed.add("b"); sorted.add("b"); insertionOrder.add("b");
        System.out.println(hashed.size() + sorted.size() + insertionOrder.size());
    }
}

// 错误：客户端直接依赖具体表示类 FastMyString / SimpleMyString
class MyStringClient {

    static void demo() {
        // 客户端必须知道表示类的名字，还必须知道构造器参数代表什么含义
        FastMyString s = new FastMyString(true);     // "true"
        System.out.println("The first character is: " + s.charAt(0));

        // 另一个客户端挑了另一个表示类，两段代码无法互换
        SimpleMyString t = new SimpleMyString(false); // "false"
        System.out.println("length = " + t.length());

        // 更糟的是：两个实现的构造器签名根本不同，
        // 接口里也没有任何地方承诺“所有实现都提供同样的构造器”
    }
}

/** 客户端只依赖接口 MyString；创建者操作是接口上的静态工厂方法。 */
class MyStringClient {

    static void demo() {
        MyString s = MyString.valueOf(true);          // 只出现接口名
        System.out.println("The first character is: " + s.charAt(0));   // 't'
        System.out.println("The whole string is: "
                + s.substring(0, s.length()));        // "true"

        // 客户端无法写 new FastMyString(..)，因为它只见过 MyString 这个类型
    }
}

/** A mutable rectangle. */
interface MutableRectangle {
    int getWidth();
    int getHeight();
    /** Set this rectangle's dimensions to width x height. */
    void setSize(int width, int height);
}

// A mutable square：原文写作 implements MutableRectangle /* hopefully? */
class MutableSquare implements MutableRectangle {
    private int side;

    MutableSquare(int side) { this.side = side; }

    @Override public int getWidth() { return side; }
    @Override public int getHeight() { return side; }

    /**
     * Set this square's dimensions to width x height.
     * Requires width = height.                    // ← 更强的前置条件：违反 LSP
     */
    @Override public void setSize(int width, int height) {
        if (width != height) {
            throw new IllegalArgumentException("width != height");
        }
        this.side = width;
    }
}

class RectangleClient {
    /** 把所有矩形放大一倍——这段代码在 MutableSquare 上会崩溃。 */
    static void doubleSize(MutableRectangle r) {
        r.setSize(r.getWidth() * 2, r.getHeight() * 2);   // 可能违反正方形的前置条件
    }

    /** 只能靠 instanceof + 强转“补救”，这就是设计坏味道。 */
    static void doubleSizeSafely(MutableRectangle r) {
        if (r instanceof MutableSquare) {
            MutableSquare s = (MutableSquare) r;          // 运行时强转：危险信号
            s.setSize(s.getWidth() * 2);
        } else {
            r.setSize(r.getWidth() * 2, r.getHeight() * 2);
        }
    }
}

/** An immutable rectangle: 不可变类型没有 setSize，因此不存在“改尺寸”的分歧。 */
public interface ImmutableRectangle {
    /** @return the width of this rectangle */
    public int getWidth();
    /** @return the height of this rectangle */
    public int getHeight();
}

/** An immutable square: 每个正方形都真的是矩形，规格被完整满足。 */
class ImmutableSquare implements ImmutableRectangle {
    private final int side;
    /** Make a new side x side square. */
    public ImmutableSquare(int side) { this.side = side; }
    /** @return the width of this square */
    @Override public int getWidth() { return side; }
    /** @return the height of this square */
    @Override public int getHeight() { return side; }
}

class RectangleClient {
    /** 任何 ImmutableRectangle 都能安全参与这段计算，无需任何 instanceof。 */
    static int area(ImmutableRectangle r) {
        return r.getWidth() * r.getHeight();
    }
}

/**
 * 若确实需要可变的矩形与正方形，就不要让正方形冒充矩形：
 * 定义两个彼此独立的类型，各自提供符合自身规格的操作。
 */
interface MutableRectangle2 {
    int getWidth();
    int getHeight();
    /** Set this rectangle's dimensions to width x height. */
    void setSize(int width, int height);
}

interface MutableSquare2 {
    int getSide();
    /** Set this square's side length to side. */
    void setSide(int side);
}

import java.util.HashSet;
import java.util.Set;

/** 错误：用字符串常量模拟“学期”这一有限取值集合（原文的三种方案之一）。 */
class RegistrationOffice {

    public static final String IAP = "IAP";
    public static final String SPRING = "Spring";
    public static final String SUMMER = "Summer";
    public static final String FALL = "Fall";

    private final Set<String> offered = new HashSet<>();

    RegistrationOffice() {
        offered.add(IAP);
        offered.add(SPRING);
        offered.add(FALL);
    }

    /** @param semester the semester name @param year the calendar year */
    public void startRegistrationFor(String semester, int year) {
        if (!offered.contains(semester)) {
            throw new IllegalArgumentException("semester not offered: " + semester);
        }
        System.out.println("Registering for " + semester + " " + year);
    }
}

class BadClient {
    static void demo() {
        RegistrationOffice office = new RegistrationOffice();
        office.startRegistrationFor("FAll", 2023);    // 拼错也照样编译通过，运行时才炸
        office.startRegistrationFor("Autumn", 2023);  // 客户端“发明”了一个新学期

        Set<String> weird = new HashSet<>();
        weird.add("Fall");
        weird.add("Fall ");                           // 多一个空格就是另一个元素
        System.out.println(weird.size());             // 2
    }
}

import java.util.EnumSet;
import java.util.Set;
import java.util.Collections;

/** 正确：取值集合小而固定，用枚举而不是字符串常量（原文的第三种方案）。 */
enum Semester { IAP, SPRING, SUMMER, FALL }

class RegistrationOffice {

    /**
     * EnumSet 用法属于「补充说明（超出 6.031 原文的 Java 生态知识）」；
     * 原文只讲 enum 本身。若严格只用原文知识，可改用 Set<Semester>。
     */
    private final EnumSet<Semester> offered =
            EnumSet.of(Semester.IAP, Semester.SPRING, Semester.FALL);

    /**
     * @param semester the semester to register for
     * @param year the calendar year
     * @throws IllegalArgumentException if semester is not offered this year
     */
    public void startRegistrationFor(Semester semester, int year) {
        if (!offered.contains(semester)) {
            throw new IllegalArgumentException("semester not offered: " + semester);
        }
        System.out.println("Registering for " + semester + " " + year);   // FALL
    }

    /** @return an unmodifiable view of the semesters offered this year */
    public Set<Semester> semestersOffered() {
        return Collections.unmodifiableSet(offered);      // 不暴露 rep
    }
}

class GoodClient {
    static void demo() {
        RegistrationOffice office = new RegistrationOffice();
        office.startRegistrationFor(Semester.FALL, 2023);        // IDE 可补全，不可能拼错
        // office.startRegistrationFor(Month.JANUARY, 2023);     // 静态错误：类型不匹配
        // office.startRegistrationFor("Fall", 2023);            // 静态错误：String 不是 Semester

        // 枚举的相等性：每值唯一，所以 == 与 equals() 等价，而且更 fail-fast
        Semester s = Semester.FALL;
        System.out.println(s == Semester.FALL);                  // true
        System.out.println(Month.JANUARY.ordinal());             // 0
        System.out.println(Month.JANUARY.name());                // "JANUARY"
    }
}

import java.util.ArrayList;
import java.util.List;

/** 错误：非泛型容器，元素类型完全不受检查。 */
class ObjectSet {

    private final List<Object> elements = new ArrayList<>();

    public void add(Object e) { elements.add(e); }

    public int size() { return elements.size(); }

    public boolean contains(Object e) { return elements.contains(e); }

    /** @param i an index @return the element at index i, as an Object */
    public Object pick(int i) { return elements.get(i); }
}

class BadSetClient {
    static void demo() {
        ObjectSet set = new ObjectSet();
        set.add("glorp");
        set.add(42);                        // 编译通过：整数混进了“字符串集合”
        set.add(new int[] { 1, 2 });         // 什么都装得下

        String s = (String) set.pick(1);     // 运行时 ClassCastException！
        System.out.println(s.length());
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;

/**
 * 正确：用原文的泛型 Set<E> 把“元素类型”变成规格的一部分。
 * A mutable set.
 * @param <E> type of elements in the set
 */
public interface Set<E> {

    /**
     * Make an empty set.
     * @param <F> type of elements in the set
     * @return a new set instance, initially empty
     */
    public static <F> Set<F> make() { return new SimpleSet<F>(); }

    /** @return the number of elements in this set */
    public int size();

    /** @param e an element @return true iff this set contains e */
    public boolean contains(E e);

    /** @param e element to add; modifies this set by adding e to the set */
    public void add(E e);

    /** @param e element to remove; if e is not found in the set, has no effect */
    public void remove(E e);
}

/**
 * 泛型实现：元素存在 List<E> 里，完全不关心 E 是什么。
 * Rep invariant: elementList has no repeated elements.
 * Abstraction function: AF(elementList) = the set of elements in elementList.
 * Safety from rep exposure: elementList 是 private final，从不返回给客户端。
 */
class SimpleSet<E> implements Set<E> {

    private final List<E> elementList = new ArrayList<>();

    @Override public int size() { return elementList.size(); }

    @Override public boolean contains(E e) { return elementList.contains(e); }

    @Override public void add(E e) { if (!contains(e)) { elementList.add(e); } }

    @Override public void remove(E e) { elementList.remove(e); }

    /**
     * Picks an element from the set.
     * @return the element most recently added but not yet removed
     * @throws NoSuchElementException if set is empty
     */
    public E pick() throws NoSuchElementException {
        if (elementList.isEmpty()) { throw new NoSuchElementException("empty set"); }
        return elementList.get(elementList.size() - 1);
    }
}

class GoodSetClient {
    static void demo() {
        Set<String> strings = Set.make();   // 编译器推断 Set<String>
        strings.add("glorp");
        strings.add("glorp");
        // strings.add(42);                 // 静态错误：int 不能转换为 String
        System.out.println(strings.size()); // 1

        // 取出元素不需要强转：泛型接口的签名已经给出类型
        List<String> copy = new ArrayList<>();
        copy.add(strings.contains("glorp") ? "glorp" : "none");
        System.out.println(copy.get(0));    // glorp
    }
}