The notifier that stopped notifying

import java.util.*;

/**
 * Solution: the notifier that stopped notifying.
 *
 * Two defects, one misunderstanding, and they need different fixes because
 * they are decided by different things at different times.
 *
 * DEFECT 1 — the channel, decided by the COMPILER from the reference type.
 *
 *   channel() was static, so UrgentNotifier.channel() HID it rather than
 *   overriding it. Hiding is resolved from the reference type, and inside
 *   Notifier.send() the reference is Notifier, so Notifier.channel() is what
 *   the bytecode calls. It would have behaved this way even if send() had
 *   been called on a UrgentNotifier a hundred times.
 *
 *   Fix: drop `static`. An instance method IS overridden, and overriding is
 *   dispatched on the object. One keyword.
 *
 * DEFECT 2 — the renderer, also decided by the COMPILER, from the declared
 * type of the ARGUMENT.
 *
 *   render(Recipient) and render(Customer) are overloads, and overload
 *   resolution happens at compile time. `recipient` is declared Recipient,
 *   so render(Recipient) was selected and burned into the call site. The
 *   object being a Customer at runtime is not consulted and never was.
 *
 *   Fix: stop overloading on a subtype relationship, and let dispatch do the
 *   work instead. render becomes ONE method, and the varying part becomes an
 *   overridable method on the type itself. One signature.
 *
 * The general rule both come from: overloading looks at the reference,
 * overriding looks at the object. If you want the object's type to decide,
 * you need a method on the object.
 */
public class Solution {

    /* ── fix 1: an instance method, so it can actually be overridden ── */

    static class Notifier {
        /** FIX: no longer static, so a subclass overrides rather than hides. */
        String channel() {
            return "email";
        }

        String send(String message) {
            return channel() + ": " + message;
        }
    }

    static final class UrgentNotifier extends Notifier {
        @Override
        String channel() {
            return "sms";
        }
    }

    /* ── fix 2: one method, and the type decides its own rendering ── */

    static class Recipient {
        final String email;

        Recipient(String email) {
            this.email = email;
        }

        /** The varying part, moved onto the object so dispatch reaches it. */
        String describe() {
            return "to " + email;
        }
    }

    static final class Customer extends Recipient {
        final String accountNumber;

        Customer(String email, String accountNumber) {
            super(email);
            this.accountNumber = accountNumber;
        }

        @Override
        String describe() {
            return "to " + email + " (account " + accountNumber + ")";
        }
    }

    /**
     * One method, no overload. There is nothing left for the compiler to
     * choose between, so the object's type is the only thing that can decide.
     */
    static String render(Recipient r) {
        return r.describe();
    }

    public static void main(String[] args) {
        System.out.println("── outgoing ──");

        Notifier urgent = new UrgentNotifier();
        String line = urgent.send("card blocked");
        System.out.println("  " + line);

        Recipient recipient = new Customer("ravi@example.com", "AC-4417");
        String rendered = render(recipient);
        System.out.println("  " + rendered);

        // Proof that the fixes are about dispatch and not about these two
        // call sites: the declared types here are the supertypes, exactly as
        // before, and both now reach the subclass behaviour.
        System.out.println();
        System.out.println("  declared type of `urgent`    : Notifier");
        System.out.println("  declared type of `recipient` : Recipient");

        System.out.println();
        boolean urgentUsesSms = line.startsWith("sms:");
        boolean customerRendered = rendered.contains("AC-4417");

        System.out.println("urgent alert went over SMS      : " + urgentUsesSms);
        System.out.println("customer rendered with account  : " + customerRendered);
        System.out.println(urgentUsesSms && customerRendered ? "PASS" : "FAIL");
    }
}