函数式编程

• 传统的函数：调用函数传入的是参数，然后方法体内进行对传入的参数进行操作，
• 函数式编程：传递的是一种函数行为，调用的函数只是将参数与函数进行整合

测试函数式接口:

public class Test {
 
    public static void main(String[] args) {
        Test test = new Test();
        System.out.println(test.calculator(100, 20, (a, b) -> a + b));
        System.out.println(test.calculator(100, 20, (a, b) -> a - b));
        System.out.println(test.calculator(100, 20, (a, b) -> a * b));
        System.out.println(test.calculator(100, 20, (a, b) -> a / b));
        // 错误的，不属于函数式编程
        System.out.println(test.square(100, 20, (a) -> a * a));
    }
 
    /**
     * 定义一个计算器
     * 使用函数式接口实现函数式编程
     *
     * @param a
     * @param b
     * @param function
     * @return
     */
    public Integer calculator(Integer a, Integer b, MyFunInterface<Integer> function) {
        // 仅仅是将 a 和 b 与传入的函数 function 进行组合,具体需要做什么由传入的 function 决定
        Integer result = function.doSomething(a, b);
        return result;
    }
 
    /**
     * 这并不符合函数式编程，函数式编程，函数类型必须式接口类型，这里式 抽象类
     *
     * @param a
     * @param function
     * @return
     */
    public Integer square(Integer a, MyAbstract<Integer> function) {
        // 仅仅是将 a 和 b 与传入的函数 function 进行组合,具体需要做什么由传入的 function 决定
        Integer result = function.doSomething(a);
　　　　　return result;
    }
    
}

 

---

 

以下是函数式接口：

可以使用注解 @FunctionalInterface，校验，当然，函数式接口成立不成立与该注解没有关系，

当符合函数式接口规则式，不加注解 @FunctionalInterface 的接口，他同样是一个函数式接口，

当不符合函数式接口规则时，加上该注解编译不通过，所以规范来说，必须加 @FunctionalInterface

该注解就好比 @Override，当符合的时候加与不加注解不影响程序，当不成立的时候 加上注解他会强制提示你，不符合，编译不通过

@FunctionalInterface
public interface MyFunInterface<T> {
 
    /**
     * 定义一个函数式接口的方法, 这是一个清晰的函数式接口
     *
     * @param var1
     * @param var2
     * @return
     */
    T doSomething(T var1, T var2);
}

@FunctionalInterface
public interface MyFunInterface<T> {
 
    /**
     * 定义一个函数式接口的方法
     *
     * @param var1
     * @param var2
     * @return
     */
    T doSomething(T var1, T var2);
 
    /**
     * 测试的默认实现的方法方法, 函数式接口可以有多个放他，但是只能有一个式抽象的方法，其他方法必须默认方法体
     */
    default void defaultMethod() {
        System.out.println("这里不做任何操作");
    }
 
}

@FunctionalInterface
public interface MyFunInterface<T>  {
 
    /**
     * 定义一个函数式接口的方法
     *
     * @param var1
     * @param var2
     * @return
     */
    T doSomething(T var1, T var2);
 
    /**
     * 测试的默认实现的方法方法,，不影响函数式接口成立
     */
    default void defaultMethod() {
        System.out.println("这里不做任何操作");
    }
 
    /**
     * 该函数在父类 Object 中继承下来的，不影响函数式接口成立
     *
     * @return
     */
    @Override
    String toString();
 
}

@FunctionalInterface
public interface MyFunInterface<T> extends TestSuperInterface {
 
    /**
     * 定义一个函数式接口的方法
     *
     * @param var1
     * @param var2
     * @return
     */
    T doSomething(T var1, T var2);
 
    /**
     * 测试的默认实现的方法方法,必须默认方法，编写方法体
     */
    default void defaultMethod() {
        System.out.println("这里不做任何操作");
    }
 
    /**
     * 该函数在父类 Object 中继承下来的，不进行默认实现也是可以的,不影响函数式接口成立
     *
     * @return
     */
    @Override
    String toString();
}

 

---

以下不是函数式接口：

/**
 * 这样并不是函数式接口，函数式接口要求必须式一个接口,抽象类是不行的
 *
 * @author Alay
 * @date 2021-04-11 15:59
 * @project ScalaStudy
 */
@FunctionalInterface
public abstract class MyAbstract<T> {
/**
     * 子类自行实现
     *
     * @param var
     * @return
     */
    abstract T doSomething(T var);
}

@FunctionalInterface
public interface MyFunInterface<T> extends TestSuperInterface {
/**
     * 定义一个函数式接口的方法
     *
     * @param var1
     * @param var2
     * @return
     */
    T doSomething(T var1, T var2);
 
    /**
     * 此函数有父类接口继承而来,此处没有进行实现,此接口将再是函数式接口
     *
     * @param param
     */
　@Override
　　void tesMethod(String param);
}

 

---

测试的父类接口：

public interface TestSuperInterface {
    /**
     * 测试的方法,若此函数未默认实现,则会影响子类成文函数式接口的条件
     *
     * @param param
     */
    // void tesMethod(String param);
    default void tesMethod(String param) {
    }
}