静态方法参考泛型类型解决方案

Question

I am aware that this type of question has been posted before but even after checking all the links I could not come up with a solution for the problem that I am facing. Here is what I have and what I want it to do:

@FunctionalInterface
public interface ProcessExecute {
    <K, T> K executeProcess(T arguments);
}

A simple functional interface (so that it can be expressed as lambda) that takes a T argument (meaning you can give different arguments to it) and a K return type, meaning it will return a K object. Next, I have this:

public interface ProcessHandler {

   void initializeMap();

   Process retrieveProcess(String key,Object parameters);

   <K, T> K executeProcess(String key,T parameters);

   <K> K executeProcess(String key);

}

For the explanation to make sense, in the implementation of the above interface I have a HashMap that links a String key to a ProcessExecute item. So the ProcessHandler should simply take a String as a key, finds it in the map, then calls the ProcessExecute::executeProcess method on that object found in the map, and then it returns what needs to be returned (specified by the parameter type). Basically, the executeProcess in the ProcessHandler is the same as the one in the ProcessExecute. Now, I have the following implementation for the ProcessHandler: (I will only put a sample of it since the class is quite big, but it will suffice)

public class ProcessManager implements ProcessHandler {
   private static final Map<String, ProcessExecute> processMap = new HashMap<>();
   private static final ProcessHandler instance = new ProcessManager();

   public static ProcessHandler getInstance() {
      return instance;
   }
   //many other methods identical to executeRam (that return boolean/String/int and take String or other types as arguments
   private static Process executeRam(Void arguments) {
      Process ram = null;
      try {
          ram = new ProcessBuilder("free", "m").start();
      } catch (IOException e) {
          Log.printLog(TAG.ERROR, "Unable to run free -m command!");
      }
      return ram;
  }

  @Override
  public void initializeMap() {
  //many other declarations identical to this one
    ProcessExecute ramMonitor =ProcessManager::executeRam;
    processMap.put("ram", ramMonitor);
  }

  @Override
  public Process retrieveProcess(String key, Object arguments) {
      return (Process) processMap.get(key).executeProcess(arguments);
 }


  @Override
  public <K, T> K executeProcess(String key, T parameters) {
      return processMap.get(key).executeProcess(parameters);
  }

  @Override
  public <K> K executeProcess(String key) {
      return processMap.get(key).executeProcess(null);
  }

}

The problem is at compilation in the initializeMap() method : When declaring an item as

ProcessExecute xxx = ProcessManager:executeXXX;

it reports that Bad return type in method reference:can not convert java.lang.Process to K (this is specific for the executeRam method, but it extends to all other methods, of course, eg. can not convert java.lang.String and so on).

What am I doing wrong? What needs to be changed so that it can be compiled? To clarify what I want it to do in that class, I want when calling the executeProcess(String key, T parameters) in the ProcessManager, for it to search for that key in the HashMap, then execute that item's (which is a ProcessExecute) executeProcess method and for it to correctly infer the types (since many of them return null or boolean or Strings or Integers and take as arguments different types, as mentioned above), and, for the life of me, I can't figure out where is the fault in my logic.

What confused me even further, is that I managed to find a (weird?) solution for this problem but I don't want to implement it since I simply don't understand why it works, so if you can please give me a hand on why the following works and how I can improve or change it, please do it. Basically, if I change the executeRam method to this:

private static <K, T> K executeRam(T arguments) {
  Process ram = null;
  try {
      ram = new ProcessBuilder("free","m").start();
  } catch (IOException e){
      Log.printLog(TAG.ERROR,"Unable to run free -m command!");
  }
  return (K) ram;
}

Then it will give no errors in the initializeMap() method (and it actually works). But it kinda seems weird and ungly to cast the return to K (?). Also, this solution of changing all the other methods is not complete : on my methods that have primitive return types such as boolean, it will complain that it can not cast boolean to K, so I can't adapt my solution to other methods.

Answer 1

The problem you've got here is that you're declaring the type variables on the method.

public interface ProcessExecute {
    <K, T> K executeProcess(T arguments);
}

means you can pass anything to the method, and expect to get back any type whatsoever.

ProcessExecute pex = ...;
String s = pex.executeProcess(1);
Integer i = pex.executeProcess("");

This will result in a ClassCastException when you invoke it, unless either you use the result as an Object (as in Object obj = pex.execute(""); ), or you return null from the method.

Instead:

public interface ProcessExecute<K, T> {
    K executeProcess(T arguments);
}

means that, given an instance of ProcessExecute , you always have to pass in the same parameter type, and you will always get back the same parameter.

You can then use an instance of this like so:

ProcessExecute<Void, Process> ramMonitor = ProcessManager::executeRam;
Process p = ramMonitor.executeProcess(null);