以不同的行为解决价值，最好没有其他行为

Question

这是我想做的

首先启动可选变量，然后执行过程。 如果程序a收益率为null，请尝试过程B，依此类推。 如果所有过程仍然产生无效，请抛出例外情况，

#pseudocode

Optional<> someVariable;

if (someVariable is empty):
  fetch value through procedure A
  assign to someVariable
if (someVariable is empty):
  fetch value through procedure B
  assign to someVariable
.
.
.
if still empty:
  throw exception

问题是我真的不想通过已解决该值的过程A，并且如果添加更多过程，我认为它是可扩展的 有任何输入吗？

Answer 1

这没有其他

public static void main(String[] args) {

    Integer result = null;
    if ((result = procA()) == null && (result = procB()) == null){
        System.out.println("throw ex");
    }
}

static Integer procA ()  {
    
    System.out.println("procA");
    return null;
}

static Integer procB () {
    System.out.println("procB");
    return null;
}

尝试更改方法返回的值的值。

Answer 2

使用JDK 11（可能是JDK 8+）：

public class MyClass {

  private Integer procedureA() {
    return ...
  }

  private Integer procedureB() {
    return ...
  }

  ...
  
  private final List<Supplier<Integer>> procedures = List.of(
    this::procedureA,
    this::procedureB,
    // ... as many as you want
  );

  // This code will stay the same, no matter how many procedures you add
  public Optional<Integer> readValue() {
    Integer someValue =  procedures
            .stream()
            .map( Supplier::get )
            .filter( Objects::nonNull )
            .findFirst()
            .orElseThrow( () -> new RuntimeException( "Exception!" )   );
   // I don't think it makes sense to return an optional in this case
   // but you can do it if you want to
   return Optional.of(someValue);
  }
}

这几乎与其他人建议的方法相同，但是使用最新的Java，您可以编写比我在其他答案中看到的代码更紧凑和可以理解的。

Answer 3

一个详细的，但希望可以阅读的方法：

Object someVariable = Stream.of(initialValue)
    .map(obj -> obj == null ? procedureA() : obj)
    .map(obj -> obj == null ? procedureB() : obj)
    .findFirst()
    .orElseThrow(NoSuchElementException::new); // or whatever exception you want

Answer 4

如果您的过程相对简单，并且可以称为运行 s。然后，我们可以创建一个可运行的列表，并使用for loop执行运行方法：

private class ProcedureA implements Runnable {
    @Override
    public void run() {
        someVariable = try fetching value
    }
}

// private class ProcedureB/C/D/E implements Runnable {}

List<Runnable> procedures = List.of(new ProcedureA(), new ProcedureB(), ...);
for (Runnable procedure : procedures) {
    if (someVariable.isPresent()) {
        break;
    }
    procedure.run();
}

if (someVariable.isEmpty()) {
    throw exception;
}

如果过程有些复杂，并且会返回值或进行参数，那么我们可以使用callable 或使用运行方法定义自定义过程接口。

public interface Procedure {
   V running(arg1, arg2);
}

public class ProcedureA implements Procedure {
    @Override
    public V running(arg1, arg2) {}
}

List<Procedure> procedures = List.of(new ProcedureA() ...);