Soyutlama ve Dört Sütun — Hangi Değişikliğe Hangisi Yardım Eder?

1
public final class Account {
2

3
    private final String iban;
4
    private final BigDecimal overdraftLimit;
5
    private BigDecimal balance;          // nobody outside can set it
6

7
    public Account(String iban, BigDecimal overdraftLimit) {
8
        this.iban = iban;
9
        this.overdraftLimit = overdraftLimit;
10
        this.balance = BigDecimal.ZERO;
11
    }
12

13
    public void deposit(BigDecimal amount) {
14
        requirePositive(amount);
15
        balance = balance.add(amount);
16
    }
17

18
    // The only way down: the overdraft rule lives here and nowhere else.
19
    public void withdraw(BigDecimal amount) {
20
        requirePositive(amount);
21
        BigDecimal next = balance.subtract(amount);
22
        if (next.compareTo(overdraftLimit.negate()) < 0) {
23
            throw new InsufficientFundsException(iban, amount);
24
        }
25
        balance = next;
26
    }
27

28
    public BigDecimal balance() {
29
        return balance;
30
    }
31

32
    private static void requirePositive(BigDecimal amount) {
33
        if (amount.signum() <= 0) throw new IllegalArgumentException("Tutar pozitif olmalı");
34
    }
35
}

1
// Abstraction: what a payment method does, not how.
2
public interface PaymentMethod {
3

4
    PaymentResult pay(Account from, BigDecimal amount);
5

6
    BigDecimal fee(BigDecimal amount);
7
}

1
// Polymorphism: a new kind is a new class. PaymentService, the fee report and
2
// the monthly statement call method.pay() / method.fee() and never change.
3
public final class QrPayment implements PaymentMethod {
4

5
    private final FeePolicy feePolicy;
6
    private final QrNetwork network;
7

8
    public QrPayment(FeePolicy feePolicy, QrNetwork network) {
9
        this.feePolicy = feePolicy;
10
        this.network = network;
11
    }
12

13
    @Override
14
    public PaymentResult pay(Account from, BigDecimal amount) {
15
        from.withdraw(amount.add(fee(amount)));
16
        return network.settle(amount);
17
    }
18

19
    @Override
20
    public BigDecimal fee(BigDecimal amount) {
21
        return feePolicy.feeFor(amount);
22
    }
23
}

1
// Composition over a shared base class: changing the card fee cannot touch
2
// transfers, because each payment kind holds its own policy object.
3
public interface FeePolicy {
4

5
    BigDecimal feeFor(BigDecimal amount);
6

7
    static FeePolicy flat(BigDecimal fee) {
8
        return amount -> fee;
9
    }
10

11
    static FeePolicy percent(BigDecimal rate, BigDecimal minimum) {
12
        return amount -> amount.multiply(rate).setScale(2, RoundingMode.HALF_EVEN).max(minimum);
13
    }
14
}

1
class TransferServiceTest {
2

3
    // The service asks for a BankGateway, so the test can hand it a fake.
4
    private final RecordingGateway gateway = new RecordingGateway();
5
    private final TransferService service = new TransferService(gateway);
6

7
    @Test
8
    void sendsTheTransferThroughTheGateway() {
9
        Account from = new Account("TR01", BigDecimal.ZERO);
10
        from.deposit(new BigDecimal("100.00"));
11

12
        service.transfer(from, "TR02", new BigDecimal("40.00"));
13

14
        assertThat(gateway.sent()).containsExactly(new SentTransfer("TR01", "TR02", new BigDecimal("40.00")));
15
        assertThat(from.balance()).isEqualByComparingTo("60.00");
16
    }
17
}