如何在Java中使用输出参数？

有人能给我一些在函数中使用输出参数的示例代码吗？我试着用谷歌搜索它，但只是在函数中找到了它。我想在另一个函数中使用这个输出值

---

我正在开发的代码打算在Android中运行

Java通过值传递；没有像C#中那样的

out

参数

您可以使用

return

，也可以将传递的对象变为引用（by值）

相关问题

• （没有！）
• （没有！）

---

代码示例 另见

---

对于OP需要帮助的问题，这里有一个典型的解决方案，使用一个特殊的值（对于引用类型，通常为

null

）来表示成功/失败：

而不是：

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;
}

改为使用

字符串

返回类型，并使用

null

表示失败

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

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

这就是工作原理，例如：它返回

instanceof String

（可能是空字符串！），直到返回

null

以指示“搜索”结束

当然，这并不限于引用类型返回值。关键是必须有一些特殊值，这些值永远不是有效值，并且您可以将该值用于特殊目的

另一个经典示例是：它返回

-1

以指示搜索失败

注意：因为Java没有“输入”和“输出”参数的概念，所以使用

i-

和

o-

前缀（例如

iAddress

，

oPerson

）是不必要的，也是不符合习惯的

---

更一般的解决方案 如果需要返回多个值，通常它们以某种方式相关（例如单个

点的
x
和
y
坐标）。最好的解决方案是将这些值封装在一起。人们使用了
对象[]
或
列表
，或通用
对
，但实际上，您自己的类型最好

对于此问题，我建议使用如下不可变的
SearchResult
类型来封装
boolean
和
String
搜索结果：

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

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

然后在搜索功能中，执行以下操作：

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

然后你像这样使用它：

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

如果需要，您可以（也可能应该）将
final
不可变字段设置为非公共的
字段，并使用
公共的
getter。
Java不支持输出参数。您可以使用返回值，也可以将对象作为参数传入并修改对象。
您可以使用：


返回X。这将只返回一个值

返回对象。将返回一个完整的对象。例如，对象可能包括X、Y和Z值

传递数组。数组是通过引用传递的。i、 如果你传递了一个整数数组，修改了方法内部的数组，那么原始代码将看到更改


传递数组的示例

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;
    }
}

void methodOne{
int[]arr={1,2,3}；
方法二（arr）；
…//在此处打印arr
}
无效方法二（int[]arr）{
对于（inti=0；i谢谢。我使用传入对象作为参数。我的Android代码如下

    String oPerson= null;
    if (CheckAddress("5556", oPerson))
    {
        Toast.makeText(this, 
                "It's Match! " + oPerson,                   
                Toast.LENGTH_LONG).show();
    }

    private boolean CheckAddress(String iAddress, String oPerson)
{
    Cursor cAddress = mDbHelper.getAllContacts();
    String address = "";        
    if (cAddress.getCount() > 0) {
        cAddress.moveToFirst();
        while (cAddress.isAfterLast() == false) {
            address = cAddress.getString(2).toString();
            oPerson = cAddress.getString(1).toString(); 
            if(iAddress.indexOf(address) != -1)
            {
                Toast.makeText(this, 
                        "Person : " + oPerson,                  
                        Toast.LENGTH_LONG).show();
                System.out.println(oPerson);
                cAddress.close();
                return true;                    
            }
            else cAddress.moveToNext();
        }
    }
    cAddress.close();
    return false;
}

结果是

人物：约翰

这是匹配！空

事实上，“这是比赛！约翰”

请检查我的错误。
这不准确--->“…*传递数组。数组是通过引用传递的。即，如果传递整数数组，请在方法内修改数组

在Java中，每个参数类型都是按值传递的。数组是对象，它的对象引用是按值传递的

这包括一个基元数组（int、double、…）和对象。整数值由methodTwo（）更改，但它仍然是相同的arr对象引用，methodTwo（）无法添加数组元素或删除数组元素。methodTwo（）也无法，请创建一个新数组，然后将此新数组设置为arr。如果确实可以通过引用传递数组，则可以使用全新的整数数组替换该arr

Java中作为参数传递的每个对象都是按值传递的，没有例外。
作为一种解决方法，可以使用通用的“ObjectHolder”。请参见下面的代码示例

示例输出为：

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

因此Person参数已经被修改，因为它被包装在按值传递的Holder中-内部的泛型参数是一个可以修改内容的引用-因此实际上返回了一个不同的Person，原始参数保持原样

/**
 * 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();
  }
}

/**
*显示java中缺少引用调用的解决方法
*/
公共类输出参数测试{
/**
*要用作参数的测试类
*/
公共静态类人员{
公共字符串名称；
公共字符串dob；
公开展览（{
System.out.println（“名称：+name+”\ndob:+dob）；
}
}
/**
*ObjectHolder（通用参数包装器）
*/
公共静态类ObjectHolder{
公共对象持有者（T参数）{
this.param=param；
}
公共T参数；
}
/**
*ObjectHolder替换缺少的“out”参数
*/
公共静态void setPersonData（ObjectHolder personHolder，字符串名称，字符串dob）{
//持有者需要取消引用才能访问内容
personHolder.param=newperson（）；
personHolder.param.name=name；
personHolder.param.dob=dob；
} 
/**
*展示它是如何工作的
*/
公共静态void main（字符串参数[]）{
人吉姆=新人（）；
jim.name=“吉姆·米勒”；
jim.dob=“1947-04-18”；
ObjectHolder testPersonHolder=新的ObjectHolder（jim）；
//通过实际创建并返回来修改testPersonHolder人员内容
//“out参数”中的新人员
setPersonData（测试人员持有人，“约翰·多伊”，“1953-12-17”）；
testPersonHolder.param.show（）；
吉姆。show（）；
}
}
包装在不同类中传递的值，这可能有助于实现该技巧，请查看下面的更多实际示例：

  class Ref<T>{

    T s;

    public void set(T value){
        s =  value;
    }

    public T get(){
        return s;
    }

    public Ref(T value) {
        s = value;
    }
}


class Out<T>{

    T s;

    public void set(T value){
        s =  value;
    }
    public T get(){
        return s;
    }

    public Out() {
    }
}

public static void doAndChangeRefs (Ref<String> str, Ref<Integer> i, Out<String> str2){
    //refs passed .. set value
    str.set("def");
    i.set(10);

    //out param passed as null .. instantiate and set 
    str2 = new Out<String>();
    str2.set("hello world");
}
public static void main(String args[]) {
        Ref<Integer>  iRef = new Ref<Integer>(11);
        Out<String> strOut = null; 
        doAndChangeRefs(new Ref<String>("test"), iRef, strOut);
        System.out.println(iRef.get());
        System.out.println(strOut.get());

    }

class-Ref{
T-s；
公共vo
  class Ref<T>{

    T s;

    public void set(T value){
        s =  value;
    }

    public T get(){
        return s;
    }

    public Ref(T value) {
        s = value;
    }
}


class Out<T>{

    T s;

    public void set(T value){
        s =  value;
    }
    public T get(){
        return s;
    }

    public Out() {
    }
}

public static void doAndChangeRefs (Ref<String> str, Ref<Integer> i, Out<String> str2){
    //refs passed .. set value
    str.set("def");
    i.set(10);

    //out param passed as null .. instantiate and set 
    str2 = new Out<String>();
    str2.set("hello world");
}
public static void main(String args[]) {
        Ref<Integer>  iRef = new Ref<Integer>(11);
        Out<String> strOut = null; 
        doAndChangeRefs(new Ref<String>("test"), iRef, strOut);
        System.out.println(iRef.get());
        System.out.println(strOut.get());

    }