Lesson 1: Advanced OOP

Records, classes, enums, sealed interfaces, generics, pricing rules, validation, sorting, grouping, and domain invariants.

scripts/run.sh lesson_1 demo
scripts/run.sh lesson_1 exercise
scripts/apply_answers.sh lesson_1
scripts/run.sh lesson_1 verify
scripts/reset_exercises.sh lesson_1

Lesson README

Lesson 1: Advanced OOP In Modern Java

Audience: CS graduates who already know another language and need the Java object model, not introductory programming.

120-Minute Plan

Exercise

Use workbook.md for the full two-hour learner path. It includes tracing tasks, implementation rounds, and edge-case drills.

Edit src/exercise/java/tutorial/lesson1/exercise/PriceRules.java.

Functions to implement:

• subtotal
• itemCount
• discountedTotal
• taxableTotal
• shippingCents
• mostExpensiveName
• namesSortedByLineTotalDescending
• quantitiesByName

The file compiles before implementation. Use scripts/apply_answers.sh lesson_1 and scripts/reset_exercises.sh lesson_1 to switch between completed and stub code.

After applying answers, run scripts/run.sh lesson_1 verify to check normal cases, empty input, invalid percentages, shipping thresholds, grouping, sorting, and validation behavior.

Learner Workbook

Learner Workbook: Lesson 1 Advanced OOP

This workbook is designed to take about two hours. Do not try to finish by reading quickly. The point is to use the code as a Java lab: run it, trace it, predict behavior, edit small functions, and test edge cases.

What You Should Understand By The End

• Why Java uses records, classes, enums, interfaces, sealed interfaces, and generics in different places.
• How constructor validation protects object invariants.
• How to read Java method signatures and collection types.
• How Optional represents "no result" without returning null.
• How small pricing rules expose edge cases such as empty carts, duplicate names, percentage boundaries, and deterministic sorting.

0-15 Minutes: Run Before Reading

Run:

scripts/reset_exercises.sh lesson_1
scripts/run.sh lesson_1 demo
scripts/run.sh lesson_1 exercise

Write down answers to these questions before opening the files:

• What objects seem to exist in the order domain?
• Which output lines look like calculated values?
• Which exercise outputs are obviously placeholders?
• What values should the placeholders eventually return?

15-35 Minutes: Trace The Demo

Open src/demo/java/tutorial/lesson1/demo/OopDemo.java.

Trace the code in this order:

• Customer
• Order<LineItem>
• LineItem
• DiscountPolicy.tieredLoyalty()
• PaymentMethod
• CreditCard.charge

Pause on each type and decide whether it is data, behavior, or both. Then inspect Money.java and answer:

• Why does Money.plus reject different currencies?
• Why does Money.times return a new object instead of changing the old one?
• Why is Money a record but Order is a class?

35-55 Minutes: Read The Exercise API

Open src/exercise/java/tutorial/lesson1/exercise/PriceRules.java.

Read every TODO before editing. Group the functions by skill:

• Arithmetic: subtotal, itemCount, discountedTotal, taxableTotal
• Business rules: shippingCents
• Optional result: mostExpensiveName
• Collection ordering: namesSortedByLineTotalDescending
• Grouping: quantitiesByName

For each function, write one normal case and one edge case in a comment or notebook.

55-95 Minutes: Implement In Rounds

Round 1:

• Implement subtotal.
• Implement itemCount.
• Run scripts/run.sh lesson_1 exercise.

Round 2:

• Implement discountedTotal.
• Test 0, 10, and 100 percent discounts.
• Decide what should happen for -1 and 101.

Round 3:

• Implement taxableTotal.
• Use basis points: 825 means 8.25%.
• Tax should round to the nearest cent.

Round 4:

• Implement shippingCents.
• Empty carts should ship for 0.
• A cart exactly at the free threshold should ship for 0.

Round 5:

• Implement mostExpensiveName.
• Use Optional.empty() for empty input.

Round 6:

• Implement sorted names by line total.
• Line total means unitCents * quantity.
• If two lines tie, sort alphabetically by name.

Round 7:

• Implement quantity grouping by name.
• Duplicate item names should merge quantities.

95-110 Minutes: Verify Answers

Run:

scripts/apply_answers.sh lesson_1
scripts/run.sh lesson_1 verify
scripts/reset_exercises.sh lesson_1

If your solution differs from the answers but passes the same behavior, that is fine. Compare the tradeoffs:

• Loop versus stream
• Early validation versus late validation
• Returning mutable versus immutable collections
• Tie-breaking rules for deterministic output

110-120 Minutes: Edge-Case Drill

Create your own cart examples in ExerciseRunner.java or a scratch file in playground.

Test at least five cases:

• Empty cart
• One item with quantity greater than one
• Two items with the same name
• Free-shipping threshold exactly equal to subtotal
• Discount percent at 0, 100, and invalid boundaries
• Tax that rounds up and tax that rounds down

Finish by resetting:

scripts/reset_exercises.sh lesson_1

Instructor Notes

Instructor Notes: Lesson 1 Advanced OOP

Session Goal

Help experienced developers understand how modern Java models domain behavior with records, classes, interfaces, enums, sealed hierarchies, generics, and collection APIs. Learners should leave able to read a small Java domain model and reason about invariants, polymorphism, and type constraints.

Learning Outcomes

By the end of 120 minutes, learners should be able to:

• Explain when this repo uses a record, class, enum, interface, sealed interface, or generic class.
• Trace method dispatch from OopDemo.main to a concrete PaymentMethod.
• Explain why Money validates currency and why Order<T extends LineItem> uses a bound.
• Implement pricing functions using collections, streams, Optional, validation, and simple arithmetic.
• Compare Java's nominal types with object or protocol systems in languages they already know.

Before Class

Run:

scripts/reset_exercises.sh lesson_1
scripts/run.sh lesson_1 demo
scripts/run.sh lesson_1 exercise

Know the key files:

• src/demo/java/tutorial/lesson1/demo/OopDemo.java
• src/demo/java/tutorial/lesson1/demo/Money.java
• src/demo/java/tutorial/lesson1/demo/Order.java
• src/demo/java/tutorial/lesson1/demo/PaymentMethod.java
• src/exercise/java/tutorial/lesson1/exercise/PriceRules.java

Minute-By-Minute Plan

Teaching Script

Start with the problem, not the syntax:

"This lesson is a miniature order/payment domain. The interesting question is not how to print a string. The question is which states are legal, where validation belongs, and how Java makes illegal states harder to construct."

When opening Money.java, point out:

• The record automatically creates accessors named currency() and cents().
• The compact constructor validates arguments before instances exist.
• The object is immutable, so methods such as plus return new Money values.
• compareTo is legal only after checking currencies.

Checkpoint question:

"If this were represented as a tuple or plain map in another language, where would the currency check live?"

When opening Order.java, emphasize:

• The class owns a mutable ArrayList internally.
• items() returns List.copyOf(items) to protect representation.
• Generic bounds let the class accept LineItem subtypes without losing the methods it needs.
• subtotal() currently picks the first item's currency, which is enough for a teaching demo but would need stronger rules in production.

When opening PaymentMethod.java, use this explanation:

"An interface says what operations exist. A sealed interface says the implementation set is intentionally closed. That gives readers and tools a stronger guarantee than a normal interface."

Exercise Facilitation

Learners edit PriceRules.java.

Recommended order:

• Implement subtotal with a loop first.
• Implement itemCount.
• Implement discountedTotal by calling subtotal.
• Add validation for discountPercent.
• Implement taxableTotal and discuss basis points.
• Implement shippingCents and threshold boundaries.
• Implement mostExpensiveName using either a loop or stream.
• Implement line-total sorting and quantity grouping.

Do not require streams. A loop-based answer is valid and often clearer for learners new to Java. Use streams in the answer discussion to show idiomatic collection processing, not to imply every collection task needs streams.

Hints to give without solving:

• "The item total is unit cents times quantity."
• "Integer division rounds down in Java."
• "Optional.empty() is the explicit no-result value."
• "A comparator can compare by CartItem::unitCents."

Expected Answer Behavior

After applying answers:

scripts/apply_answers.sh lesson_1
scripts/run.sh lesson_1 verify

Expected important lines:

lesson_1 answers verified

Reset afterward:

scripts/reset_exercises.sh lesson_1

Common Mistakes

• Returning null instead of Optional.empty().
• Modifying input lists unnecessarily.
• Forgetting to multiply by quantity.
• Treating discountPercent as 0.10 rather than 10.
• Assuming Java record fields are accessed as item.unitCents instead of item.unitCents().

Discussion Prompts

• When is a record too small for a domain concept?
• Should Money allow negative values?
• Should Order reject mixed currencies at add time or subtotal time?
• Should discounts be methods, objects, lambdas, or enum constants?
• What would change if payment providers performed network I/O?

Extension Challenge

Ask fast learners to add a new discount policy in playground/src/java. They can use the demo package or create a tiny independent class. The goal is to preserve the DiscountPolicy signature while changing only the behavior.

Functions In This Lesson

private PriceRules() {

public static int subtotal(List<CartItem> items) {

public static int itemCount(List<CartItem> items) {

public static int discountedTotal(List<CartItem> items, int discountPercent) {

public static int taxableTotal(List<CartItem> items, int taxBasisPoints) {

public static int shippingCents(List<CartItem> items, int freeThresholdCents, int standardShippingCents) {

public static Optional<String> mostExpensiveName(List<CartItem> items) {

public static List<String> namesSortedByLineTotalDescending(List<CartItem> items) {

public static Map<String, Integer> quantitiesByName(List<CartItem> items) {

public BankTransfer(String routingAlias) {

public PaymentReceipt charge(Money amount) {

public PaymentReceipt charge(Money amount) {

public Customer {

Money discountFor(Order<? extends LineItem> order, Money subtotal);

static DiscountPolicy none() {

static DiscountPolicy tieredLoyalty() {

public LineItem {

public Money total() {

public Money {

public Money plus(Money other) {

public Money minus(Money other) {

public Money times(int quantity) {

public Money multiply(double factor) {

public String format() {

public int compareTo(Money other) {

private void requireSameCurrency(Money other) {

private OopDemo() {

public static void main(String[] args) {

public Order(String id, Customer customer) {

public String id() {

public Customer customer() {

public void add(T item) {

public List<T> items() {

public Money subtotal() {

public Money totalAfter(DiscountPolicy policy) {

PaymentReceipt charge(Money amount);

public Wallet(String accountId) {

public PaymentReceipt charge(Money amount) {

private AnswerVerifier() {

public static void main(String[] args) {

private static void expectEquals(Object expected, Object actual, String label) {

private static void expectThrows(Runnable action, String label) {

public CartItem {

private ExerciseRunner() {

public static void main(String[] args) {

private PriceRules() {

public static int subtotal(List<CartItem> items) {

public static int itemCount(List<CartItem> items) {

public static int discountedTotal(List<CartItem> items, int discountPercent) {

public static int taxableTotal(List<CartItem> items, int taxBasisPoints) {

public static int shippingCents(List<CartItem> items, int freeThresholdCents, int standardShippingCents) {

public static Optional<String> mostExpensiveName(List<CartItem> items) {

public static List<String> namesSortedByLineTotalDescending(List<CartItem> items) {

public static Map<String, Integer> quantitiesByName(List<CartItem> items) {

private PriceRules() {

public static int subtotal(List<CartItem> items) {

public static int itemCount(List<CartItem> items) {

public static int discountedTotal(List<CartItem> items, int discountPercent) {

public static int taxableTotal(List<CartItem> items, int taxBasisPoints) {

public static int shippingCents(List<CartItem> items, int freeThresholdCents, int standardShippingCents) {

public static Optional<String> mostExpensiveName(List<CartItem> items) {

public static List<String> namesSortedByLineTotalDescending(List<CartItem> items) {

public static Map<String, Integer> quantitiesByName(List<CartItem> items) {