2010-06-10 2 views
2

Il ya une liste de tâches qui sont sensibles au temps (mais "temps" dans ce cas est arbitraire à ce qu'un autre programme me dit - c'est plus comme "ticks" plutôt que le temps). Cependant, je ne veux pas que ces méthodes soient évaluées immédiatement. Je veux qu'on s'exécute après que l'autre a fini. J'utilise une liste liée pour ma file d'attente, mais je ne suis pas vraiment sûr comment/si je peux accéder aux méthodes réelles dans une classe sans les évaluer immédiatement.Comment mettre en file d'attente et appeler des méthodes réelles (plutôt qu'éval immédiatement) dans Java?

Le code ressemblerait à quelque chose comme ...

LinkedList<Method> l = new LinkedList<Method>(); 
l.add(this.move(4)); 
l.add(this.read()); 
l.removeFirst().call(); 
//wait 80 ticks 
l.removeFirst().call(); 

move(4) exécuterait immédiatement, puis 80 tiques plus tard, je le supprimer de la liste et d'appeler this.read() qui serait alors exécuté. Je suppose que cela a quelque chose à voir avec les cours de réflexion, et j'ai un peu fourré, mais je n'arrive pas à faire quoi que ce soit pour travailler, ou faire ce que je veux. Si seulement je pouvais utiliser des pointeurs ...

Pour clarifier: Ces commandes seront appelées par une autre classe qui ne connaît rien au timing, c'est pourquoi cette classe doit le gérer. Il appellera simplement des méthodes qui devraient être exécutées en séquence. Certaines méthodes ne retournent rien mais changent d'état.

Répondre

1

Vous pouvez certainement faire quelque chose comme votre exemple. Vous pourriez faire quelque chose en utilisant des interfaces et des classes et renoncer à la réflexion, aussi. Je ne sais pas ce qui fonctionnerait le mieux pour votre situation. Voici comment vous pouvez le faire avec la réflexion.

Vérifiez la classe Class et la classe Method.

// Get the Class of the type you're grabbing methods from 
Object target = new SomeObject(); 
Class theClass = target.getClass(); 
// Or, use the class literal: 
Class theClass = SomeObject.class; 

// Get the methods you want 
// You need to know the method name and its parameter types. 
Method aMethod = theClass.getMethod("move", Integer.class); 

List<Method> myMethods = new LinkedList<Method>(); 
myMethods.add(aMethod); 

// Later, you need an object on which to invoke a method. 
Method currentMethod = myMethods.get(0); 
currentMethod.invoke(target, 4); 
+0

C'est génial! Merci! Juste par curiosité, savez-vous ce qui est le plus rapide à l'exécution - les classes internes, ou les bibliothèques de réflexion? – nathas

+0

Je ne sais pas, mais je pense que la réflexion serait plus lente. Fouettez un cas de test pour être sûr. Aller avec la solution qui est la plus propre à moins que la performance est critique. Je n'ai pas testé ce que j'ai écrit dans ma réponse, c'est de mémoire, mais c'est presque correct. –

+0

Fera, merci encore pour votre aide. – nathas

2

PriorityBlockingQueue est votre ami. Normalement, pour obtenir quelque chose qui se rapproche des fonctions de première classe dans Java, vous utiliseriez une petite interface telle que runnable et l'étendiez dans une classe (anonyme interne).

+0

Y a-t-il vraiment une meilleure façon de le faire? C'est juste si moche ... – nathas

+2

C'est certainement un peu maladroit à approximer, mais ça n'a pas à être horriblement encombrant. Vous pourriez avoir une interface avec une méthode. Malheureusement, vous devrez créer une classe pour chaque "tâche" qui implémenterait cette interface. –

+1

Ce n'est pas si grave en fait, la seule chose que vous répétez inutilement est la signature de la méthode. Tout le reste est un produit de typage statique, que je préfère largement aux autres formes. – CurtainDog

Questions connexes