Apa kontrak supertype?
Apakah subtype bisa menggantikan supertype tanpa mengejutkan caller?
Apakah superclass memang dirancang untuk inheritance?
Apakah reuse code sedang disamarkan sebagai type relationship?
Apa extension point yang stabil?
Apa yang boleh dioverride dan apa yang final?
Apakah invariant superclass bisa dirusak subclass?

Relasi antar konsep:
  ├─ true subtype?             -> inheritance/interface implementation mungkin valid
  ├─ uses behavior?            -> composition/dependency
  ├─ owns component?           -> composition/aggregation
  ├─ configurable algorithm?   -> strategy/policy
  ├─ closed variant set?       -> sealed hierarchy
  ├─ reuse helper code?        -> delegation/utility/skeletal implementation
  └─ framework extension?      -> documented protected hooks/template method

1. Type relationship: subtype adalah variasi sah dari supertype.
2. Implementation reuse: subclass memakai ulang field/method superclass.

public interface NotificationChannel {
    void send(Notification notification);
}

public final class EmailChannel implements NotificationChannel {
    @Override
    public void send(Notification notification) {
        // send email
    }
}

public final class SmsChannel implements NotificationChannel {
    @Override
    public void send(Notification notification) {
        // send sms
    }
}

public class CsvReportGenerator extends FileWriterHelper {
    public Report generate(DataSet dataSet) {
        writeHeader();
        writeRows(dataSet);
        return closeFile();
    }
}

public final class CsvReportGenerator {
    private final ReportFileWriter writer;

    public CsvReportGenerator(ReportFileWriter writer) {
        this.writer = Objects.requireNonNull(writer);
    }

    public Report generate(DataSet dataSet) {
        writer.writeHeader();
        writer.writeRows(dataSet);
        return writer.closeFile();
    }
}

public interface DocumentStore {
    void save(Document document);
}

public final class PdfOnlyDocumentStore implements DocumentStore {
    @Override
    public void save(Document document) {
        if (!document.fileName().endsWith(".pdf")) {
            throw new IllegalArgumentException("Only PDF is supported");
        }
        // save
    }
}

public interface DocumentStore<D extends Document> {
    void save(D document);
}

public final class PdfDocumentStore implements DocumentStore<PdfDocument> {
    @Override
    public void save(PdfDocument document) {
        // save pdf
    }
}

public interface PdfDocumentStore {
    void save(PdfDocument document);
}

public interface IdGenerator<T> {
    T nextId();
}

public final class NullableIdGenerator implements IdGenerator<OrderId> {
    @Override
    public OrderId nextId() {
        return maybeUnavailable() ? null : OrderId.random();
    }
}

public interface OptionalIdGenerator<T> {
    Optional<T> tryNextId();
}

public class Rectangle {
    private int width;
    private int height;

    public void setWidth(int width) {
        this.width = width;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public int area() {
        return width * height;
    }
}

public class Square extends Rectangle {
    @Override
    public void setWidth(int width) {
        super.setWidth(width);
        super.setHeight(width);
    }

    @Override
    public void setHeight(int height) {
        super.setWidth(height);
        super.setHeight(height);
    }
}

void resize(Rectangle r) {
    r.setWidth(10);
    r.setHeight(5);
    assert r.area() == 50;
}

public sealed interface Shape permits Rectangle, Square {
    int area();
}

public record Rectangle(int width, int height) implements Shape {
    public Rectangle {
        if (width <= 0 || height <= 0) throw new IllegalArgumentException();
    }

    @Override
    public int area() {
        return width * height;
    }
}

public record Square(int side) implements Shape {
    public Square {
        if (side <= 0) throw new IllegalArgumentException();
    }

    @Override
    public int area() {
        return side * side;
    }
}

Can every operation promised by the supertype be validly supported by the subtype?

public interface MutableBag<E> {
    void add(E element);
    boolean remove(E element);
    int size();
}

public interface Bag<E> {
    int size();
    boolean contains(E element);
}

public interface MutableBag<E> extends Bag<E> {
    void add(E element);
    boolean remove(E element);
}

class Parent {
    void process(String value) {}
    static void describe() {}
    String name = "parent";
}

class Child extends Parent {
    @Override
    void process(String value) {}       // overriding

    void process(Object value) {}       // overloading, not overriding

    static void describe() {}           // hiding, not polymorphic overriding

    String name = "child";              // field hiding
}

public class BaseProcessor {
    public BaseProcessor() {
        initialize();
    }

    protected void initialize() {
    }
}

public class FileProcessor extends BaseProcessor {
    private final Path path;

    public FileProcessor(Path path) {
        this.path = path;
    }

    @Override
    protected void initialize() {
        // path is still null when BaseProcessor constructor calls this
        path.toAbsolutePath();
    }
}

public abstract class BaseProcessor {
    protected BaseProcessor() {
    }

    public final void start() {
        initialize();
    }

    protected abstract void initialize();
}

public class AuditedList<E> extends ArrayList<E> {
    private int addCount;

    @Override
    public boolean add(E e) {
        addCount++;
        return super.add(e);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        addCount += c.size();
        return super.addAll(c);
    }

    public int addCount() {
        return addCount;
    }
}

public final class AuditedList<E> {
    private final List<E> delegate;
    private int addCount;

    public AuditedList(List<E> delegate) {
        this.delegate = Objects.requireNonNull(delegate);
    }

    public boolean add(E e) {
        addCount++;
        return delegate.add(e);
    }

    public boolean addAll(Collection<? extends E> elements) {
        addCount += elements.size();
        return delegate.addAll(elements);
    }

    public int addCount() {
        return addCount;
    }
}

public abstract class AbstractCsvReader<T> {
    public final List<T> readAll(Reader reader) throws IOException {
        List<T> result = new ArrayList<>();
        for (CsvRow row : parseRows(reader)) {
            result.add(mapRow(row));
        }
        return List.copyOf(result);
    }

    /**
     * Maps one parsed CSV row to a domain object.
     * Implementations must not retain the mutable CsvRow reference.
     * Implementations may throw CsvMappingException for invalid rows.
     */
    protected abstract T mapRow(CsvRow row);

    private List<CsvRow> parseRows(Reader reader) throws IOException {
        // internal parsing, not overridable
        return List.of();
    }
}

protected List<OrderLine> lines;

protected final List<OrderLine> linesView() {
    return List.copyOf(lines);
}

protected final void addValidatedLine(OrderLine line) {
    validateLine(line);
    lines.add(line);
}

Classes should be final unless explicitly designed for inheritance.
Methods should be final/private unless explicitly designed as hooks.
State should be private unless subclass access is part of contract.

public final class MoneyFormatter {
    private final Locale locale;

    public MoneyFormatter(Locale locale) {
        this.locale = Objects.requireNonNull(locale);
    }

    public String format(Money money) {
        // stable behavior
    }
}

public interface MoneyFormatStrategy {
    String format(Money money, Locale locale);
}

public sealed interface PaymentResult
        permits PaymentApproved, PaymentDeclined, PaymentPending {
}

public record PaymentApproved(AuthorizationId authorizationId) implements PaymentResult {}
public record PaymentDeclined(DeclineReason reason) implements PaymentResult {}
public record PaymentPending(Instant checkAfter) implements PaymentResult {}

public final class Invoice {
    private final List<InvoiceLine> lines;
}

public final class InvoicePrinter {
    private final TemplateRenderer renderer;
}

public final class RetryExecutor {
    private final RetryPolicy retryPolicy;

    public <T> T execute(Callable<T> operation) throws Exception {
        // use retryPolicy to decide retry
    }
}

public final class AuditingNotifier implements Notifier {
    private final Notifier delegate;
    private final AuditSink auditSink;

    @Override
    public void notify(User user, Message message) {
        delegate.notify(user, message);
        auditSink.record("notification.sent", user.id());
    }
}

public final class SmtpEmailSender implements EmailSender {
    private final SmtpClient smtp;

    @Override
    public void send(Email email) {
        smtp.send(toSmtpMessage(email));
    }
}

public interface EscalationPolicy {
    boolean shouldEscalate(CaseFile caseFile, Instant now);
}

public final class ReadOnlyOrderRepository implements OrderRepository {
    private final OrderRepository delegate;

    public ReadOnlyOrderRepository(OrderRepository delegate) {
        this.delegate = Objects.requireNonNull(delegate);
    }

    @Override
    public Optional<Order> findById(OrderId id) {
        return delegate.findById(id);
    }

    @Override
    public Order save(Order order) {
        throw new UnsupportedOperationException("Repository is read-only");
    }
}

public interface OrderLookup {
    Optional<Order> findById(OrderId id);
}

public interface OrderStore extends OrderLookup {
    Order save(Order order);
}

public interface Validator<T> {
    ValidationResult validate(T candidate);
}

public abstract class AbstractValidator<T> implements Validator<T> {
    @Override
    public final ValidationResult validate(T candidate) {
        Objects.requireNonNull(candidate, "candidate");
        ValidationResult result = doValidate(candidate);
        return Objects.requireNonNull(result, "result");
    }

    protected abstract ValidationResult doValidate(T candidate);
}

public interface RateLimiter {
    boolean allow(RequestKey key);
}

public abstract class AbstractWindowRateLimiter implements RateLimiter {
    private final Clock clock;

    protected AbstractWindowRateLimiter(Clock clock) {
        this.clock = Objects.requireNonNull(clock);
    }

    protected final Instant now() {
        return clock.instant();
    }
}

public abstract class ImportJob {
    public final ImportResult run(Path file) {
        validateFile(file);
        List<Row> rows = readRows(file);
        ImportResult result = processRows(rows);
        afterImport(result);
        return result;
    }

    protected abstract List<Row> readRows(Path file);
    protected abstract ImportResult processRows(List<Row> rows);

    protected void afterImport(ImportResult result) {
        // optional hook
    }

    private void validateFile(Path file) {
        Objects.requireNonNull(file, "file");
    }
}

public final class ImportJob {
    private final RowReader rowReader;
    private final RowProcessor rowProcessor;
    private final ImportListener listener;

    public ImportResult run(Path file) {
        validateFile(file);
        List<Row> rows = rowReader.readRows(file);
        ImportResult result = rowProcessor.process(rows);
        listener.afterImport(result);
        return result;
    }
}

public interface Timestamped {
    Instant createdAt();

    default boolean wasCreatedBefore(Instant instant) {
        return createdAt().isBefore(instant);
    }
}

interface A {
    default String name() { return "A"; }
}

interface B {
    default String name() { return "B"; }
}

class C implements A, B {
    @Override
    public String name() {
        return A.super.name();
    }
}

Can I replace parent with child everywhere without changing caller assumptions?
  yes -> inheritance may be valid
  no  -> composition/interface split

Am I inheriting only to reuse code?
  yes -> composition/helper/delegation

Can external users safely subclass this?
  no -> final or sealed

public abstract class PaymentProcessor {
    public Receipt process(PaymentRequest request) {
        validate(request);
        Money fee = calculateFee(request);
        return charge(request, fee);
    }

    protected abstract Money calculateFee(PaymentRequest request);
    protected abstract Receipt charge(PaymentRequest request, Money fee);
}

PremiumMerchantCardProcessor
PremiumMerchantWalletProcessor
EuCardProcessor
EuPremiumWalletProcessor
RetryableEuPremiumCardProcessor

public final class PaymentProcessor {
    private final PaymentValidator validator;
    private final FeePolicy feePolicy;
    private final PaymentGateway gateway;
    private final AuditSink auditSink;

    public Receipt process(PaymentRequest request) {
        validator.validate(request);
        Money fee = feePolicy.feeFor(request);
        Receipt receipt = gateway.charge(request, fee);
        auditSink.record(PaymentAuditEvent.success(request, receipt));
        return receipt;
    }
}

public abstract class AbstractMessageHandler<M extends Message> {
    public final HandlingResult handle(M message) {
        Objects.requireNonNull(message, "message");
        beforeHandle(message);
        HandlingResult result = doHandle(message);
        afterHandle(message, result);
        return result;
    }

    protected void beforeHandle(M message) {
    }

    protected abstract HandlingResult doHandle(M message);

    protected void afterHandle(M message, HandlingResult result) {
    }
}

public interface CacheContractTest {
    Cache<String, String> createCache();

    @Test
    default void storedValueCanBeRetrieved() {
        Cache<String, String> cache = createCache();
        cache.put("k", "v");
        assertEquals(Optional.of("v"), cache.get("k"));
    }

    @Test
    default void missingValueReturnsEmptyOptional() {
        Cache<String, String> cache = createCache();
        assertEquals(Optional.empty(), cache.get("missing"));
    }
}

class InMemoryCacheTest implements CacheContractTest {
    @Override
    public Cache<String, String> createCache() {
        return new InMemoryCache<>();
    }
}

[ ] Accepted inputs from supertype contract.
[ ] Return semantics.
[ ] Exception semantics.
[ ] State transition semantics.
[ ] Nullability contract.
[ ] Idempotency if promised.
[ ] Immutability/mutability expectation.
[ ] Thread-safety if promised.

public interface ErrorCodes {
    String INVALID_TOKEN = "INVALID_TOKEN";
}

public class AuthService implements ErrorCodes {
}

public final class ErrorCodes {
    private ErrorCodes() {}

    public static final String INVALID_TOKEN = "INVALID_TOKEN";
}

public abstract class BaseOrder {
    protected List<OrderLine> lines = new ArrayList<>();
}

BaseEntity
  AuditedEntity
    TenantScopedAuditedEntity
      SoftDeletableTenantScopedAuditedEntity
        VersionedSoftDeletableTenantScopedAuditedEntity

public record AuditInfo(UserId createdBy, Instant createdAt, UserId updatedBy, Instant updatedAt) {}
public record TenantScope(TenantId tenantId) {}
public record SoftDeletion(boolean deleted, Instant deletedAt) {}

public abstract class DomainObject {
}

public class ReadOnlyList<E> extends ArrayList<E> {
    @Override
    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }
}

public interface MessageEncoder {
    byte[] encode(Message message);
}

public sealed interface CaseDecision
        permits Approved, Rejected, NeedsMoreInformation {
}

public record Approved(Approver approver, Instant at) implements CaseDecision {}
public record Rejected(String reason) implements CaseDecision {}
public record NeedsMoreInformation(List<String> missingItems) implements CaseDecision {}

public final class TokenVerifier {
    public VerificationResult verify(Token token) {
        // stable implementation
    }
}

public abstract class TokenVerifier {
    public final VerificationResult verify(Token token) {
        Objects.requireNonNull(token);
        return verifyToken(token);
    }

    protected abstract VerificationResult verifyToken(Token token);
}

public interface TokenVerifierPlugin {
    VerificationResult verify(Token token, VerificationContext context);
}

public class JsonAuditLogger extends AuditLogger {
    @Override
    protected String format(AuditEvent event) {
        return toJson(event);
    }
}

public final class AuditLogger {
    private final AuditEventFormatter formatter;
    private final AuditSink sink;

    public void log(AuditEvent event) {
        sink.write(formatter.format(event));
    }
}

public interface AuditEventFormatter {
    String format(AuditEvent event);
}

[ ] Is the subtype truly substitutable for the supertype?
[ ] Are all inherited public methods meaningful for the subtype?
[ ] Can subtype preserve superclass invariants?
[ ] Is superclass documented for inheritance?
[ ] Are override hooks small and stable?
[ ] Does superclass avoid constructor calls to overridable methods?
[ ] Are protected members minimal and safe?
[ ] Is the hierarchy shallow?
[ ] Is code reuse not the only motivation?
[ ] Would composition make variation clearer?

[ ] The object uses another behavior but is not a subtype of it.
[ ] Multiple behavior axes vary independently.
[ ] The relationship is runtime-configurable.
[ ] Testing benefits from replacing collaborator.
[ ] You need wrapper/decorator behavior.
[ ] You need adapt external API.
[ ] You want to hide implementation details.
[ ] You want to avoid protected API compatibility burden.

public abstract class Report {
    protected String title;
    protected List<String> rows = new ArrayList<>();

    public void addRow(String row) {
        rows.add(row);
    }

    public abstract byte[] export();
}

public class PdfReport extends Report {
    @Override
    public byte[] export() {
        return PdfLibrary.render(title, rows);
    }
}

public class CsvReport extends Report {
    @Override
    public byte[] export() {
        return CsvLibrary.render(rows);
    }
}

public record ReportDocument(String title, List<String> rows) {
    public ReportDocument {
        Objects.requireNonNull(title, "title");
        rows = List.copyOf(rows);
    }
}

public interface ReportExporter {
    byte[] export(ReportDocument report);
}

public final class PdfReportExporter implements ReportExporter {
    @Override
    public byte[] export(ReportDocument report) {
        return PdfLibrary.render(report.title(), report.rows());
    }
}

public final class CsvReportExporter implements ReportExporter {
    @Override
    public byte[] export(ReportDocument report) {
        return CsvLibrary.render(report.rows());
    }
}