Java方法引用初始化与调用标准模式及未设置引用问题咨询

首先我先把你给出的代码补全完整，这样能更清晰地展示问题场景（毕竟你提供的ClassA代码不完整，且缺少ClassB1/ClassB2的定义）：

import java.util.function.Consumer;

public class ClassA {
    public ClassA() {
        ClassB1 objB1 = new ClassB1();
        ClassB2 objB2 = new ClassB2();
        
        // 有时可能会注释掉这两行，不设置方法引用
        objB1.setFunctionA(this::functionA);
        objB2.setFunctionA(this::functionA);
        
        objB1.functionB();
        objB2.functionB();
    }

    public void functionA(Integer x) {
        x *= 2;
    }
}

class ClassB1 {
    private Consumer<Integer> functionA;

    public void setFunctionA(Consumer<Integer> functionA) {
        this.functionA = functionA;
    }

    public void functionB() {
        // 如果没设置functionA，这里会直接抛NullPointerException
        functionA.accept(10);
    }
}

class ClassB2 {
    private Consumer<Integer> functionA;

    public void setFunctionA(Consumer<Integer> functionA) {
        this.functionA = functionA;
    }

    public void functionB() {
        functionA.accept(20);
    }
}

核心问题就是：当setFunctionA没有被调用时，functionA变量为null，调用functionB会触发空指针异常。针对这个场景，我给你几个实用的解决方案：

方案1：用Optional做显式的空安全处理 #

Java 8引入的Optional可以很好地表达“值可能不存在”的语义，在ClassB1/ClassB2中用它包装方法引用，调用前先判断是否存在：

class ClassB1 {
    // 初始化为空的Optional
    private Optional<Consumer<Integer>> functionA = Optional.empty();

    public void setFunctionA(Consumer<Integer> functionA) {
        // 允许传入null，自动转为空Optional
        this.functionA = Optional.ofNullable(functionA);
    }

    public void functionB() {
        // 只有当方法引用存在时才执行
        functionA.ifPresent(func -> func.accept(10));
    }
}

这个方案的优点是代码语义清晰，一眼就能看出functionA是可选的，而且完全避免了空指针。

方案2：设置默认的空实现 #

如果希望即使不注入方法引用，functionB也能正常运行不报错，可以给functionA设置一个默认的空操作：

class ClassB1 {
    // 默认是一个什么都不做的Consumer
    private Consumer<Integer> functionA = x -> {};

    public void setFunctionA(Consumer<Integer> functionA) {
        // 可选：如果外部传入null，不覆盖默认值
        if (functionA != null) {
            this.functionA = functionA;
        }
    }

    public void functionB() {
        // 永远不会触发空指针，没注入的话就执行空操作
        functionA.accept(10);
    }
}

这种方案对调用方最友好，不需要担心忘记设置方法引用导致程序崩溃。

方案3：抛出明确的异常（适合方法引用是必填的场景） #

如果functionA理论上是必须设置的，只是偶尔会忘记，那不如在调用functionB前主动检查，抛出更明确的异常，方便调试：

import java.util.Objects;

class ClassB1 {
    private Consumer<Integer> functionA;

    public void setFunctionA(Consumer<Integer> functionA) {
        // 注入时就强制非空，从源头避免null
        this.functionA = Objects.requireNonNull(functionA, "functionA cannot be null");
    }

    public void functionB() {
        // 双重保险，防止没调用setFunctionA
        Objects.requireNonNull(functionA, "Please call setFunctionA before invoking functionB");
        functionA.accept(10);
    }
}

这样如果忘记设置方法引用，会抛出带有明确提示的NullPointerException，比模糊的空指针更容易定位问题。

方案4：空对象模式（适合需要默认逻辑的场景） #

如果需要在未注入方法引用时执行特定逻辑（比如打日志、统计），可以定义一个空实现类：

class EmptyFunctionA implements Consumer<Integer> {
    @Override
    public void accept(Integer x) {
        // 这里可以加自定义的默认逻辑
        System.out.println("No functionA provided for ClassB1, skipping operation with value: " + x);
    }
}

class ClassB1 {
    private Consumer<Integer> functionA = new EmptyFunctionA();

    public void setFunctionA(Consumer<Integer> functionA) {
        // 传入null时仍使用空对象
        this.functionA = functionA != null ? functionA : new EmptyFunctionA();
    }

    public void functionB() {
        functionA.accept(10);
    }
}

这个方案扩展性很强，后续可以随时修改空对象的逻辑，不需要改动调用方代码。

内容的提问来源于stack exchange，提问作者Ilya K.