相关疑难解决方法(0)

这2个代码有什么区别:

代码A:

Foo myFoo;
myFoo = createfoo();

哪里

public Foo createFoo()
{
   Foo foo = new Foo();
   return foo;
}

比.代码B:

Foo myFoo;
createFoo(myFoo);

public void createFoo(Foo foo)
{
   Foo f = new Foo();
   foo = f;
}

这2个代码之间有什么区别吗？

比较这种方法:

void doStuff(String val) {
    if (val == null) {
        val = DEFAULT_VALUE;
    }

    // lots of complex processing on val
}

...对于这种方法:

void doStuff(String origVal) {
    String val = origVal;
    if (val == null) {
        val = DEFAULT_VALUE;
    }

    // lots of complex processing on val
}

对于前一种方法,Eclipse会发出警告"不应分配参数'val'".为什么？

在我看来,前者更清洁.首先,它并没有迫使我想出两个好名字val(想出一个好的名字就足够了).

(注意:假设val封闭类中没有命名的字段.)

我认为几乎所有语言都包括java传递数组作为参考(可修改)

但不知何故,它在这里不起作用.并且testArray仍然是1,2,3,大小为3

如果我将结果[i] = 2更改为[1] = 2,那就太奇怪了 这行得通 .它确实通过引用传递

这段代码有什么问题？

最后,我有一个=结果; (更新a).结果从堆栈中删除了.这就是为什么一个仍然得到原来的？

我很迷惑.

谢谢

class Test
{
   public static void main(String[] args)
   {

      int[] testArray = {1,2,3};
      equalize(testArray, 6);

      System.out.println("test Array size :" + testArray.length);
      for(int i = 0; i < testArray.length; i++)
         System.out.println(testArray[i]);
   }

   public static void equalize(int[] a, int biggerSize)
   {
      if(a.length > biggerSize)
         throw new Error("Array size bigger than biggerSize");

      int[] result = new int[biggerSize];
     // System.arraycopy(a, 0, result, 0, a.length);
     // int array default value should …

可能重复: Java是否通过引用传递？

public class myClass{
    public static void main(String[] args){
        myObject obj = new myObject("myName");
        changeName(obj);
        System.out.print(obj.getName()); // This prints "anotherName"
    }
    public static void changeName(myObject obj){
        obj.setName("anotherName");
    }
}

我知道Java通过值传递,但为什么它obj在前面的示例中通过引用传递并更改它？

Java是按值传递的.你如何修改语言以引入通过引用传递(或一些等效的行为)？

举个例子

public static void main(String[] args) {
    String variable = "'previous String reference'";
    passByReference(ref variable);
    System.out.println(variable); // I want this to print 'new String reference'
}

public static void passByReference(ref String someString) {
    someString = "'new String reference'";
}

哪个(没有ref)编译成以下字节码

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String 'previous String reference'
       2: astore_1
       3: aload_1
       4: invokestatic  #3                  // Method passByReference:(Ljava/lang/String;)V
       7: return

  public static void passByReference(java.lang.String);
    Code:
       0: ldc           #4                  // String …

我发现以下问题是Java"pass-by-reference"还是"pass-by-value"？.

我几乎阅读了所有内容,但是如果我想要这个foo(-)方法,我还不知道该怎么做才能改变我String的价值？(也许或不参考,对我来说无关紧要).

void foo(String errorText){ 
    errorText="bla bla";
}

int main(){ 
    String error="initial"; 
    foo(error); 
    System.out.println(error);
}

我想bla bla在控制台上看到.可能吗？

public class StackOverFlow {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        al.add("A");
        al.add("B");
        markAsNull(al);
        System.out.println("ArrayList elements are "+al);

        String str = "Hello";
        markStringAsNull(str);
        System.out.println("str "+ str);
    }
    private static void markAsNull(ArrayList<String> str){
        str.add("C");
        str= null;
    }
    private static void markStringAsNull(String str){
        str = str + "Append me";
        str = null;
    }
}

这输出:

ArrayList elements are [A, B, C]
str Hello

在这种情况下ArrayList,添加的元素将被检索.如果String方法调用对传递的String没有影响.JVM到底在做什么？谁能详细解释一下？

ColdFusion对象(即通过cfobject调用的CFC)通常是通过引用还是通过值传递(复制到内存中)？是否可以强制ColdFusion以任何一种方式传递对象？

我正在读一本C++书,上面写着:

C++通过引用将数组传递给函数 - 被调用的函数可以修改调用者原始数组中的元素值.

它指的是这样的情况:

int hourlyTemperatures[ 24 ]; 
modifyArray( hourlyTemperatures, 24 );

但是,这是香草C阵列指针在这里工作,对吧？没有使用C++"引用"技术,传递的是按值的指针,在这种情况下,是指向数组的第一个元素的指针.最终的结果是函数确实可以访问完整的原始数组,就像引用一样,但实际上并没有通过引用传递,对吧？

从这本Prentice Hall书中:

所以,我刚刚开始学习Java,我发现没有"通过引用传递"这样的东西.我正在将一个应用程序从C#移植到Java,原始应用程序有一个"ref"或"out"参数的整数和双精度数.

起初我以为我可以传入"整数"或"双精度",由于这是一个引用类型,因此值将被更改.但后来我了解到那些引用类型是不可变的.

那么,我创建了一个"MutableInteger"类和一个"MutableDouble"类,并将它们传递给了我的函数.它有效,但我想我必须违背该语言的原始设计意图.

一般糟糕的设计是"通过参考"吗？我该如何改变自己的思维方式？

拥有这样的函数似乎是合理的:

bool MyClass::changeMyAandB(ref int a, ref int b)
{
    // perform some computation on a and b here

    if (success)
        return true;
    else return false;
}

这是糟糕的设计吗？