Acceso a una función a través de una cadena almacenada en la tabla hash

Question

Si tengo los nombres de funciones almacenados como cadenas en una tabla hash.
¿Hay una manera de acceder a las funciones a través de las cadenas almacenadas?

EDITAR Me temo que la plataforma que estoy trabajando en CLDC1.1 / MIDP 2.0 no es compatible con la reflexión.
Cualquier solución posible?

Answer 1

Sólo tiene que utilizar una gran larga lista de Else-IFS:

[...]
} else if ("foo".equals(function)) {
    target. foo();
} else if ("bar".equals(function)) {
    target. bar();
[...]

(Aunque por lo general no les gusta intentar alineaciones verticales en la fuente, creo que en casos como este, es bien vale la pena.)

Almacenamiento de un funtor en el mapa es una alternativa, bu podría aumentar el tamaño del objeto demasiado para muchas aplicaciones MIDP.

Answer 2

Class.forName () y newInstance () debería estar allí en MIDP 1.1 y podría ser útil. Dado que usted no tiene la reflexión completa, se podría crear una clase que envuelve todas las llamadas a funciones e invoca ellos. Esto supone que conoce todas las llamadas a funciones de antelación.

Usted necesitará las referencias a todos los objetos a menos que estés haciendo llamadas estáticas. Un poco desordenado, pero sería hacer el trabajo.

public Object invoke(String name, Object[] args) {
   Object f = functionMap.get(name);
   if("f1".equals(name)) {
       return ((SomeInterface1)f).someFunction1((SomeArg0) args[0]), ...);
   } else if ("f2".equals(name)) {
       return ((SomeInterface2)f).someFunction2((SomeArg0) args[0]), ...);
   }...{
   } else if ("fN".equals(name)) {
       return ((SomeInterfaceN)f).someFunctionN((SomeArg0) args[0]), ...);
   }
}

Answer 3

Dado un nombre de función, se podría utilizar la reflexión para acceder al método. Además del nombre de la función, lo que necesita saber su clase, y tienen (o crear a través de la reflexión si tiene un constructor NOARG o conoces a los parámetros que se pasan al constructor) una instancia (si el método no es estática) y tiene que conocer los parámetros necesarios para pasar a la misma.

Otra opción es utilizar la clase Método como un puntero a la función. Tiene la ventaja de conocer su clase, y conocer sus requisitos de los parámetros. Tiene la desventaja de no ser serializable.

EDIT: No hay manera de acceder a un método en Java sin reflexión con sólo tener su nombre como una cadena. Si quieres un puntero alternativa a un método, se puede utilizar una clase interna anónima que invoca el método que desea que implementa una interfaz conocida y pasar que a su mapa. Eso no sería apropiada como la clave del mapa, pero funcionaría como un valor en el mapa.

Answer 4

no he probado la reflexión sobre JavaME, pero en JavaSE se puede utilizar la reflexión para llamar a un método de forma dinámica.

El siguiente fragmento es tomada de: http://java.sun.com/developer/technicalArticles/ALT/Reflection/

import java.lang.reflect.*;

public class {metodo2       public int add (int a, int b)       {          volver a + b;       }

  public static void main(String args[])
  {
     try {
       Class cls = Class.forName("method2");
       Class partypes[] = new Class[2];
        partypes[0] = Integer.TYPE;
        partypes[1] = Integer.TYPE;
        Method meth = cls.getMethod(
          "add", partypes);
        method2 methobj = new method2();
        Object arglist[] = new Object[2];
        arglist[0] = new Integer(37);
        arglist[1] = new Integer(47);
        Object retobj 
          = meth.invoke(methobj, arglist);
        Integer retval = (Integer)retobj;
        System.out.println(retval.intValue());
     }
     catch (Throwable e) {
        System.err.println(e);
     }
  }

}

EDIT: En lugar de utilizar if..thenthen..else es posible que desee pasar realmente a un número, y el uso de un interruptor, ya que será más fácil de leer, la OMI.

Sin embargo, sin tener en cuenta, que es probablemente su única opción dadas las limitaciones de JavaME.

Answer 5

Yo trato con problemas similares en Hecl , un intérprete que trabaja en J2ME. De alguna manera depende del número de cuerdas que desea tratar, pero un método que funciona es usar el hash para buscar un número entero, y luego utilizar eso en una sentencia switch, en lugar de la gran lista de if / then. Por cierto, le invitamos a utilizar el código fuente Hecl; que está disponible bajo la licencia Apache liberal.