Java泛型函数实现空安全：链式调用编译报错问题求助

在Java中处理嵌套对象时，形如game.getPlayer().getState().getPositionInfo().getCurrent().getX();的链式调用极易因空引用抛出NullPointerException。我希望实现一个泛型方法，在调用链式路径时自动检查空值，返回null而非抛出异常（暂不考虑错误处理逻辑）。但编写的示例代码中，Check1（基础函数映射）可正常运行，Check2（嵌套类型调用）和Check3（跨类型链式调用）均无法编译，报错信息为java: incompatible types: incompatible parameter types in lambda expression，使用OpenJDK 22，求解决编译问题。

问题代码 #

import java.util.function.Function;

public class Main {

    public static void main(String[] args) {
        // Check 1: baseline - "normal" function mappings
        SAVE.TY_Baseline(b -> b.contains("a"), "aoiudssaiud"); // works

        // Check 2: nested types
        Team t = new Team(new Team(null));
        Team t1 = SAVE.TY_Chained(() -> t.getTeam(), z -> z.getTeam()); // 编译失败

        // Check 3: String -> boolean -> String
        String g = "Hi !";
        // 编译失败且类型不匹配
        Team t2 = SAVE.TY_Chained(() -> g.contains("Hi"), b -> b ? "contained" : "not contained"); 
    }

    public static class Team {
        private Team t = null;
        public Team(Team t) {
            this.t = t;
        }
        public Team getTeam() {
            return t;
        }
    }

    public static interface SAVE {
        public static <A, B> B TY_Chained(Function<Void, A> first , Function<A, B> second) {
            A firstResult = first.apply(null);
            if (firstResult == null)
                return null;
            return second.apply(firstResult);
        }
        public static <A,B> B TY_Baseline(Function<A,B> oo, A in) {
            return oo.apply(in);
        }
    }
}

问题原因 #

1. 参数类型设计不合理：TY_Chained的第一个参数使用Function<Void, A>，虽然可以用() -> ...形式的lambda适配，但这种写法违背了Function的语义（需要输入参数），会导致编译器无法准确推断泛型参数A的类型，进而引发lambda参数类型不兼容的错误。
2. Check3存在类型不匹配：代码试图将String类型的返回值赋值给Team类型变量，属于明显的类型错误，即使编译通过也会运行报错。

解决方案 #

1. 重构TY_Chained方法，使用Supplier替代Function<Void, A> #

Supplier<A>专门用于无参数返回值的场景，语义更清晰，能帮助编译器准确推断类型，解决lambda参数不兼容的问题。

2. 修正Check3的类型不匹配问题 #

将接收返回值的变量类型改为对应类型（如String）。

修改后的代码 #

import java.util.function.Function;
import java.util.function.Supplier;

public class Main {

    public static void main(String[] args) {
        // Check 1: baseline - "normal" function mappings
        SAVE.TY_Baseline(b -> b.contains("a"), "aoiudssaiud"); // works

        // Check 2: nested types - 编译通过
        Team t = new Team(new Team(null));
        Team t1 = SAVE.TY_Chained(() -> t.getTeam(), z -> z.getTeam()); 

        // Check 3: String -> boolean -> String - 编译通过，修正类型匹配
        String g = "Hi !";
        String result = SAVE.TY_Chained(() -> g.contains("Hi"), b -> b ? "contained" : "not contained"); 
    }

    public static class Team {
        private Team t = null;
        public Team(Team t) {
            this.t = t;
        }
        public Team getTeam() {
            return t;
        }
    }

    public static interface SAVE {
        // 改用Supplier<A>作为第一个参数
        public static <A, B> B TY_Chained(Supplier<A> first , Function<A, B> second) {
            A firstResult = first.get();
            if (firstResult == null)
                return null;
            return second.apply(firstResult);
        }
        public static <A,B> B TY_Baseline(Function<A,B> oo, A in) {
            return oo.apply(in);
        }
    }
}

扩展：支持更长的链式调用 #

如果需要支持三步及以上的链式调用，可以重载TY_Chained方法：

public static <A, B, C> C TY_Chained(Supplier<A> first, Function<A, B> second, Function<B, C> third) {
    A a = first.get();
    if (a == null) return null;
    B b = second.apply(a);
    if (b == null) return null;
    return third.apply(b);
}

这样就可以处理类似game.getPlayer().getState().getX()的链式调用：

Integer x = SAVE.TY_Chained(() -> game.getPlayer(), Player::getState, State::getX);

内容的提问来源于stack exchange，提问作者TeaTiMe08