Comment utiliser un paramètre de sortie en Java?

Question

Quelqu'un pourrait-il me donner un exemple de code utilisant un paramètre de sortie dans function? J'ai essayé de le rechercher sur Google, mais je l'ai trouvé uniquement dans les fonctions. J'aimerais utiliser cette valeur de sortie dans une autre fonction.

Le code que je développe est destiné à être exécuté sur Android.

Answer 1

Java passe par là, il n'y a pas d' out paramètre comme en C#.

Vous pouvez soit utiliser return, ou de muter un objet passé comme une référence (par valeur).

Questions connexes

• Java avoir quelque chose comme C#ref et des mots-clés? ? (NON!)
• Est Java passage par référence? (NON!)

---

Exemple de Code

public class FunctionSample {
    static String fReturn() {
        return "Hello!";
    }
    static void fArgNoWorkie(String s) {
        s = "What am I doing???"; // Doesn't "work"! Java passes by value!
    }
    static void fMutate(StringBuilder sb) {
        sb.append("Here you go!");
    }
    public static void main(String[] args) {
        String s = null;

        s = fReturn();
        System.out.println(s); // prints "Hello!"

        fArgNoWorkie(s);
        System.out.println(s); // prints "Hello!"

        StringBuilder sb = new StringBuilder();
        fMutate(sb);
        s = sb.toString();
        System.out.println(s); // prints "Here you go!"
    }

}

Voir aussi

• Qu'entend-on par immuable?
• StringBuilder et StringBuffer en Java

---

Comme pour le code que l'OP a besoin d'aide, voici une solution typique de l'utilisation d'une valeur particulière (habituellement null pour les types de référence) pour indiquer la réussite/échec:

Au lieu de:

String oPerson= null;
if (CheckAddress("5556", oPerson)) {
   print(oPerson); // DOESN'T "WORK"! Java passes by value; String is immutable!
}

private boolean CheckAddress(String iAddress, String oPerson) {
   // on search succeeded:
   oPerson = something; // DOESN'T "WORK"!
   return true;
   :
   // on search failed:
   return false;
}

Utiliser un String type de retour au lieu de cela, avec null pour indiquer l'échec.

String person = checkAddress("5556");
if (person != null) {
   print(person);
}

private String checkAddress(String address) {
   // on search succeeded:
   return something;
   :
   // on search failed:
   return null;
}

C'est combien de java.io.BufferedReader.readLine() de travaux, par exemple: elle retourne instanceof String (peut-être une chaîne vide!), jusqu'à ce qu'il retourne null pour indiquer la fin de la "recherche".

Ce n'est pas limité à un type de référence valeur de retour, bien sûr. La clé est qu'il y a à être une valeur spéciale(s) qui n'est pas une valeur valide, et que vous utilisez cette valeur pour des fins spéciales.

Un autre exemple classique est - String.indexOf: elle retourne -1 pour indiquer la défaillance de recherche.

Remarque: parce que Java ne dispose pas d'un concept de "entrée" et "sortie" des paramètres, à l'aide de l' i- et o- préfixe (par exemple, iAddress, oPerson) est inutile et unidiomatic.

---

Plus générale de la solution

Si vous avez besoin de retourner plusieurs valeurs, généralement elles sont liées d'une certaine façon (par exemple, x et y coordonnées d'un seul Point). La meilleure solution serait d'incarner ces valeurs. Les gens ont utilisé un Object[] ou List<Object>, ou un générique Pair<T1,T2>, mais vraiment, votre propre type serait le mieux.

Pour ce problème, je recommande immuable SearchResult type de ce genre pour encapsuler l' boolean et String résultats de recherche:

public class SearchResult {
   public final String name;
   public final boolean isFound;

   public SearchResult(String name, boolean isFound) {
      this.name = name;
      this.isFound = isFound;
   }
}

Puis dans votre fonction de recherche, vous effectuez les opérations suivantes:

private SearchResult checkAddress(String address) {
  // on address search succeed
  return new SearchResult(foundName, true);
  :
  // on address search failed
  return new SearchResult(null, false);
}

Et puis vous l'utiliser comme ceci:

SearchResult sr = checkAddress("5556");
if (sr.isFound) {
  String name = sr.name;
  //...
}

Si vous le souhaitez, vous pouvez (et devriez) faire l' final immuable champs non-public, et l'utilisation public getters à la place.

Answer 2

Java ne prend pas en charge les paramètres de sortie. Vous pouvez utiliser une valeur de retour ou transmettre un objet en tant que paramètre et modifier l'objet.

Answer 3

Vous pouvez soit utiliser:

• renvoyer X. ceci ne renverra qu'une valeur.

• retourne un objet. retournera un objet complet. Par exemple, votre objet peut inclure des valeurs X, Y et Z.

• passer tableau. les tableaux sont passés par référence. c'est-à-dire que si vous passez un tableau d'entiers, modifié le tableau à l'intérieur de la méthode, le code d'origine verra les modifications.

Exemple en passant Array.

 void methodOne{
    int [] arr = {1,2,3};
    methodTwo(arr);
    ...//print arr here
}
void methodTwo(int [] arr){
    for (int i=0; i<arr.length;i++){
         arr[i]+=3;
    }
}
 

Ceci imprimera: 4,5,6.

Answer 4

Pour contourner le problème, un "ObjectHolder" générique peut être utilisé. Voir exemple de code ci-dessous.

L'exemple de sortie est:

 name: John Doe
dob:1953-12-17
name: Jim Miller
dob:1947-04-18
 

le paramètre Person a donc été modifié puisqu'il est encapsulé dans le titulaire qui est passé par valeur (le paramètre générique à l'intérieur est une référence permettant de modifier le contenu). Ainsi, une personne différente est renvoyée et l'original reste en l'état.

 /**
 * show work around for missing call by reference in java
 */
public class OutparamTest {

 /**
  * a test class to be used as parameter
  */
 public static class Person {
   public String name;
     public String dob;
     public void show() {
      System.out.println("name: "+name+"\ndob:"+dob);
   }
 }

 /**
  * ObjectHolder (Generic ParameterWrapper)
  */
 public static class ObjectHolder<T> {
    public ObjectHolder(T param) {
     this.param=param;
    }
    public T param;
 }

 /**
  * ObjectHolder is substitute for missing "out" parameter
  */
 public static void setPersonData(ObjectHolder<Person> personHolder,String name,String dob) {
    // Holder needs to be dereferenced to get access to content
    personHolder.param=new Person();
    personHolder.param.name=name;
    personHolder.param.dob=dob;
 } 

  /**
   * show how it works
   */
  public static void main(String args[]) {
    Person jim=new Person();
    jim.name="Jim Miller";
    jim.dob="1947-04-18";
    ObjectHolder<Person> testPersonHolder=new ObjectHolder(jim);
    // modify the testPersonHolder person content by actually creating and returning
    // a new Person in the "out parameter"
    setPersonData(testPersonHolder,"John Doe","1953-12-17");
    testPersonHolder.param.show();
    jim.show();
  }
}
 

Answer 5

Ce n'est pas précis ---> "...* tableau passe. les tableaux sont passés par référence. c'est à dire si vous passez tableau d'entiers, modifié le tableau à l'intérieur de la méthode.

Chaque type de paramètre est passé par valeur en Java. Les tableaux sont l'objet, de son objet de référence est passé par valeur.

Cela inclut un tableau de primitifs (int, double,...) et des objets. L'entier de la valeur est modifiée par l'methodTwo() mais c'est toujours la même arr référence de l'objet, la methodTwo() ne peut pas ajouter un élément de tableau ou de supprimer un élément de tableau. methodTwo() ne peut pas aussi, de créer une nouvelle matrice de définir ce nouveau tableau de arr. Si vous ne pouvez vraiment passer un tableau par référence, vous pouvez remplacer cet arr avec un tout nouveau tableau d'entiers.

Chaque objet passé en paramètre en Java est passé par valeur, pas d'exceptions.