/** Represents an immutable set of elements of type E. */
    public interface Set<E> {
        /** make an empty set */
A       public Set();
        /** @return true if this set contains e as a member */
        public boolean contains(E e);
        /** @return a set which is the union of this and that */
B       public ArraySet<E> union(Set<E> that);    
    }
    /** Implementation of Set<E>. */
    public class ArraySet<E> implements Set<E> {
        /** make an empty set */
        public ArraySet() { ... }
        /** @return a set which is the union of this and that */
        public ArraySet<E> union(Set<E> that) { ... }
        /** add e to this set */
        public void add(E e) { ... }
    }

/** 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. */
public class ImmutableSquare {
    private final int side;
    /** Make a new side x side square. */
    public ImmutableSquare(int side) { this.side = side; }
    /** @return the width of this square */
    public int getWidth() { return side; }
    /** @return the height of this square */
    public int getHeight() { return side; }
}

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

/** A mutable square. */
public class MutableSquare {
    private int side;
    // ... same constructor and methods as above ...
    // TODO implement setSize(..)
}

/** Set this square's dimensions to width x height.
 *  Requires width = height. */
public void setSize(int width, int height) { ... }

/** Set this square's dimensions to width x height.
 *  @throws BadSizeException if width != height */
public void setSize(int width, int height) throws BadSizeException { ... }

/** If width = height, set this square's dimensions to width x height.
 *  Otherwise, new dimensions are unspecified. */
public void setSize(int width, int height) { ... }

/** Set this square's dimensions to side x side. */
public void setSize(int side) { ... }

/** 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);
}

public class SimpleMyString implements MyString {
    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);
    }
}

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.end + end);
    }
}

MyString s = new FastMyString(true);
System.out.println("The first character is: " + s.charAt(0));

List<String> s = new ArrayList<String>();
...

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(true);
    }
    // ...

MyString s = MyString.valueOf(true);
System.out.println("The first character is: " + s.charAt(0));

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

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

    // 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);

Set<String> set = new HashSet<String>();

set = Collections.unmodifiableSet(set);

set = Collections.singleton("glorp");

set = new Set<String>();

List<String> list = set;

public class CharSet implements Set<Character>

public interface Set<E> {
    // ...
    /**
     * Test for membership.
     * @param e an element
     * @return true iff this set contains e
     */
    public boolean contains(E e);
    /**
     * Modifies this set by adding e to the set.
     * @param e element to add
     */
    public void add(E e);
    // ...
}

public class CharSet1 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();
    }
    // ...
}

public interface Set<E> {
    // ...

public class HashSet<E> implements Set<E> {
    // ...

public class Rational {
    ...
}

public interface Rational {
    ...
}
public class IntFraction implements Rational {
    ...
}

private int numerator;
private int denominator;

//   denominator > 0
//   numerator/denominator is in reduced form

//   AF(numerator, denominator) = numerator / denominator

    /**
     * @param that another Rational
     * @return a Rational equal to (this / that)
     */

    public boolean isZero()

    return numer == 0;

public enum Month { JANUARY, FEBRUARY, MARCH, ..., DECEMBER };

Month thisMonth = MARCH;

if (day.equals(SATURDAY) || day.equals(SUNDAY)) {
    System.out.println("It's the weekend");
}

if (day == SATURDAY || day == SUNDAY) {
    System.out.println("It's the weekend");
}

switch (direction) {
    case NORTH: return "polar bears";
    case SOUTH: return "penguins";
    case EAST:  return "elephants";
    case WEST:  return "llamas";
}

Month firstMonth = MONDAY; // static error: MONDAY has type DayOfWeek, not type Month 

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 nextSemester() {
        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");
        }
    }
}

startRegistrationFor("Fall", 2023);

public static final String FALL = "Fall";
...
startRegistrationFor(FALL, 2023);

public enum Semester { IAP, SPRING, SUMMER, FALL };
...
startRegistrationFor(FALL, 2023);