Accéder à une fonction via chaîne stockée dans le tableau de hachage

Question

Si j'ai les noms de fonctions stockées sous forme de chaînes dans une Hashtable.
Est-il possible d'accéder aux fonctions via les chaînes stockées?

EDIT Je crains que la plate-forme que je travaille sur CLDC1.1 / MIDP2.0 ne prend pas en charge la réflexion.
Toute solution de contournement possible?

Answer 1

Il suffit d'utiliser une grande liste d'autre-ifs:

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

(Bien que je généralement faire, je pense comme ne pas essayer les alignements verticaux dans la source dans des cas comme cela, il vaut bien la peine.)

Enregistrement d'un foncteur sur la carte est une alternative, bu pourrait augmenter la taille de l'objet trop pour de nombreuses applications MIDP.

Answer 2

Class.forName () et newInstance () devrait être là MIDP 1.1 et pourrait être utile. Puisque vous n'avez pas une réflexion complète, vous pouvez créer une classe qui enveloppe tous les appels de fonction et les invoque. Cela suppose que vous savez tous les appels de fonction à l'avance.

Vous aurez besoin de références à tous les objets sauf si vous faites des appels statiques. Un peu en désordre, mais serait faire le travail.

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

Étant donné un nom de fonction, vous pouvez utiliser la réflexion pour accéder à la méthode. Outre le nom de la fonction, vous devez connaître sa classe, et ont (ou créer par réflexion si elle a un constructeur de noarg ou vous savez quels sont les paramètres à passer au constructeur) une instance (si la méthode est pas statique) et vous doivent connaître les paramètres nécessaires pour lui passer.

Une autre option consiste à utiliser la classe de méthode comme un pointeur vers la fonction. Il a l'avantage de connaître sa classe, et connaître ses exigences de paramètres. Il présente l'inconvénient de ne pas être sérialisable.

EDIT: Il n'y a pas moyen d'accéder à une méthode en Java sans réflexion en ayant juste son nom comme une chaîne. Si vous voulez un pointeur alternative à une méthode, vous pouvez utiliser une classe interne anonyme qui invoque la méthode que vous voulez qui implémente une interface connue et que passer à votre carte. Ce ne serait pas approprié que la clé de la carte, mais il fonctionnerait comme une valeur sur la carte.

Answer 4

Je ne l'ai pas essayé la réflexion sur JavaME, mais JavaSE vous pouvez utiliser la réflexion pour appeler dynamiquement une méthode.

L'extrait suivant est tiré de: http://java.sun.com/developer/technicalArticles/ALT/Reflection/

import java.lang.reflect.*;

{public class method2       add public int (int a, int b)       {          retourner 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: Plutôt que d'utiliser if..then..else vous voudrez peut-être passer en fait revenir un certain nombre, et d'utiliser un commutateur, car il sera plus facile à lire, l'OMI.

Mais, peu importe, ce qui est probablement votre seule option étant donné les limites de JavaME.

Answer 5

Je traite des questions similaires dans Hecl , un interprète qui fonctionne sur J2ME. Cela dépend en quelque sorte sur le nombre de chaînes que vous voulez traiter, mais une méthode qui fonctionne est d'utiliser le hachage pour rechercher un entier, et ensuite utiliser que dans une instruction switch, au lieu de la grande liste des cas / then. Soit dit en passant, vous êtes invités à utiliser le code source Hecl; il est disponible sous la licence Apache libérale.