Préserver les noms des paramètres / argument dans les classes java compilées

Question

Quand je compile quelque chose comme ceci:

public class MyClass
{
    void myMethod(String name, String options, String query, String comment)
    {
        ...
    }
}

et compiler à un fichier de classe, il semble que les noms d'arguments sont perdus. Autrement dit, lorsque d'autres références de code Java MyClass et veut appeler ou écraser myMethod, mon IDE (actuellement Eclipse) semble obtenir cette signature de la méthode à partir du fichier de classe:

void myMethod(String arg0, String arg1, String arg2, String arg3);

Je sais que Eclipse (et peut-être d'autres aussi) me IDEs permet de fournir un lien vers la source ou la javadoc (comme Bishiboosh souligné) de MyClass et peut tirer profit de cela. Mais je suis curieux de savoir s'il y a un moyen de dire javac d'inclure les noms dans le fichier de classe, de sorte que les utilisateurs de cette classe peuvent voir les noms d'argument, même si elles ont seulement le fichier de classe.

Solution pour les classes

Quand je compile une classe avec java -g:vars, les noms des paramètres sont inclus dans le fichier de classe. -g:vars semble être équivalent à Eclipse -> propriétés du projet -> compilateur Java -> Ajouter des attributs variables à des fichiers de classe générés.

Cette solution a été suggérée par plusieurs auteurs, mais la réponse de Nick m'a finalement fait croire.

Sur ma machine, Eclipse parfois utilisé cette information, parfois, il ne l'a pas, ce qui était probablement ma faute ou d'un bogue dans Eclipse, mais pas un problème avec les fichiers de classe ou la compilation. Quoi qu'il en soit, je sais maintenant que l'information est bien présente.

Mais pas de solution pour les interfaces

Bien que cela fonctionne (genre de) d'amende pour les classes, il ne fonctionne pas pour les interfaces.

Pour moi, la raison logique semble être que -g: vars ne fournit les noms des variables locales, ce qui est ce que la documentation javac indique également. Dans le corps d'une méthode, ses paramètres sont très semblables à des variables locales, donc ils sont couverts par -g: vars. les méthodes d'interface n'ont pas de corps, de sorte qu'ils ne peuvent pas avoir varibles locales.

Ma question initiale ne demandait que des classes, parce que je ne savais pas qu'il pourrait y avoir une différence.

format de fichier de classe

gid a souligné, le format de fichier de classe ne prend pas en charge storrage des noms de paramètres. J'ai trouvé une section qui descibes une struture de données qui devrait Holf les noms des paramètres des méthodes, mais cela est certainement pas utilisé lors de la compilation des interfaces.

Lors de la compilation d'une classe, je ne peux pas dire si la structure de données mentionnée est utilisée, ou si Eclipse infère les noms des paramètres de l'utilisation des paramètres à l'intérieur du corps de la méthode. Un expert pourrait préciser, mais ce n'est pas que je pense utile.

Answer 1

Pour préserver les noms dans le fichier de classe pour des fins de débogage essayer propriétés du projet, le compilateur Java, puis « Ajouter des attributs variables aux fichiers classe générés » (Voir Eclipse Help ).

Compiler la source suivante:

public class StackOverflowTest {
    public void test(String foo, String bar) {
        // blah
    }
}

est décompilé dans:

// Compiled from StackOverflowTest.java (version 1.5 : 49.0, super bit)
public class StackOverflowTest {

    // Method descriptor #6 ()V
    // Stack: 1, Locals: 1
    public StackOverflowTest();
        0  aload_0 [this]
        1  invokespecial java.lang.Object() [8]
        4  return
        Line numbers:
            [pc: 0, line: 1]
        Local variable table:
            [pc: 0, pc: 5] local: this index: 0 type: StackOverflowTest

    // Method descriptor #15 (Ljava/lang/String;Ljava/lang/String;)V
    // Stack: 0, Locals: 3
    public void test(java.lang.String foo, java.lang.String bar);
        0  return
        Line numbers:
            [pc: 0, line: 4]
        Local variable table:
            [pc: 0, pc: 1] local: this index: 0 type: StackOverflowTest
            [pc: 0, pc: 1] local: foo index: 1 type: java.lang.String
            [pc: 0, pc: 1] local: bar index: 2 type: java.lang.String
}

Voir les noms de paramètres sont conservés dans les fichiers de classe.

Je vous suggère de regarder la façon dont est compilé source, quelle version il est compilé pour etc.

EDIT:

Ah, je vois ce qui est différent pour les interfaces - ils ne semblent pas avoir cette information disponible pour le débogueur que je suppose est logique. Je ne pense pas qu'il y aura un moyen de contourner cela, si vous voulez juste voir les noms des paramètres lorsque vous la source d'édition, vous aurez besoin d'aller la route javadoc comme Nagrom_17 suggère (joindre la source).

Answer 2

Vous n'avez pas spécialement besoin de la source pour faire des noms de arg apparaissent dans Eclipse ... Si vous spécifiez le Javadoc, Eclipse affiche les args.

Answer 3

Il pourrait aider à compiler avec le support de débogage, qui stocke tous les noms dans le fichier .class.

bien que je ne sais pas si Eclipse prend cela en compte.

Answer 4

Il n'y a pas de support dans la structure de données de fichier de classe pour stocker les noms de paramètres à toute méthode, peu importe quelles sont les options que vous utilisez javac.

Pour voir les noms originaux dans un IDE, vous devez leur fournir soit le javadoc ou la source.

Si vous avez un besoin particulier de les atteindre lors de l'exécution, il est possible d'ajouter des annotations aux paramètres, mais vous devrez créer votre propre car il n'y a pas un ensemble standard à utiliser.

Désolé ne peut pas être plus utile

EDIT : Je reste complètement corrigé ... le format de fichier de classe ne clairement l'espace pour les paramètres nommés ( JLS 4,7 )

Ce que je ne vois pas comment l'enfer vous pouvez obtenir à les utiliser java.lang.reflect.*

Answer 5

Eclipse captera les noms des arguments si vous incluez des informations de débogage dans le fichier de classe: javac -g:vars devrait être suffisant

.

Answer 6

Vous n'avez pas besoin d'un fichier séparé Javadoc vous pouvez créer « inline » javadocs dans Eclipse en utilisant un commentaire spécial avec deux astérisques (*) après la première barre oblique d'un commentaire sur plusieurs lignes.

exemple de code:

   public class MyClass
{
 /**
  * documentation of your method
  * 
  * @param name    a String describing the name
  * @param options used to describe current option
  * @param query
  * @param comment
  * @return void
  */
    void myMethod(String name, String options, String query, String comment)
    {
        ...
    }
}