Sınıf, Nesne ve Kapsülleme — Kuralı Kim Koruyor?

1
public final class Account {
2

3
    private final String iban;
4
    private final Money overdraftLimit;
5
    private final List<Movement> movements;
6
    private Money balance;
7

8
    // Rebuilds an account from its stored history: copy first, then check the copy.
9
    public Account(String iban, Money overdraftLimit, List<Movement> history) {
10
        this.iban = Objects.requireNonNull(iban, "iban");
11
        this.overdraftLimit = Objects.requireNonNull(overdraftLimit, "overdraftLimit");
12
        this.movements = new ArrayList<>(history);   // defensive copy: the caller's list stays theirs
13
        this.balance = new Money(BigDecimal.ZERO, overdraftLimit.currency());
14
        for (Movement movement : movements) {
15
            balance = balance.plus(movement.amount());
16
        }
17
        requireWithinLimit(balance);
18
    }
19

20
    public void deposit(Money amount, String description, Instant bookedAt) {
21
        requirePositive(amount);
22
        book(new Movement(bookedAt, amount, description));
23
    }
24

25
    public void withdraw(Money amount, String description, Instant bookedAt) {
26
        requirePositive(amount);
27
        requireWithinLimit(balance.minus(amount));   // check before any state changes
28
        book(new Movement(bookedAt, amount.negate(), description));
29
    }
30

31
    // Money is immutable, so handing it out opens no back door.
32
    public Money balance() {
33
        return balance;
34
    }
35

36
    // A read-only window: callers see new movements, only this class can add them.
37
    public List<Movement> movements() {
38
        return Collections.unmodifiableList(movements);
39
    }
40

41
    // The single door: the movement and the balance always change together.
42
    private void book(Movement movement) {
43
        movements.add(movement);
44
        balance = balance.plus(movement.amount());
45
    }
46

47
    private void requireWithinLimit(Money candidate) {
48
        if (candidate.isLessThan(overdraftLimit.negate())) {
49
            throw new IllegalStateException("overdraft limit exceeded on " + iban);
50
        }
51
    }
52

53
    private static void requirePositive(Money amount) {
54
        if (amount.amount().signum() <= 0) {
55
            throw new IllegalArgumentException("amount must be positive");
56
        }
57
    }
58
}

1
public record Money(BigDecimal amount, Currency currency) {
2

3
    public Money {
4
        Objects.requireNonNull(amount, "amount");
5
        Objects.requireNonNull(currency, "currency");
6
        // 10.005 TRY is a bug upstream, not something to round away here.
7
        amount = amount.setScale(currency.getDefaultFractionDigits(), RoundingMode.UNNECESSARY);
8
    }
9

10
    public static Money of(String amount, String currencyCode) {
11
        return new Money(new BigDecimal(amount), Currency.getInstance(currencyCode));
12
    }
13

14
    public Money plus(Money other) {
15
        requireSameCurrency(other);
16
        return new Money(amount.add(other.amount), currency);
17
    }
18

19
    public Money minus(Money other) {
20
        requireSameCurrency(other);
21
        return new Money(amount.subtract(other.amount), currency);
22
    }
23

24
    public Money negate() {
25
        return new Money(amount.negate(), currency);
26
    }
27

28
    public boolean isLessThan(Money other) {
29
        requireSameCurrency(other);
30
        return amount.compareTo(other.amount) < 0;
31
    }
32

33
    private void requireSameCurrency(Money other) {
34
        if (!currency.equals(other.currency)) {
35
            throw new IllegalArgumentException("currency mismatch: " + currency + " vs " + other.currency);
36
        }
37
    }
38
}

1
// Every field is immutable, so a movement can be shared freely once booked.
2
public record Movement(Instant bookedAt, Money amount, String description) {
3

4
    public Movement {
5
        Objects.requireNonNull(bookedAt, "bookedAt");
6
        Objects.requireNonNull(amount, "amount");
7
        Objects.requireNonNull(description, "description");
8
    }
9
}

1
// Counter-example. It compiles and "works", yet nothing keeps the balance
2
// equal to the sum of the movements or above the overdraft limit.
3
public class LeakyAccount {
4

5
    private Money balance;
6
    private List<Movement> movements;
7

8
    public LeakyAccount(List<Movement> movements) {
9
        this.movements = movements;   // keeps the caller's list: they can still change it
10
    }
11

12
    public Money getBalance() {
13
        return balance;
14
    }
15

16
    public void setBalance(Money balance) {   // any balance, limit or not
17
        this.balance = balance;
18
    }
19

20
    public List<Movement> getMovements() {
21
        return movements;   // the internal list itself: add() here skips the balance
22
    }
23
}