BAEL-9399 (#18740)

Co-authored-by: Wynn Teo <[email protected]>

Author: wynnteo

core-java-modules/core-java-function/src/main/java/com/baeldung/functionpointer/AddCommand.java

@@ -0,0 +1,9 @@
+package com.baeldung.functionpointer;
+
+public class AddCommand implements MathOperation {
+
+    @Override
+    public int operate(int a, int b) {
+        return a + b;
+    }
+}

core-java-modules/core-java-function/src/main/java/com/baeldung/functionpointer/AdvancedCalculator.java

@@ -0,0 +1,10 @@
+package com.baeldung.functionpointer;
+
+import java.util.function.BiFunction;
+
+public class AdvancedCalculator {
+
+    public int compute(int a, int b, BiFunction<Integer, Integer, Integer> operation) {
+        return operation.apply(a, b);
+    }
+}

core-java-modules/core-java-function/src/main/java/com/baeldung/functionpointer/Calculator.java

@@ -0,0 +1,7 @@
+package com.baeldung.functionpointer;
+
+public class Calculator {
+    public int calculate(int a, int b, MathOperation operation) {
+        return operation.operate(a, b);
+    }
+}

core-java-modules/core-java-function/src/main/java/com/baeldung/functionpointer/DynamicOps.java

@@ -0,0 +1,8 @@
+package com.baeldung.functionpointer;
+
+public class DynamicOps {
+
+    public int power(int a, int b) {
+        return (int) Math.pow(a, b);
+    }
+}

core-java-modules/core-java-function/src/main/java/com/baeldung/functionpointer/EnumCalculator.java

@@ -0,0 +1,8 @@
+package com.baeldung.functionpointer;
+
+public class EnumCalculator {
+
+    public int calculate(int a, int b, MathOperationEnum operation) {
+        return operation.apply(a, b);
+    }
+}

core-java-modules/core-java-function/src/main/java/com/baeldung/functionpointer/MathOperation.java

@@ -0,0 +1,6 @@
+package com.baeldung.functionpointer;
+
+public interface MathOperation {
+
+    int operate(int a, int b);
+}

core-java-modules/core-java-function/src/main/java/com/baeldung/functionpointer/MathOperationEnum.java

@@ -0,0 +1,33 @@
+package com.baeldung.functionpointer;
+
+public enum MathOperationEnum {
+    ADD {
+        @Override
+        public int apply(int a, int b) {
+            return a + b;
+        }
+    },
+    SUBTRACT {
+        @Override
+        public int apply(int a, int b) {
+            return a - b;
+        }
+    },
+    MULTIPLY {
+        @Override
+        public int apply(int a, int b) {
+            return a * b;
+        }
+    },
+    DIVIDE {
+        @Override
+        public int apply(int a, int b) {
+            if (b == 0) {
+                throw new ArithmeticException("Division by zero");
+            }
+            return a / b;
+        }
+    };
+
+    public abstract int apply(int a, int b);
+}

core-java-modules/core-java-function/src/main/java/com/baeldung/functionpointer/MathUtils.java

@@ -0,0 +1,8 @@
+package com.baeldung.functionpointer;
+
+public class MathUtils {
+
+    public static int add(int a, int b) {
+        return a + b;
+    }
+}

core-java-modules/core-java-function/src/test/java/com/baeldung/functionpointer/FunctionPointerUnitTest.java

@@ -0,0 +1,78 @@
+package com.baeldung.functionpointer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.lang.reflect.Method;
+import java.util.function.BiFunction;
+
+import org.junit.jupiter.api.Test;
+
+public class FunctionPointerUnitTest {
+
+    @Test
+    void givenAnonymousAddition_whenCalculate_thenReturnSum() {
+        Calculator calculator = new Calculator();
+        MathOperation addition = new MathOperation() {
+            @Override
+            public int operate(int a, int b) {
+                return a + b;
+            }
+        };
+        int result = calculator.calculate(2, 3, addition);
+        assertEquals(5, result);
+    }
+
+    @Test
+    void givenLambdaSubtraction_whenCalculate_thenReturnDifference() {
+        Calculator calculator = new Calculator();
+        MathOperation subtract = (a, b) -> a - b;
+        int result = calculator.calculate(10, 4, subtract);
+        assertEquals(6, result);
+    }
+
+    @Test
+    void givenBiFunctionMultiply_whenApply_thenReturnProduct() {
+        BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b;
+        int result = multiply.apply(6, 7);
+        assertEquals(42, result);
+    }
+
+    @Test
+    void givenBiFunctionDivide_whenCompute_thenReturnQuotient() {
+        AdvancedCalculator calculator = new AdvancedCalculator();
+        BiFunction<Integer, Integer, Integer> divide = (a, b) -> a / b;
+        int result = calculator.compute(20, 4, divide);
+        assertEquals(5, result);
+    }
+
+    @Test
+    void givenMethodReference_whenCalculate_thenReturnSum() {
+        Calculator calculator = new Calculator();
+        MathOperation operation = MathUtils::add;
+        int result = calculator.calculate(5, 10, operation);
+        assertEquals(15, result);
+    }
+
+    @Test
+    void givenReflection_whenInvokePower_thenReturnResult() throws Exception {
+        DynamicOps ops = new DynamicOps();
+        Method method = DynamicOps.class.getMethod("power", int.class, int.class);
+        int result = (int) method.invoke(ops, 2, 3);
+        assertEquals(8, result);
+    }
+
+    @Test
+    void givenAddCommand_whenCalculate_thenReturnSum() {
+        Calculator calculator = new Calculator();
+        MathOperation add = new AddCommand();
+        int result = calculator.calculate(3, 7, add);
+        assertEquals(10, result);
+    }
+
+    @Test
+    void givenEnumSubtract_whenCalculate_thenReturnResult() {
+        EnumCalculator calculator = new EnumCalculator();
+        int result = calculator.calculate(9, 4, MathOperationEnum.SUBTRACT);
+        assertEquals(5, result);
+    }
+}