The problem I have in hand is that I methods `one(), two(), three(), four()` that have a different return types say, `A, B, C, D` and I need to spawn variable numbers of threads (one for each method depending on the use case. This means I would want to call a subset of methods at a time.) Now, am using the `cachedThreadPool` to submit these callables. Some code below:

```
public class Dispatcher {

  public void dispatch(List<MethodNames> methodNames) {
    //Now I am going to iterate through the list of methodNames
    //And submit each method to the `ExecutorService`
    for(MethodNames m : methodNames) {
      switch(m) {
        case ONE: //submit one()
                  //wait and get the future
                  Future<A> future = cachePool.submit(new Callable<A>() {
                    @Override
                    public A call() {
                      return one();
                    });
                  A response = future.get(); 
             break;
        ....
      }
    }
  }
}

public enum MethodNames {
  ONE, TWO, THREE, FOUR
}

//Example methods:
public A one() {
}

public B two() {
}

```

My question is how do the above such that all the method calls are made without having to wait for one to finish. Also, how do I gather all the `futures` and wait for them to finish cause all the futures have a different generic type `Future<A>, Future<B>` etc. I make the call to `submit()` inside the case statement so I don't have the access to the returned `Future<T>` outside the case. Now I could do an `if, else` instead of the `for` loop but I am trying to figure out if there is a better way to achieve this.