Question

我正在玩Java实用程序功能。我有以下代码：

public class Checker<T>{

  private T value;
  private Function<T, T> callback;

  private Checker(T value) {
    this.value = value;
  }

  public static Checker when(String o) {
    return new Checker<String>(o);
  }

  public static Checker when(int o) {
    return new Checker<Integer>(o);
  }

  public Checker then(Function<T, T> callback) {
    this.callback = callback;
    return this;
  }

  public void execute() {
    if (this.value instanceof String) {
      this.callback.apply("123");
    }
    if (this.value instanceof Integer) {
      this.callback.apply(123);
    }
  }

  Checker.when("123").then(str -> {
    return "";
  }).execute();

  Checker.when(123).then(str -> {
    return "";
  }).execute();

现在我在this.callback.apply("123")收到错误，因为它需要T而无法将其投放到String。

是否可以为Function<T,T>设置通用返回类型？我可以发送T，但之后在我的lambda中收到Object，但我想要String或Integer。

Answer 1

我在Checker课程中做了一些对我有意义的修改。我删除了所有原始类型，并使用了value中的execute成员。我添加了返回类型execute，以便能够打印其结果。

class Checker<T>{

  private T value;
  private Function<T, T> callback;

  private Checker(T value) {
    this.value = value;
  }

  public static Checker<String> when(String o) {
    return new Checker<>(o);
  }

  public static Checker<Integer> when(int o) {
    return new Checker<>(o);
  }

  public Checker<T> then(Function<T, T> callback) {
    this.callback = callback;
    return this;
  }

  public T execute() {
    return this.callback.apply(value);
  }

  public static void main (String[] args) {
    Checker.when("123").then(str -> {
      return "." + str + ".";
    }).execute();

    Checker.when(123).then(i -> {
      return i + 100;
    }).execute();
  }
}

现在，当您通过以下方式检查课程时

System.out.println (Checker.when("123").then(str -> "." + str + ".").execute());
System.out.println (Checker.when(123).then(i -> i + 100).execute());

你得到：

.123.
223

Answer 2

此代码甚至可以进一步简化，如下所示：

static class Checker<T> {

    private final T value;

    private UnaryOperator<T> callback;

    private Checker(T value) {
        this.value = value;
    }

    public static <T> Checker<T> when(T o) {
        return new Checker<>(o);
    }

    public Checker<T> then(UnaryOperator<T> callback) {
        this.callback = callback;
        return this;
    }

    public T execute() {
        return this.callback.apply(value);
    }
}

Answer 3

正如其他人所建议的那样，代码可以简化，但为什么不能使调用成为可链接的，也就是最终的类，这样你就会有一个简单而干净的模型：

final class Checker<T> {

    private final T value;

    private final UnaryOperator<T> callback;

    private Checker(T value, UnaryOperator<T> callback) {
        this.value = value;
        this.callback = callback;
    }

    public static <T> Checker<T> when(T t) {
        return new Checker<>(t, UnaryOperator.identity());
    }

    public Checker<T> then(UnaryOperator<T> callback) {
        return new Checker<>(value, t -> callback.apply(this.callback.apply(t)));
    }

    public T execute() {
        return callback.apply(value);
    }
}

而不是在this中返回then()这种方法返回一个完全新的Checker实例

使用Function.apply的Java泛型

3 个答案: