有人可以向我解释一下传递“值”背后的原因是什么吗？ 而不是通过“参考” 在Java中是？

Question

我对 Java 相当陌生（多年来一直在写其他东西），除非我遗漏了一些东西（并且我很高兴在这里犯了错误），否则以下是一个致命的缺陷......

String foo = new String();
thisDoesntWork(foo);
System.out.println(foo);//this prints nothing

public static void thisDoesntWork(String foo){
   foo = "howdy";
}

现在，我很清楚（措辞相当糟糕的）概念是，在 java 中，所有内容都是通过“值”而不是“引用”传递的，但是 String 是一个对象，并且具有各种附加功能，因此，人们会期望与 int 不同，用户会能够对传递到方法中的内容进行操作（并且不会被重载 = 设置的值所困扰）。

有人可以向我解释一下这个设计选择背后的原因是什么吗？ 正如我所说，我不想在这里，也许我错过了一些明显的东西？

Answer 1

这篇咆哮比我尝试的更好地解释了这一点：

在 Java 中，原语是按值传递的。 然而，对象不是
通过引用传递。 正确的说法是对象引用
按值传递。

Answer 2

当您传递“foo”时，您将“foo”的引用作为值传递给ThisDoesntWork()。 这意味着当您在方法内部对“foo”进行赋值时，您只是将局部变量 (foo) 的引用设置为对新字符串的引用。

在考虑字符串在 Java 中的行为时要记住的另一件事是字符串是不可变的。 它在 C# 中的工作方式相同，并且有一些很好的原因：

• 安全性：如果没有人可以修改它，那么没有人可以将数据塞入字符串并导致缓冲区溢出错误！
• 速度：如果您可以确定字符串是不可变的，那么您就知道它的大小始终相同，并且在操作它时不必移动内存中的数据结构。 您（语言设计者）也不必担心将字符串实现为慢速链表。 但这是双向的。 仅使用 + 运算符附加字符串可能会占用大量内存，并且您必须使用 StringBuilder 对象以高性能、内存高效的方式执行此操作。

现在谈谈你更大的问题。 为什么对象以这种方式传递？ 好吧，如果 Java 将字符串作为传统上所说的“按值”传递，那么它必须在将字符串传递给函数之前实际复制整个字符串。 那是相当慢的。 如果它通过引用传递字符串并让您更改它（就像 C 那样），您就会遇到我刚才列出的问题。

Answer 3

由于我最初的答案是“为什么会发生这种情况”，而不是“为什么语言被设计成会发生这种情况”，所以我会再试一次。

为了简化事情，我将摆脱方法调用并以另一种方式显示正在发生的情况。

String a = "hello";
String b = a;
String b = "howdy"

System.out.print(a) //prints hello

为了让最后一个语句打印“hello”，b必须指向内存中与a指向的同一个“洞”（指针）。 当您想要通过引用传递时，这就是您想要的。 Java 决定不朝这个方向发展有几个原因：

• 指针令人困惑Java 的设计者试图消除其他语言中一些更令人困惑的东西。 指针与运算符重载一样，是 C/C++ 中最容易被误解和使用不当的结构之一。

• 指针存在安全风险 误用指针会导致许多安全问题。 恶意程序将某些内容分配给该部分内存，然后您认为是您的对象实际上是其他人的。 （Java 已经通过检查数组消除了最大的安全问题，即缓冲区溢出）

• 抽象泄漏当您开始准确地处理“内存中的内容和位置”时，您的抽象就不再是一个抽象的概念。抽象。 虽然抽象泄漏几乎肯定会渗透到语言中，但设计者并不想直接将其融入其中。

• 你关心的只是对象在Java中，一切都是对象，而不是对象占用的空间。 不过，添加指针会使对象占用的空间变得重要......

您可以通过创建“孔”对象来模拟您想要的内容。 您甚至可以使用泛型来使其类型安全。 例如：

public class Hole<T> {
   private T objectInHole;

   public void putInHole(T object) {
      this.objectInHole = object;
   }
   public T getOutOfHole() {
      return objectInHole;
   }

   public String toString() {
      return objectInHole.toString();
   }
   .....equals, hashCode, etc.
}


Hole<String> foo = new Hole<String)();
foo.putInHole(new String());
System.out.println(foo); //this prints nothing
thisWorks(foo);
System.out.println(foo);//this prints howdy

public static void thisWorks(Hole<String> foo){
   foo.putInHole("howdy");
}

Answer 4

您所提出的问题实际上与按值传递、按引用传递或字符串不可变这一事实无关（正如其他人所说）。

在该方法内部，您实际上创建了一个局部变量（我将其称为“localFoo”），它指向与原始变量（“originalFoo”）相同的引用。

当您将“howdy”分配给localFoo时，您不会更改originalFoo指向的位置。

如果你做了类似的事情：

String a = "";
String b = a;
String b = "howdy"?

你会期望：

System.out.print(a)

打印出“howdy”吗？ 它打印出“”。

您不能通过更改 localFoo 指向的内容来更改 OriginalFoo 指向的内容。 您可以修改两者都指向的对象（如果它不是不可变的）。 例如，

List foo = new ArrayList();
System.out.println(foo.size());//this prints 0

thisDoesntWork(foo);
System.out.println(foo.size());//this prints 1

public static void thisDoesntWork(List foo){   
    foo.add(new Object);
}

Answer 5

在java中，所有传递的变量实际上都是通过值传递的，甚至是对象。 传递给方法的所有变量实际上都是原始值的副本。 在您的字符串示例中，原始指针（它实际上是一个引用 - 但为了避免混淆，我将使用不同的单词）被复制到一个新变量中，该变量成为该方法的参数。

如果一切都通过参考，那就很痛苦了。 人们需要在各处制作私人副本，这绝对是一件非常痛苦的事情。 每个人都知道，使用值类型的不变性等会使您的程序变得更加简单且更具可扩展性。

一些好处包括：
- 无需制作防御副本。
- 线程安全 - 无需担心锁定，以防其他人想要更改对象。

Answer 6

问题是您正在实例化 Java 引用类型。 然后将该引用类型传递给静态方法，并将其重新分配给本地范围的变量。

它与不变性无关。 对于可变引用类型，也会发生完全相同的事情。

Answer 7

如果我们对 C 和汇编程序做一个粗略的类比：

void Main()
{ 
     // stack memory address of message is 0x8001.  memory address of Hello is 0x0001.  
     string message = "Hello"; 
     // assembly equivalent of: message = "Hello";
     // [0x8001] = 0x0001

     // message's stack memory address
     printf("%d", &message); // 0x8001

     printf("%d", message); // memory pointed to of message(0x8001): 0x0001
     PassStringByValue(message); // pass the pointer pointed to of message.  0x0001, not 0x8001
     printf("%d", message); // memory pointed to of message(0x8001): 0x0001.  still the same

     // message's stack memory address doesn't change
     printf("%d", &message); // 0x8001
}

void PassStringByValue(string foo)
{
    printf("%d", &foo); // &foo contains foo's *stack* address (0x4001)

    // foo(0x4001) contains the memory pointed to of message, 0x0001
    printf("%d", foo);  // 0x0001
    // World is in memory address 0x0002
    foo = "World";  // on foo's memory address (0x4001), change the memory it pointed to, 0x0002
    // assembly equivalent of: foo = "World":
    // [0x4001] = 0x0002

    // print the new memory pointed by foo
    printf("%d", foo); // 0x0002

    // Conclusion: Not in any way 0x8001 was involved in this function.  Hence you cannot change the Main's message value.
    // foo = "World"  is same as [0x4001] = 0x0002

}

---

void Main()
{
     // stack memory address of message is 0x8001.  memory address of Hello is 0x0001.  
     string message = "Hello"; 
     // assembly equivalent of: message = "Hello";
     // [0x8001] = 0x0001

     // message's stack memory address
     printf("%d", &message); // 0x8001

     printf("%d", message); // memory pointed to of message(0x8001): 0x0001
     PassStringByRef(ref message); // pass the stack memory address of message.  0x8001, not 0x0001
     printf("%d", message); // memory pointed to of message(0x8001): 0x0002. was changed

     // message's stack memory address doesn't change
     printf("%d", &message); // 0x8001
}


void PassStringByRef(ref string foo)
{
    printf("%d", &foo); // &foo contains foo's *stack* address (0x4001)

    // foo(0x4001) contains the address of message(0x8001)
    printf("%d", foo);  // 0x8001
    // World is in memory address 0x0002
    foo = "World"; // on message's memory address (0x8001), change the memory it pointed to, 0x0002
    // assembly equivalent of: foo = "World":
    // [0x8001] = 0x0002;


    // print the new memory pointed to of message
    printf("%d", foo); // 0x0002

    // Conclusion: 0x8001 was involved in this function.  Hence you can change the Main's message value.
    // foo = "World"  is same as [0x8001] = 0x0002

}

Java 中所有内容都按值传递的一个可能原因是，其语言设计人员希望简化语言并以 OOP 方式完成所有操作。

他们宁愿让你使用对象设计一个整数交换器，而不是为按引用传递提供一流的支持，对于委托也是如此（高斯林对函数指针感到讨厌，他宁愿将该功能塞到对象中）和枚举。

他们过度简化（一切都是对象）语言，从而损害了对大多数语言结构没有一流的支持，例如通过引用传递、委托、枚举、属性。

Answer 8

你确定它打印的是 null 吗？ 我认为它只是空白，因为当您初始化 foo 变量时，您提供了空字符串。

在 thisDoesntWork 方法中对 foo 进行赋值不会更改类中定义的 foo 变量的引用，因此 System.out.println(foo) 中的 foo 仍将指向旧的空字符串对象。

Answer 9

戴夫，你必须原谅我（好吧，我想你不必“必须”，但我宁愿你这样做），但这个解释并不太令人信服。 安全性收益相当小，因为任何需要更改字符串值的人都会找到一种通过一些丑陋的解决方法来实现的方法。 还有速度？！ 您自己（非常正确）断言，整个+业务非常昂贵。

你们其他人，请理解我明白它是如何工作的，我问为什么它会这样工作......请停止解释方法之间的差异。

（老实说，我并不是在这里寻求任何形式的战斗，顺便说一句，我只是不明白这是一个理性的决定）。

Answer 10

@Axelle

Mate你真的知道按值传递和按引用传递之间的区别吗？

在java中，甚至引用也是按值传递的。 当您传递对对象的引用时，您将在第二个变量中获得引用指针的副本。 这就是为什么可以更改第二个变量而不影响第一个变量。

Answer 11

这是因为，它在方法内部创建了一个局部变量。 一个简单的方法（我很确定会起作用）是：

String foo = new String();    

thisDoesntWork(foo);    
System.out.println(foo); //this prints nothing

public static void thisDoesntWork(String foo) {    
   this.foo = foo; //this makes the local variable go to the main variable    
   foo = "howdy";    
}

Answer 12

如果您将对象视为对象中的字段，那么在 Java 中对象是通过引用传递的，因为方法可以修改参数的字段，并且调用者可以观察到修改。 但是，如果您也将对象视为其标识，那么对象将按值传递，因为方法无法以调用者可以观察到的方式更改参数的标识。 所以我想说Java是按值传递的。

Answer 13

这是因为在“thisDoesntWork”内部，您实际上破坏了 foo 的本地值。 如果你想以这种方式通过引用传递，总是可以将 String 封装在另一个对象中，比如数组中。

class Test {

    public static void main(String[] args) {
        String [] fooArray = new String[1];
        fooArray[0] = new String("foo");

        System.out.println("main: " + fooArray[0]);
        thisWorks(fooArray);
        System.out.println("main: " + fooArray[0]);
    }

    public static void thisWorks(String [] foo){
        System.out.println("thisWorks: " + foo[0]);
        foo[0] = "howdy";
        System.out.println("thisWorks: " + foo[0]);
    }
}

产生以下输出：

main: foo
thisWorks: foo
thisWorks: howdy
main: howdy

Answer 14

引用类型参数作为对对象本身的引用传递（而不是对引用对象的其他变量的引用）。 您可以调用已传递的对象上的方法。 但是，在您的代码示例中：

public static void thisDoesntWork(String foo){
    foo = "howdy";
}

您仅将对字符串 "howdy" 的引用存储在该方法的本地变量中。 调用该方法时，该局部变量 (foo) 被初始化为调用方的 foo 值，但没有对调用方变量本身的引用。 初始化之后：

caller     data     method
------    ------    ------
(foo) -->   ""   <-- (foo)

在方法中赋值之后：

caller     data     method
------    ------    ------
(foo) -->   ""
          "hello" <-- (foo)

您还有另一个问题：String 实例是不可变的（出于安全考虑而设计），因此您无法修改其值。

如果您确实希望您的方法为字符串提供初始值（或者在其生命周期中的任何时间），那么让您的方法返回一个String 您在调用时分配给调用者变量的值。 像这样的事情，例如：

String foo = thisWorks();
System.out.println(foo);//this prints the value assigned to foo in initialization 

public static String thisWorks(){
    return "howdy";
}

Answer 15

去suns网站上做一个非常大的教程。

您似乎不了解变量范围的差异。 “foo”对于您的方法来说是本地的。 该方法之外的任何内容都不能改变“foo”所指向的内容。 引用您的方法的“foo”是一个完全不同的字段 - 它是您的封闭类中的静态字段。

范围界定尤其重要，因为您不希望系统中的所有其他内容都可见。