/**
 * 通过自定义函数式接口实现数据类型转换
 *
 * @return 24
 */
private static void convertTest01() {
    ConvertFunctionInterface<Integer, String> convert = t -> String.valueOf(t);
    String ret = convert.convert(2);
    System.out.println(ret+4);
}

/**
 * 使用"::"运算符更精简
 *
 * @return 24
 */
private static void convertTest02() {
    ConvertFunctionInterface<Integer, String> convert = String::valueOf;
    String ret = convert.convert(2);
    System.out.println(ret+4);//24
}

/**
 * 使用"::"运算符更精简
 * convertTest03(2, String::valueOf);
 *
 * @return 24
 */
private static void convertTest03(Integer t, ConvertFunctionInterface<Integer, String> convertFI) {
    String ret = convertFI.convert(t) + 4;
    System.out.println(ret);
}

/**
 * convertTest04("myFunctionInterfaceTest", ObjectUtil::hump2Line);
 *
 * @param t
 * @param convertFI
 * @return my_function_interface_test
 */
private static void convertTest04(String t, ConvertFunctionInterface<String, String> convertFI) {
    String ret = convertFI.convert(t);
    System.out.println(ret);
}

java8提供了Function接口（接收一个功能参数t，并返回一个功能结果R。）

所以，一定要了解清楚，你要定义的方法，是否已经存在，不要重复造轮子，编写代码的大忌，费力不讨好。?

/**
 * java8提供了Function接口（接收一个功能参数t，并返回一个功能结果R。）
 *
 * convertTest05("myFunctionInterfaceTest", ObjectUtil::hump2Line);
 *
 * @param t
 * @param convertFI
 * @return my_function_interface_test
 */
private static void functionTest05(String t, Function<String, String> function) {
    String ret = function.apply(t);
    System.out.println(ret);//my_function_interface_test
}

@FunctionalInterface
public interface LogFunction {
    public void log();
}

public static  void logTest01(LogFunction logFunction){
    logFunction.log();
}

public static  void logTest011(){
    //调用log方法，方法的参数是一个接口，所以可以传递接口的实现类对象
    logTest01(new LogFunction() {
        @Override
        public void log() {
            System.out.println("函数式接口练习");
        }
    });
}

//调用log方法，方法的参数是一个函数式接口，所以，可以使用lambda表达式
public static  void logTest012(){
    //调用log方法，方法的参数是一个接口，所以可以传递接口的实现类对象
    logTest01(() -> {
        System.out.println("函数式接口练习");
    });
}

//简化lambda表达式
public static  void logTest013(){
    logTest01(() -> System.out.println("函数式接口练习"));
}

package com.example.demo.java8;

@FunctionalInterface
public interface LogFunction2<T extends Student> {
    public void log(T t);
}

public static  void logTest02(Student student, LogFunction2 logFunction2){
    logFunction2.log(student);
}

public static  void logTest021(Student student){
    logTest02(student, new LogFunction2<Student>() {
        @Override
        public void log(Student t) {
            String ret = t.getId() + "->" + t.getName() + "->" + t.getAge();
            System.out.println(ret);//1->z->18
        }
    });
}

// lambda表达式写法
public static  void logTest022(Student student){
    logTest02(student, (Student t) -> {
        String ret = t.getId() + "->" + t.getName() + "->" + t.getAge();
        System.out.println(ret);
    });
}

package com.example.demo.java8;

@FunctionalInterface
public interface LogFunction3<T extends Student, R extends Teacher> {
    public R build(T t);
}

public static  void logTest03(Student student, LogFunction3 logFunction3){
    logFunction3.build(student);
}

// Teacher(id=1, name=z)
public static  void logTest031(Student student){
    logTest03(student, new LogFunction3<Student, Teacher>() {
        @Override
        public Teacher build(Student s) {
            Teacher t = new Teacher();
            t.setId(s.getTeacherId());
            t.setName(s.getTeacherName());
            System.out.println(t);
            return t;
        }
    });
}

package com.example.demo.java8;

import lombok.Data;

@Data
public class Student {
    private Integer id;
    private String name;
    private Integer age;
    private Integer teacherId;
    private String teacherName;
}