Class punya field + method.
Object adalah instance dari class.
Inheritance berarti is-a.
Encapsulation berarti private field + getter/setter.
Polymorphism berarti method overriding.

Untuk class ini:
  - Tipe apa yang sedang dimodelkan?
  - Kontrak apa yang dijanjikan tipe ini?
  - State apa yang sah?
  - Siapa yang menjaga invariant?
  - Behavior apa yang memang milik object ini?
  - Behavior apa yang seharusnya external policy/service?
  - Apakah subtype dapat menggantikan supertype tanpa kejutan?
  - Apakah public API memaksa caller memahami detail internal?

Ada tabel customer.
Kolomnya id, name, email, status.
Buat class Customer.
Generate getter/setter.
Selesai.

public class Customer {
    private String id;
    private String name;
    private String email;
    private String status;

    public String getId() { return id; }
    public void setId(String id) { this.id = id; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }

    public String getStatus() { return status; }
    public void setStatus(String status) { this.status = status; }
}

ACTIVE?
SUSPENDED?
DELETED?
PENDING_VERIFICATION?

PENDING -> ACTIVE
ACTIVE -> SUSPENDED
SUSPENDED -> ACTIVE
DELETED -> ACTIVE ?

User sendiri?
Admin?
Compliance process?
Background reconciliation?

public final class CustomerAccount {
    private final CustomerId id;
    private EmailAddress email;
    private CustomerStatus status;

    private CustomerAccount(CustomerId id, EmailAddress email, CustomerStatus status) {
        this.id = Objects.requireNonNull(id);
        this.email = Objects.requireNonNull(email);
        this.status = Objects.requireNonNull(status);
    }

    public static CustomerAccount register(CustomerId id, EmailAddress email) {
        return new CustomerAccount(id, email, CustomerStatus.PENDING_VERIFICATION);
    }

    public void verifyEmail(EmailAddress verifiedEmail) {
        if (!this.email.equals(verifiedEmail)) {
            throw new IllegalArgumentException("Verified email does not match account email");
        }
        if (status != CustomerStatus.PENDING_VERIFICATION) {
            throw new IllegalStateException("Only pending accounts can be verified");
        }
        this.status = CustomerStatus.ACTIVE;
    }

    public void suspend(String reason) {
        if (status == CustomerStatus.DELETED) {
            throw new IllegalStateException("Deleted accounts cannot be suspended");
        }
        if (reason == null || reason.isBlank()) {
            throw new IllegalArgumentException("Suspension reason is required");
        }
        this.status = CustomerStatus.SUSPENDED;
    }

    public CustomerId id() {
        return id;
    }

    public CustomerStatus status() {
        return status;
    }
}

PaymentInstrument instrument;

public interface PaymentInstrument {
    Authorization authorize(Money amount, Merchant merchant);
}

CreditCard
DebitCard
WalletBalance
BankTransferMandate

public final class CreditCard implements PaymentInstrument {
    private final CardToken token;
    private final RiskPolicy riskPolicy;

    @Override
    public Authorization authorize(Money amount, Merchant merchant) {
        riskPolicy.check(amount, merchant);
        return Authorization.approved(token, amount, merchant);
    }
}

PaymentInstrument a = new CreditCard(token1, riskPolicy);
PaymentInstrument b = new CreditCard(token2, riskPolicy);

interface Cache<K, V> {
    V get(K key);
}

public final class InvoiceService {
    public boolean isOverdue(Invoice invoice, LocalDate today) {
        return invoice.getDueDate().isBefore(today)
            && invoice.getStatus() != InvoiceStatus.PAID;
    }
}

public final class Invoice {
    private final LocalDate dueDate;
    private InvoiceStatus status;

    public boolean isOverdueOn(LocalDate date) {
        return dueDate.isBefore(date) && status != InvoiceStatus.PAID;
    }
}

invoice.isOverdueOn(today)
account.canWithdraw(amount)
subscription.renew(period)
caseFile.escalate(reason)
order.cancel(cancellationPolicy)

public final class Customer {
    public void sendWelcomeEmail(SmtpClient smtpClient) {
        smtpClient.send(email, "Welcome");
    }
}

public final class CustomerOnboardingService {
    private final EmailSender emailSender;

    public void welcome(Customer customer) {
        emailSender.sendWelcomeEmail(customer.email());
    }
}

If the behavior protects the object's truth, keep it near the object.
If the behavior coordinates the outside world, move it to a service/collaborator.

Money amount cannot be negative.
Approved case must have approval timestamp.
Closed ticket cannot be reassigned.
Percentage must be between 0 and 100.
Date range start must be <= end.
Email address must be syntactically valid.

public class DateRange {
    public LocalDate start;
    public LocalDate end;
}

DateRange range = new DateRange();
range.start = LocalDate.of(2026, 12, 31);
range.end = LocalDate.of(2026, 1, 1);

public record DateRange(LocalDate start, LocalDate end) {
    public DateRange {
        Objects.requireNonNull(start, "start");
        Objects.requireNonNull(end, "end");
        if (end.isBefore(start)) {
            throw new IllegalArgumentException("end must not be before start");
        }
    }

    public boolean contains(LocalDate date) {
        return !date.isBefore(start) && !date.isAfter(end);
    }
}

public final class WorkItem {
    private WorkItemStatus status;
    private Assignee assignee;

    public void assignTo(Assignee assignee) {
        Objects.requireNonNull(assignee, "assignee");
        if (status == WorkItemStatus.CLOSED) {
            throw new IllegalStateException("Closed work item cannot be reassigned");
        }
        this.assignee = assignee;
    }

    public void close() {
        if (assignee == null) {
            throw new IllegalStateException("Cannot close unassigned work item");
        }
        this.status = WorkItemStatus.CLOSED;
    }
}

CustomerAccount
BankAccount
CaseFile
WorkflowInstance
Order
Ticket
Session

public final class CustomerAccount {
    private final CustomerId id;

    public CustomerId id() {
        return id;
    }
}

Money
EmailAddress
DateRange
Percentage
CurrencyCode
PhoneNumber
Coordinates

public record Money(BigDecimal amount, Currency currency) {
    public Money {
        Objects.requireNonNull(amount, "amount");
        Objects.requireNonNull(currency, "currency");
        if (amount.scale() > currency.getDefaultFractionDigits()) {
            throw new IllegalArgumentException("Amount scale exceeds currency fraction digits");
        }
    }

    public Money add(Money other) {
        requireSameCurrency(other);
        return new Money(amount.add(other.amount), currency);
    }

    private void requireSameCurrency(Money other) {
        if (!currency.equals(other.currency)) {
            throw new IllegalArgumentException("Currency mismatch");
        }
    }
}

public final class FraudScoringService {
    private final RiskModel riskModel;

    public FraudScore score(PaymentAttempt attempt) {
        return riskModel.evaluate(attempt.features());
    }
}

public interface DiscountPolicy {
    Money discountFor(Customer customer, Cart cart);
}

private String status;
public String getStatus() { return status; }
public void setStatus(String status) { this.status = status; }

public final class Subscription {
    private final LocalDate startedAt;
    private LocalDate expiresAt;

    public void renewForMonths(int months) {
        if (months <= 0) {
            throw new IllegalArgumentException("months must be positive");
        }
        this.expiresAt = expiresAt.plusMonths(months);
    }

    public boolean isActiveOn(LocalDate date) {
        return !date.isBefore(startedAt) && date.isBefore(expiresAt);
    }
}

if (invoice.getDueDate().isBefore(today) && invoice.getStatus() != PAID) {
    // overdue
}

if (invoice.isOverdueOn(today)) {
    // overdue
}

public Money calculateFee(PaymentMethod method, Money amount) {
    return switch (method.type()) {
        case CARD -> amount.multiply(new BigDecimal("0.029"));
        case BANK_TRANSFER -> Money.zero(amount.currency());
        case WALLET -> amount.multiply(new BigDecimal("0.010"));
    };
}

public interface PaymentMethod {
    Money feeFor(Money amount);
}

public final class CardPayment implements PaymentMethod {
    @Override
    public Money feeFor(Money amount) {
        return amount.multiply(new BigDecimal("0.029"));
    }
}

public final class BankTransferPayment implements PaymentMethod {
    @Override
    public Money feeFor(Money amount) {
        return Money.zero(amount.currency());
    }
}

public sealed interface PaymentMethod
        permits CardPayment, BankTransferPayment, WalletPayment {
}

public record CardPayment(CardToken token) implements PaymentMethod {}
public record BankTransferPayment(BankAccount account) implements PaymentMethod {}
public record WalletPayment(WalletId walletId) implements PaymentMethod {}

public Money feeFor(PaymentMethod method, Money amount) {
    return switch (method) {
        case CardPayment ignored -> amount.multiply(new BigDecimal("0.029"));
        case BankTransferPayment ignored -> Money.zero(amount.currency());
        case WalletPayment ignored -> amount.multiply(new BigDecimal("0.010"));
    };
}

interface Notifier {
    void notify(User user, Message message);
}

final class EmailNotifier implements Notifier {
    @Override
    public void notify(User user, Message message) {
        // send email
    }
}

Notifier notifier = new EmailNotifier();
notifier.notify(user, message);

public interface Processor {
    void process(Object input);
}

public interface CommandHandler<C extends Command> {
    HandlingResult handle(C command);
}

Apa yang bisa dilakukan object ini?

public interface Clock {
    Instant now();
}

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

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

public interface Repository<ID, E> {
    Optional<E> findById(ID id);
    E save(E entity);
}

public interface CustomerServiceInterface {
    Customer getCustomer(String id);
    void saveCustomer(Customer customer);
    void deleteCustomer(String id);
    void sendEmail(Customer customer);
    void exportCustomer(Customer customer);
}

public interface CustomerLookup {
    Optional<Customer> findCustomer(CustomerId id);
}

public interface CustomerStore {
    Customer save(Customer customer);
}

public interface CustomerExporter {
    ExportedFile export(Customer customer);
}

public interface CaseRepository {
    Optional<CaseFile> findById(CaseId id);
    CaseFile save(CaseFile caseFile);
}

public final class OrderManager {
    public void validate(Order order) {}
    public void calculatePrice(Order order) {}
    public void reserveInventory(Order order) {}
    public void chargePayment(Order order) {}
    public void sendEmail(Order order) {}
    public void writeAuditLog(Order order) {}
    public void exportCsv(Order order) {}
}

Order                     -> owns order lifecycle invariant
PricingService            -> computes price using policy/catalog
InventoryReservationPort  -> reserves stock
PaymentGateway            -> charges payment
OrderNotificationService  -> sends messages
AuditSink                 -> records audit event
OrderExporter             -> export concern

DRAFT -> SUBMITTED -> REVIEWED -> APPROVED -> CLOSED

caseFile.setStatus(CaseStatus.APPROVED);

caseFile.approve(approver, decisionTime);

public final class ReviewCase {
    private final CaseId id;
    private CaseStatus status;
    private Reviewer assignedReviewer;
    private Instant submittedAt;
    private Instant approvedAt;

    public void submit(Instant now) {
        if (status != CaseStatus.DRAFT) {
            throw new IllegalStateException("Only draft cases can be submitted");
        }
        this.status = CaseStatus.SUBMITTED;
        this.submittedAt = Objects.requireNonNull(now);
    }

    public void assignReviewer(Reviewer reviewer) {
        if (status != CaseStatus.SUBMITTED) {
            throw new IllegalStateException("Only submitted cases can be assigned");
        }
        this.assignedReviewer = Objects.requireNonNull(reviewer);
        this.status = CaseStatus.IN_REVIEW;
    }

    public void approve(Reviewer reviewer, Instant now) {
        if (status != CaseStatus.IN_REVIEW) {
            throw new IllegalStateException("Only cases in review can be approved");
        }
        if (!reviewer.equals(assignedReviewer)) {
            throw new IllegalArgumentException("Only assigned reviewer can approve");
        }
        this.status = CaseStatus.APPROVED;
        this.approvedAt = Objects.requireNonNull(now);
    }
}

public class Order {
    private List<OrderLine> lines;
    private OrderStatus status;
    // getters/setters only
}

public class OrderService {
    public void submit(Order order) {
        if (order.getLines().isEmpty()) throw ...;
        order.setStatus(OrderStatus.SUBMITTED);
    }
}

public class Order {
    public void submit() {}
    public void calculateTax() {}
    public void reserveInventory() {}
    public void chargeCreditCard() {}
    public void sendEmail() {}
    public void writeToDatabase() {}
}

Order owns order invariant and lifecycle transition.
PricingPolicy computes price rules.
PaymentGateway charges external payment.
InventoryPort reserves external stock.
Application service coordinates transaction/use case.

public final class SubmitOrderUseCase {
    private final OrderRepository orders;
    private final InventoryPort inventory;
    private final PaymentGateway payment;

    public OrderReceipt submit(OrderId id, PaymentDetails paymentDetails) {
        Order order = orders.findRequired(id);
        order.submit();

        inventory.reserve(order.items());
        PaymentReceipt receipt = payment.charge(order.total(), paymentDetails);

        order.markPaid(receipt.id());
        orders.save(order);

        return OrderReceipt.from(order, receipt);
    }
}

if (account.getBalance().compareTo(amount) >= 0) {
    account.setBalance(account.getBalance().subtract(amount));
}

account.withdraw(amount);

if (subscription.isActiveOn(today)) {
    featureGate.enablePremiumFeatures();
}

Ask object about its own truth.
Tell object to perform its own state transition.
Do not make object orchestrate unrelated external systems.

public final class ReportGenerator {
    public Report generate(CaseFile file) {
        PdfRenderer renderer = new PdfRenderer();
        return renderer.render(file);
    }
}

public final class ReportGenerator {
    private final ReportRenderer renderer;

    public ReportGenerator(ReportRenderer renderer) {
        this.renderer = Objects.requireNonNull(renderer);
    }

    public Report generate(CaseFile file) {
        return renderer.render(file);
    }
}

public record Percentage(int value) {
    public Percentage {
        if (value < 0 || value > 100) {
            throw new IllegalArgumentException("Percentage must be between 0 and 100");
        }
    }

    public BigDecimal asRatio() {
        return BigDecimal.valueOf(value).movePointLeft(2);
    }
}

public final class SupportTicket {
    private final TicketId id;
    private TicketStatus status;
    private Agent assignee;

    public void assignTo(Agent agent) {
        if (status == TicketStatus.CLOSED) {
            throw new IllegalStateException("Closed ticket cannot be assigned");
        }
        this.assignee = Objects.requireNonNull(agent);
    }
}

public final class Employee {
    private Manager manager;

    public Manager getManager() {
        return manager;
    }
}

public Optional<Manager> manager() {
    return Optional.ofNullable(manager);
}

public sealed interface ReportingLine permits HasManager, NoManager {
}

public record HasManager(Manager manager) implements ReportingLine {
    public HasManager {
        Objects.requireNonNull(manager);
    }
}

public record NoManager() implements ReportingLine {
}

public void withdraw(Money amount)

public void withdraw(Money amount) {
    requirePositive(amount);
    if (status != AccountStatus.ACTIVE) {
        throw new IllegalStateException("Only active accounts can withdraw");
    }
    if (balance.isLessThan(amount)) {
        throw new InsufficientFundsException(id, amount, balance);
    }
    this.balance = balance.subtract(amount);
}

[ ] Nama class merepresentasikan konsep jelas.
[ ] Public methods merepresentasikan behavior, bukan manipulasi field acak.
[ ] Interface merepresentasikan role/capability, bukan sekadar mock seam.
[ ] Record digunakan untuk value/data transparan, bukan entity mutable.
[ ] Enum/sealed type digunakan jika state space tertutup.

[ ] Invalid state tidak bisa dibuat lewat constructor/factory.
[ ] Invalid transition tidak bisa dilakukan lewat public API.
[ ] Setter tidak melemahkan invariant.
[ ] Getter tidak memaksa caller mengambil keputusan internal.
[ ] Mutation method atomic secara semantic.

[ ] Behavior yang menjaga object truth berada dekat object.
[ ] Policy yang berubah-ubah dipisah menjadi collaborator.
[ ] I/O dan external orchestration tidak bocor ke entity/value object.
[ ] Use case mengkoordinasi, bukan mengambil alih semua domain behavior.

[ ] Contract polymorphic jelas.
[ ] Semua implementation memenuhi pre/postcondition supertype.
[ ] Tidak ada instanceof/switch yang mengindikasikan missing behavior tanpa alasan.
[ ] Jika memakai sealed + switch, variasi memang tertutup.

public class LoanApplication {
    private String id;
    private String applicantId;
    private BigDecimal amount;
    private String status;
    private LocalDate submittedDate;

    public String getId() { return id; }
    public void setId(String id) { this.id = id; }
    public BigDecimal getAmount() { return amount; }
    public void setAmount(BigDecimal amount) { this.amount = amount; }
    public String getStatus() { return status; }
    public void setStatus(String status) { this.status = status; }
}

public final class LoanApplication {
    private final LoanApplicationId id;
    private final ApplicantId applicantId;
    private Money requestedAmount;
    private LoanApplicationStatus status;
    private LocalDate submittedDate;

    public static LoanApplication draft(
            LoanApplicationId id,
            ApplicantId applicantId,
            Money requestedAmount
    ) {
        return new LoanApplication(id, applicantId, requestedAmount, LoanApplicationStatus.DRAFT, null);
    }

    public void submit(LocalDate today) {
        if (status != LoanApplicationStatus.DRAFT) {
            throw new IllegalStateException("Only draft applications can be submitted");
        }
        this.status = LoanApplicationStatus.SUBMITTED;
        this.submittedDate = Objects.requireNonNull(today);
    }

    public void approve() {
        if (status != LoanApplicationStatus.SUBMITTED) {
            throw new IllegalStateException("Only submitted applications can be approved");
        }
        this.status = LoanApplicationStatus.APPROVED;
    }
}

All classes have only fields, getters, setters.
All behavior lives in services.

UserService interface has exactly one UserServiceImpl.
No alternative implementation.
No meaningful role abstraction.

Subclass exists only to reuse helper methods/fields.

Every class hides everything, but no useful behavior emerges.

What is the stable concept?
What is the changing policy?
Where is the invariant?
What does the type promise?
What should be impossible?
What should callers not need to know?
What can vary without changing the public API?