Polimorfizm ve Dinamik Bağlama — Kararı Kim Veriyor?

1
// One implementation per channel. Amounts come from the tariff config, not from code.
2
public sealed interface FeePolicy permits FastFee, EftFee, SwiftFee {
3

4
    BigDecimal feeFor(BigDecimal amount);
5
}
6

7
// Instant transfer: one flat fee.
8
record FastFee(BigDecimal flat) implements FeePolicy {
9
    @Override
10
    public BigDecimal feeFor(BigDecimal amount) {
11
        return flat;
12
    }
13
}
14

15
// Same-day interbank transfer: flat fee, waived for a premium segment.
16
record EftFee(BigDecimal flat, boolean premium) implements FeePolicy {
17
    @Override
18
    public BigDecimal feeFor(BigDecimal amount) {
19
        return premium ? BigDecimal.ZERO : flat;
20
    }
21
}
22

23
// International transfer: a percentage with a floor.
24
record SwiftFee(BigDecimal rate, BigDecimal minimum) implements FeePolicy {
25
    @Override
26
    public BigDecimal feeFor(BigDecimal amount) {
27
        return amount.multiply(rate).setScale(2, RoundingMode.HALF_UP).max(minimum);
28
    }
29
}

1
@Service
2
class TransferService {
3

4
    private final FeePolicies policies;       // picks the policy for a channel and customer
5
    private final BlockedIbans blocked;
6
    private final Ledger ledger;
7

8
    TransferService(FeePolicies policies, BlockedIbans blocked, Ledger ledger) {
9
        this.policies = policies;
10
        this.blocked = blocked;
11
        this.ledger = ledger;
12
    }
13

14
    @Transactional
15
    public TransferReceipt send(TransferRequest request) {
16
        if (blocked.contains(request.beneficiary())) {
17
            throw new BlockedBeneficiaryException(request.beneficiary());
18
        }
19
        FeePolicy policy = policies.forChannel(request.channel(), request.customerNo());
20
        // No switch on the channel: the JVM calls the feeFor of the object's real class.
21
        BigDecimal fee = policy.feeFor(request.amount());
22
        return ledger.post(request, fee);
23
    }
24
}

1
public final class Iban {
2

3
    private final String value;
4

5
    public Iban(String raw) {
6
        // "TR33 0006 1005 ..." and "tr330006 1005..." are the same account.
7
        this.value = raw.replace(" ", "").toUpperCase(Locale.ROOT);
8
    }
9

10
    // Object, not Iban: this replaces Object.equals, so HashSet and HashMap call it.
11
    @Override
12
    public boolean equals(Object other) {
13
        return other instanceof Iban iban && value.equals(iban.value);
14
    }
15

16
    @Override
17
    public int hashCode() {
18
        return value.hashCode();
19
    }
20

21
    @Override
22
    public String toString() {
23
        return value;
24
    }
25
}

1
// Counter-example. It looks right and its unit test passes:
2
// new BrokenIban("TR33...").equals(new BrokenIban("TR33...")) is true.
3
public final class BrokenIban {
4

5
    private final String value;
6

7
    public BrokenIban(String raw) {
8
        this.value = raw.replace(" ", "").toUpperCase(Locale.ROOT);
9
    }
10

11
    // An overload, not an override: the parameter is BrokenIban, not Object.
12
    // Set.contains calls equals(Object), which is still Object's identity check,
13
    // so a blocked IBAN read fresh from a request is never found in the set.
14
    public boolean equals(BrokenIban other) {
15
        return other != null && value.equals(other.value);
16
    }
17

18
    @Override
19
    public int hashCode() {
20
        return value.hashCode();
21
    }
22
}