在android中将引用作为参数传递

Question

我是java/android新手。我是 ac/c++ 开发人员。我可以知道如何在 android 中传递引用作为参数吗？下面显示的说明性 C 示例代码

void main()
{
  int no1 = 3, no2 = 2, sum = 0;
  findsum( no1, no2, sum );
  printf("sum=%d", sum );
}

void findsum( int no1, int no2, int& sum )
{
  sum = no1 + no2;
}

请建议我一个解决方案，

谢谢

Answer 1

您不能在 Java 中传递 int 作为引用。 int 是主要类型，它只能按值传递。

如果您仍然需要传递 int 变量作为引用，您可以将其包装在可变类中，例如 int 数组：

void findsum( int no1, int no2, int[] sum )
{
  sum[0] = no1 + no2;
}

无论如何，我强烈建议您重构代码以更加面向对象，例如：

class SumOperation {
   private int value;

   public SumOperation(int no1, int no2) {
      this.value = no1 + no2;
   }

   public int getReturnValue() { return this.value; }
}

Answer 2

Java 中没有引用传递。

Answer 3

这就是我解决这个问题的方法：

// By using a wrapper class.
// This also works with Class objects.
class IntReturn {
    public int val;
}

// For example:
class StringReturn {
    public String val;
}

class Main {
    public static void main (){
        IntReturn iRtn = new IntReturn();
        
        if(tryAdd(2, 3, iRtn)){
            System.out.println("tryAdd(2, 3): " + iRtn.val);
        }
    }

    public static boolean tryAdd(final int a, final int b, final IntReturn iRtn){
        iRtn.val = a + b;

        return true;  // Just something to use return
    }
}

我有一个用于此目的的此类类型的个人库。 Lambda 是这些类的另一个原因，因为您需要一个“最终”变量才能从 Lambda 中获取值，而不是通过 return 语句。

更新：
我已经替换了所有特定的包装类
使用单个泛型类：

public final class Ref<T>
{
    /**
     * The object being held.
     */
    public T val;

    /**
     * This constructor is <b>private</b> to prevent instantiation by external
     * clients.
     * <p>
     * This class should <i>only</i> be instantiated through one of the factory
     * methods:
     * <ul>
     * <li>{@link  #val()}</li>
     * <li>{@link  #val(Object) val(T val)}</li>
     * </ul>
     */
    private Ref()
    {
        this.val = null;
    }

    /**
     * This factory method instantiates an empty Ref object.
     *
     * @param <T> type of object.
     *
     * @return a new instance of the Ref class.
     */
    public static <T> Ref<T> val()
    {
        return new Ref<>();
    }

    /**
     * This factory method instantiates a Ref object containing {@code val}.
     *
     * @param <T> type of object.
     * @param val the object to be held
     *
     * @return a new instance of the Ref class, initialized with the 'val'
     *         object.
     */
    public static <T> Ref<T> val(T val)
    {
        Ref<T> rtn = new Ref<>();
        rtn.val = val;
        return rtn;
    }

    /**
     * Reset 'val' to {@code null}.
     */
    public void clear()
    {
        this.val = null;
    }

    /**
     * Check to see if this Ref object has not yet been set to a value.
     *
     * @return {@code true} if it hasn't been set to a value, {@code false}
     *         otherwise.
     */
    public boolean isEmpty()
    {
        return this.val == null;
    }

    /**
     * Check to see if this Ref object has been set to a value.
     *
     * @return {@code true} if it has been set to a value, {@code false}
     *         otherwise.
     */
    public boolean isPresent()
    {
        return this.val != null;
    }

    /**
     * Returns a string representation of the object.
     *
     * @implSpec
     * This implementation returns a string consisting of the default conversion
     * to a string, of the object held in {@code val}. This is achieved by
     * calling its {@code toString()} method. If {@code val} is empty, then the
     * empty string is returned: "".
     *
     * @return a string representation of the object.
     */
    @Override
    public String toString()
    {
        return "" + this.val;
    }
}

以下是它的使用方法：

 ...
     Ref<Integer> iRtn = Ref.val();

     if(add(2, 3, iRtn)){
         System.out.println("2 + 3 = " + iRtn.val);
     }
 ...

 public boolean add(final int a, final int b, final Ref<Integer> iRtn){
     iRtn.val = a + b;

     return iRtn.val > 0;  // just something to use up return
 }

这似乎是多余的，因为我拥有所有以前开发的包装器类。然而，现在我只有一个可以容纳任何东西的泛型类！