CSCD 211

HAS-A vs IS-A

I can identify, in a class declaration, every HAS-A relationship by reading the field list, and articulate the relationship in English.Not started yet
I can identify whether a relationship is HAS-A or IS-A from the source declaration, citing the keyword that establishes each.Not started yet
I can apply Bloch's rule to a candidate design, choose HAS-A or IS-A and justify the choice in one sentence per ruled-out option.Not started yet

Association, Aggregation, Composition

I can identify a "uses-a" relationship in code by recognizing it as a method parameter or local variable rather than a field.Not started yet
I can distinguish aggregation from composition by inspecting the constructor: aggregation *receives* the reference, composition *constructs* internally.Not started yet
I can identify composition in source code by recognizing constructor-internal new (or constructor-parameter defensive copy), and explain why the contained object's lifetime is bounded by the container's.Not started yet

A class with a class-type field

Defensive copy

Multiple EVCs and constructor delegation

Enum basics: finite named instances

I can declare a bare-bones enum, name the SCREAMING_SNAKE_CASE convention for constants, and access individual constants via EnumType.CONSTANT.Lesson coming soon
I can use Enum.values() to iterate all constants, distinguish name() (safe) from ordinal() (brittle), and avoid persisting ordinals.Lesson coming soon
I can choose between bare-bones and enum-with-state for a given specification, and justify the choice in one sentence.Lesson coming soon

Enum with fields and methods

I can declare an enum with instance fields and a private constructor, and explain why each constant has its own field values.Lesson coming soon
I can write standard accessor methods on an enum and call them through a constant.Lesson coming soon
I can declare enum constants with constructor arguments matching the declared constructor's signature.Lesson coming soon

Enum `toString` and display

I can override toString() on an enum to control the display, and predict the difference between toString()'s output and name()'s output.Lesson coming soon
I can implement the field + getter + toString triplet on an enum, and explain when each access form is appropriate.Lesson coming soon

Enums in `switch`

I can write a switch statement on an enum, use bare-name case labels, and avoid fall-through bugs by using break.Lesson coming soon
I can write a switch expression with arrow form, predict the exhaustiveness check, and translate between classic switch and arrow form.Lesson coming soon

Enum natural order via `Comparable`

I can predict the result of enum.compareTo based on declaration order, and explain why the natural order cannot be overridden.Lesson coming soon
I can write a multi-key compareTo that delegates to enum compareTo as a tiebreaker, and explain when this is appropriate vs. brittle.Lesson coming soon

Composition of enums and collections

I can declare a class with an enum field, write its constructor with appropriate preconditions, and explain why no defensive copy is needed.Lesson coming soon
I can declare a class with an array-typed field of class-type elements, write a constructor that defensively copies element-by-element, and reason about the storage shape.Lesson coming soon
I can read a class with mixed-mutability fields, classify each field's mutability, and predict whether the constructor's assignment is correct.Lesson coming soon

Why a `List<E>` exists when arrays already do

I can predict the size and capacity of an ArrayList through a sequence of add and remove calls.Lesson coming soon
I can identify a runtime ArrayStoreException risk in a covariant array assignment, and demonstrate the equivalent generic-list code is rejected at compile time.Lesson coming soon
I can declare variables and parameters using List<E> rather than concrete ArrayList<E>, and explain when the concrete type is justified.Lesson coming soon

Constructing an ArrayList

I can choose between the no-arg and capacity-hint constructors based on whether the expected size is known, and predict initial size.Lesson coming soon
I can defensively copy a List parameter using the copy constructor, and predict whether mutations to the original affect the copy.Lesson coming soon
I can choose between immutable List.of(...) and mutable new ArrayList<>(...) based on whether subsequent mutation is needed.Lesson coming soon

Reading from an ArrayList

I can call get(i) correctly, predict IndexOutOfBoundsException for invalid i, and reason about O(1) cost.Lesson coming soon
I can use size() for loop bounds and isEmpty() for emptiness checks, and choose between them stylistically.Lesson coming soon
I can use contains and indexOf correctly, predict equality semantics, and reason about O(n) cost.Lesson coming soon

Writing to an ArrayList

I can append with add(E) and insert with add(int, E), and reason about the cost difference.Lesson coming soon
I can distinguish set(i, x) (replace) from add(i, x) (insert) and predict size after each.Lesson coming soon
I can predict which overload of remove is invoked given the argument type, and force the desired overload via boxing or Object-typed argument.Lesson coming soon

for-each and `Iterable<T>`

I can write a for-each loop on a List, predict the iteration order, and identify when a traditional for-loop is needed.Lesson coming soon
I can identify the abstract method on Iterable<T> and explain how the compiler desugars for-each.Lesson coming soon

Explicit `Iterator<T>` and `ConcurrentModificationException`

I can write an explicit-iterator loop and predict NoSuchElementException for over-advance.Lesson coming soon
I can predict CME for structural modification during iteration, and identify it as a single-threaded problem despite the name.Lesson coming soon
I can use Iterator.remove correctly and translate to/from removeIf.Lesson coming soon

Autoboxing and unboxing pitfalls

I can identify autoboxing in code, predict the Integer cache range, and reason about cost in hot loops.Lesson coming soon
I can identify code paths where unboxing might NPE and add a null check.Lesson coming soon
I can predict when == on Integer-typed values appears to work and when it silently breaks.Lesson coming soon

ArrayList vs array; sorting

I can choose between T[] and List<T> for a given specification.Lesson coming soon
I can sort a List<E> with a Comparator using the modern list.sort(cmp) form.Lesson coming soon
I can sort a List by natural order using Collections.sort or list.sort(null), and predict compile error for non-Comparable elements.Lesson coming soon

List equality, copying, and views

I can predict the result of list1.equals(list2) for two List instances given their sizes, element types, and element ordering, and explain why ordering matters.Lesson coming soon
I can produce a shallow independent copy of a List using new ArrayList<>(other) or List.copyOf, predict whether subsequent mutations affect the original, and choose between the two based on whether the result needs to be mutable.Lesson coming soon
I can predict whether a mutation to a sublist or its parent affects the other, and can produce an independent snapshot of a range when isolation is required.Lesson coming soon
I can predict whether a mutation through a wrapped or original reference succeeds, and can choose between unmodifiableList, List.copyOf, and a defensive copy depending on the required guarantees.Lesson coming soon

`ArrayList<E>` ↔ array interop

I can produce a typed array from a generic List<E> using toArray(new E[0]), and predict the failure when the no-arg toArray() is cast to a typed array.Lesson coming soon
I can predict whether set, add, and direct array writes succeed on the result of Arrays.asList(arr), and contrast it with List.of(...) and new ArrayList<>(Arrays.asList(arr)).Lesson coming soon
I can implement, in one line, the conversion from a reference-type array to an independent mutable ArrayList, and can implement the boxing loop required for primitive-array sources.Lesson coming soon

Quiz milestone

Comparable / Comparator: the Dual

The `compare` Method Contract

Comparator as a Named Class

Comparator as an Anonymous Inner Class

Comparator as a Lambda

Method References as a Comparator

Multiple Comparators for One Class

Sorting Arrays and Lists with a Comparator

The Subtraction-Trick Overflow Pitfall

Comparator Composition (Modern API)

HAS-A vs IS-A

Association, Aggregation, Composition

A class with a class-type field

Defensive copy

Multiple EVCs and constructor delegation

Enum basics: finite named instances

Enum with fields and methods

Enum `toString` and display

Enums in `switch`

Enum natural order via `Comparable`

Composition of enums and collections

Why a `List<E>` exists when arrays already do

Constructing an ArrayList

Reading from an ArrayList

Writing to an ArrayList

for-each and `Iterable<T>`

Explicit `Iterator<T>` and `ConcurrentModificationException`

Autoboxing and unboxing pitfalls

ArrayList vs array; sorting

List equality, copying, and views

`ArrayList<E>` ↔ array interop

Git is a linked structure

`Node<T>` self-referential class

NDH vs DH header conventions

The traversal idiom

`addFirst` and append (`add`)

remove head and tail

add and remove at index

`removeAllOccurrences(T data)`

`toArray` and `toString`

Doubly-linked variant

Custom Iterator implementation

Generic bound `<T extends Comparable<? super T>>`

`extends` and the subclass relation

`super(...)` and constructor chaining

Method overriding

Dynamic dispatch

`super.method()` call

Object class and its overridable methods

toString override in hierarchy

`equals` override mechanic

Upcast and downcast

`instanceof` classic and pattern

Polymorphism through base-type reference

final classes and final methods

protected access

Abstract class fundamentals

Abstract methods

Partial-implementation pattern

The interface declaration

`implements` and multiple-interface implementation

Interface inheritance

`default` methods (Java 8+)

`static` (Java 8+) and `private` (Java 9+) interface methods

Abstract class vs interface: the design choice

The classic 211 interfaces (pointers)

Static nested class

Inner (non-static member) class

Local class

Anonymous class

Choosing the right inner-class kind

`Object.clone()` protocol

Shallow vs deep copy

`Cloneable` is broken; modern alternatives

The `equals` contract

`equals` under inheritance: `getClass` vs `instanceof`

`hashCode` and the equals/hashCode consistency rule

`==` vs `.equals` revisited