Lambda ve Fonksiyonel Arayüzler — Lambda Neyi Yakalar?

1
@FunctionalInterface
2
public interface FeeRule {
3

4
    BigDecimal apply(Customer customer, BigDecimal fee);   // the single abstract method
5

6
    // Composition without new classes: this rule, then the next one.
7
    default FeeRule andThen(FeeRule next) {
8
        return (customer, fee) -> next.apply(customer, this.apply(customer, fee));
9
    }
10

11
    static FeeRule identity() {
12
        return (customer, fee) -> fee;
13
    }
14
}

1
public final class Rules {
2

3
    private Rules() {}
4

5
    // A constant rule: a lambda stored in a field.
6
    public static final FeeRule ROUND_TO_KURUS =
7
            (customer, fee) -> fee.setScale(2, RoundingMode.HALF_UP);
8

9
    // A rule factory: the lambda captures `percent`, which is effectively final.
10
    public static FeeRule percentOff(int percent) {
11
        BigDecimal factor = BigDecimal.valueOf(100 - percent).movePointLeft(2);
12
        return (customer, fee) -> fee.multiply(factor);
13
    }
14

15
    // Built from a predicate: rules can be conditional without an if in the engine.
16
    public static FeeRule when(Predicate<Customer> condition, FeeRule rule) {
17
        return (customer, fee) -> condition.test(customer) ? rule.apply(customer, fee) : fee;
18
    }
19

20
    public static boolean isLongStanding(Customer customer) {   // used as a method reference
21
        return customer.yearsWithBank() >= 3;
22
    }
23
}

1
public class FeeEngine {
2

3
    private final FeeRule pipeline;
4

5
    public FeeEngine(List<FeeRule> rules) {
6
        // reduce: fold the list into ONE composed rule, once, at construction.
7
        this.pipeline = rules.stream().reduce(FeeRule.identity(), FeeRule::andThen);
8
    }
9

10
    public BigDecimal feeFor(Customer customer, BigDecimal baseFee) {
11
        return pipeline.apply(customer, baseFee);
12
    }
13
}

1
public class CaptureRules {
2

3
    static int totalTransfers(List<Customer> customers) {
4
        int total = 0;
5
        // customers.forEach(c -> total += c.transfersThisMonth());
6
        //   does not compile: `total` is not effectively final. A lambda may run
7
        //   later or on another thread, so Java forbids mutating captured locals.
8

9
        // The functional answer is not a workaround, it is the computation itself:
10
        return customers.stream().mapToInt(Customer::transfersThisMonth).sum();
11
    }
12
}

1
public class Main {
2

3
    public static void main(String[] args) {
4
        var engine = new FeeEngine(List.of(
5
                Rules.when(Rules::isLongStanding, Rules.percentOff(10)),   // method reference as Predicate
6
                Rules.percentOff(5),                                       // this month's mobile campaign
7
                Rules.ROUND_TO_KURUS));
8

9
        BigDecimal swiftFee = new BigDecimal("200.00");                   // illustrative base fee
10
        Customer longStanding = new Customer("C-1", 5, 4);                // 5 years, 4 transfers
11
        Customer newcomer = new Customer("C-2", 0, 4);
12

13
        System.out.println(engine.feeFor(longStanding, swiftFee));   // 171.00  (200 × 0.90 × 0.95)
14
        System.out.println(engine.feeFor(newcomer, swiftFee));       // 190.00  (200 × 0.95)
15
        System.out.println(CaptureRules.totalTransfers(List.of(longStanding, newcomer)));   // 8
16
    }
17
}