Puis-je passer un type primitif par référence en Java?

Les primitives ne sont pas transmises par des références (ou des objets pour cette affaire), donc non, vous ne pouvez pas.

int i = 1;
moo(i);
public void moo(int bah)
{
   bah = 3;
}
System.out.println(i);

Les types d'objets de types primitifs en Java (double, entier, booléen, etc.) sont, si je me souviens bien, immuable. Cela signifie que vous ne pouvez pas modifier la valeur d'origine dans une méthode passée.

Il y a deux solutions à cela. L'un est de créer un type d'emballage qui contient la valeur. Si tout ce que vous essayez de faire est de modifier la valeur ou d'obtenir un calcul de la valeur, vous pourriez avoir la méthode renvoyer le résultat pour vous. Pour prendre vos exemples: xxx

et vous les appeleriez par les éléments suivants: xxx

ou quelque chose de similaire. Cela vous permet de muter ou de modifier la valeur et de renvoyer la valeur mutée, ce qui permettrait à quelque chose comme ce qui suit: xxx

espère que cela aide.

tandis que Java prend en charge la surcharge, tous les paramètres sont passés par la valeur, c'est-à-dire l'attribution d'un argument de méthode n'est pas visible pour l'appelant.

à partir de votre extrait de code, vous essayez de retourner une valeur de différents types. Étant donné que les types de retour ne font pas partie de la signature d'une méthode, vous ne pouvez pas surcharger avec différents types de retour. Par conséquent, l'approche habituelle est la suivante: xxx

S'il s'agit d'une conversion, la nommée standard est xxx

Je dirais la stratégie alternative, si vous voulez travailler avec des primitives, est de faire ce que font les bibliothèques Java. Il suffit de le sucer et d'avoir plusieurs méthodes.

Par exemple, ObjectInphatStretream a ReadDouble () Code>, Loadbyte () Code>, etc. P>

vous ' Ne gagnez rien en partageant une implémentation de la fonction, et les clients de votre fonction ne gagnent rien par les variantes de votre fonction ayant tous le même nom. P>

Mise à jour forte> P>

Considérant votre mise à jour, je ne pense pas qu'il soit nécessaire de faire dupliquer trop de code. Cela dépend de votre stratégie de codage, mais j'imagine que vous pouviez faire quelque chose comme ceci: p> xxx pré>

tout ce qui partage le code plus que cela est probablement sur-ingénierie. P> Une alternative pourrait être p> xxx pré>

IE Je ne pense pas qu'il est logique d'exposer les utilisateurs de votre bibliothèque à autre chose que les types primitifs eux-mêmes. P>

Si vous êtes vraiment, je voulais vraiment que vous puissiez faire une seule méthode d'accès à celui-ci: P>

@SuppressWarnings("unchecked")
public static <T> T getValue(Class<T> clazz) {
    if ( clazz == byte.class ) {
        return (T)Byte.valueOf((byte)getBits(8));
    } else if ( clazz == int.class ) {
        return (T)Integer.valueOf((int)getBits(32));
    }
    throw new UnsupportedOperationException(clazz.toString());
}

//...
byte b = getValue(byte.class);
int i = getValue(int.class);

Oui, s'il vous plaît soyez plus précis sur ce que vous voulez réaliser. De votre description, je vous suggère de jeter un coup d'œil aux génériques Java où vous pourriez écrire quelque chose comme ceci:

class SomeClass <GenericType> {
  GenericType val;  

  void setValue(GenericType val) {
     this.val = val;
  }

  GenericType getValue() {
     return val;
  }

  public static void main(String[] args) {
    SomeClass<Integer> myObj = new SomeClass<Integer>();
    myObj.setValue(5);
    System.out.println(myObj.getValue());

    SomeClass<String> myObj2 = new SomeClass<String>();
    myObj2.setValue("hello?!");
    System.out.println(myObj2.getValue());

  }

}

On dirait que vous avez un ensemble de bits que vous analysez. Vous devriez l'avoir enveloppé dans un objet, appelons cet objet un bitset. Vous êtes itération à travers les bits, vous aurez donc quelque chose comme un itérateur , et comme vous vous voulez faire analyser les octets, les intentes, les longs, etc ..., etc., alors vous aurez votre analyseur de classe, et il y a des méthodes sur celui-ci comme: xxx

etc ...

Donc, après avoir appelé la méthode dont vous avez besoin, vous avez Extrait de la valeur que vous souhaitez sous une manière TypeAfe (types de rendement différents pour différentes méthodes) et que l'itérateur a été déplacé vers l'avant le nombre correct de positions, en fonction du type.

est-ce ce que vous cherchez pour?