Java是“按引用传递”还是“按值传递”？
我一直认为Java使用按引用传递Java是“按引用传递”还是“按值传递”？,java,methods,parameter-passing,pass-by-reference,pass-by-value,Java,Methods,Parameter Passing,Pass By Reference,Pass By Value,我一直认为Java使用按引用传递 public class PassByCopy{ public static void changeName(Dog d){ d.name = "Fido"; } public static void main(String[] args){ Dog d = new Dog("Maxx"); System.out.println("name= "+ d.name); chan
public class PassByCopy{
public static void changeName(Dog d){
d.name = "Fido";
}
public static void main(String[] args){
Dog d = new Dog("Maxx");
System.out.println("name= "+ d.name);
changeName(d);
System.out.println("name= "+ d.name);
}
}
class Dog{
public String name;
public Dog(String s){
this.name = s;
}
}
解释是什么？Java总是按值传递，从来没有例外 那么，怎么会有人对此感到困惑，认为Java是通过引用传递的，或者认为他们有一个Java作为通过引用传递的例子呢？关键的一点是，Java在任何情况下都不提供对对象本身值的直接访问。对对象的唯一访问是通过对该对象的引用。因为Java对象总是通过引用来访问，而不是直接访问，所以通常将字段、变量和方法参数称为对象，而从字面上讲，它们只是对对象的引用。这种混淆源于这种严格意义上的不正确的命名变化 因此，在调用方法时 对于基元参数int、long等，传递值是基元的实际值，例如3。 对于对象，传递值是对对象的引用的值。 因此，如果有doSomethingfoo和public void doSomethingfoo foo{..}，那么这两个foo复制了指向相同对象的引用
当然，按值传递对对象的引用看起来很像，在实践中与按引用传递对象没有区别。Java按值传递引用
public class PassByCopy{
public static void changeName(Dog d){
d.name = "Fido";
}
public static void main(String[] args){
Dog d = new Dog("Maxx");
System.out.println("name= "+ d.name);
changeName(d);
System.out.println("name= "+ d.name);
}
}
class Dog{
public String name;
public Dog(String s){
this.name = s;
}
}
因此，您无法更改传入的引用。基本上，重新指定对象参数不会影响参数，例如
private void foo(Object bar) {
bar = null;
}
public static void main(String[] args) {
String baz = "Hah!";
foo(baz);
System.out.println(baz);
}
会打印出来的哈！而不是null。之所以这样做，是因为bar是baz值的副本，它只是对Hah！的引用！。如果它是实际的引用本身，那么foo会将baz重新定义为null。Java将引用按值传递给对象。Java总是按值传递。不幸的是，当我们处理对象时，我们实际上是在处理被称为引用的对象句柄，这些句柄也是通过值传递的。这种术语和语义很容易使许多初学者感到困惑 事情是这样的：
public static void main(String[] args) {
Dog aDog = new Dog("Max");
Dog oldDog = aDog;
// we pass the object to foo
foo(aDog);
// aDog variable is still pointing to the "Max" dog when foo(...) returns
aDog.getName().equals("Max"); // true
aDog.getName().equals("Fifi"); // false
aDog == oldDog; // true
}
public static void foo(Dog d) {
d.getName().equals("Max"); // true
// change d inside of foo() to point to a new Dog instance "Fifi"
d = new Dog("Fifi");
d.getName().equals("Fifi"); // true
}
void getValues(int[] arg1, int[] arg2) {
arg1[0] = 1;
arg2[0] = 2;
}
void caller() {
int[] x = new int[1];
int[] y = new int[1];
getValues(x, y);
System.out.println("Result: " + x[0] + " " + y[0]);
}
public static void main(String[] args) {
Dog aDog = new Dog("Max");
Dog oldDog = aDog;
foo(aDog);
// when foo(...) returns, the name of the dog has been changed to "Fifi"
aDog.getName().equals("Fifi"); // true
// but it is still the same dog:
aDog == oldDog; // true
}
public static void foo(Dog d) {
d.getName().equals("Max"); // true
// this changes the name of d to be "Fifi"
d.setName("Fifi");
}
在上面的例子中，Fifi是调用fooaDog后狗的名字，因为对象的名字是在foo内设置的。。。。foo对d执行的任何操作都是在aDog上执行的，但是不可能更改变量aDog本身的值。长话短说，对象具有一些非常特殊的属性 一般来说，Java有int、bool、char、double等基本类型，它们直接通过值传递。然后，Java拥有从Java.lang.Object派生的所有对象。对象实际上总是通过一个引用来处理的，引用是一个你不能触摸的指针。这意味着实际上，对象是通过引用传递的，因为引用通常不感兴趣。但是，这确实意味着您不能更改指向哪个对象，因为引用本身是通过值传递的 这听起来是不是既奇怪又令人困惑？让我们考虑一下C是如何实现按引用传递和按值传递的。在C语言中，默认约定是按值传递。void fooint x通过值传递一个int。void fooint*x是一个函数，它不需要int a，而是指向int:foo&a的指针。可以将其与&运算符一起使用来传递变量地址
把这个带到C++，我们有参考文献。在这个上下文中，引用基本上是隐藏表达式指针部分的语法糖：void fooint&x由fooa调用，其中编译器本身知道它是一个引用，应该传递非引用a的地址。在java中，所有引用对象的变量实际上都是引用类型，实际上，通过引用来强制调用大多数目的和目的，而没有细粒度的控制和复杂性，例如C++，
或者，也许我记得，我曾经和最初的海报有着相同的印象，那就是：Java总是按值传递。Java中的所有对象，除原语外的任何对象都是引用。这些引用是按值传递的。正如许多人之前提到的 下面是另一个有助于您理解差异的示例： 印刷品： 之前：a=2，b=3 之后：a=2，b=3 这是因为iA和iB是新的局部引用变量，它们分别指向a和b的传递引用的值相同伊利。因此，尝试更改iA或iB的引用只会在本地范围内更改，而不会超出此方法。我始终认为这是一个传递副本。它是值的副本，可以是原语或引用。如果它是一个原语，则它是作为值的位的副本；如果它是一个对象，则它是引用的副本
public class PassByCopy{
public static void changeName(Dog d){
d.name = "Fido";
}
public static void main(String[] args){
Dog d = new Dog("Maxx");
System.out.println("name= "+ d.name);
changeName(d);
System.out.println("name= "+ d.name);
}
}
class Dog{
public String name;
public Dog(String s){
this.name = s;
}
}
原始包装器类和字符串是不可变的，因此任何使用这些类型的示例都不会与其他类型/对象一样工作。我为任何编程语言创建了一个专门讨论此类问题的线程 。以下是简短的总结： Java按值传递它的参数 在java中，按值是将参数传递给方法的唯一方法 使用作为参数提供的对象中的方法将改变 对象作为引用指向的对象 原始对象。如果 方法本身改变了一些值
我刚注意到你提到了 Java规范说Java中的一切都是按值传递的。Java中没有通过引用传递的东西 理解这一点的关键是
Dog myDog;
Dog myDog = new Dog("Rover");
foo(myDog);
public void foo(Dog someDog) {
someDog.setName("Max"); // AAA
someDog = new Dog("Fifi"); // BBB
someDog.setName("Rowlf"); // CCC
}
将引用参数视为传入变量的别名。分配别名时，传入的变量也是如此。为了显示对比度，请比较以下内容和代码段： 在C++中：注意：错误代码-内存泄漏！但它证明了这一点
void cppMethod(int val, int &ref, Dog obj, Dog &objRef, Dog *objPtr, Dog *&objPtrRef)
{
val = 7; // Modifies the copy
ref = 7; // Modifies the original variable
obj.SetName("obj"); // Modifies the copy of Dog passed
objRef.SetName("objRef"); // Modifies the original Dog passed
objPtr->SetName("objPtr"); // Modifies the original Dog pointed to
// by the copy of the pointer passed.
objPtr = new Dog("newObjPtr"); // Modifies the copy of the pointer,
// leaving the original object alone.
objPtrRef->SetName("objRefPtr"); // Modifies the original Dog pointed to
// by the original pointer passed.
objPtrRef = new Dog("newObjPtrRef"); // Modifies the original pointer passed
}
int main()
{
int a = 0;
int b = 0;
Dog d0 = Dog("d0");
Dog d1 = Dog("d1");
Dog *d2 = new Dog("d2");
Dog *d3 = new Dog("d3");
cppMethod(a, b, d0, d1, d2, d3);
// a is still set to 0
// b is now set to 7
// d0 still have name "d0"
// d1 now has name "objRef"
// d2 now has name "objPtr"
// d3 now has name "newObjPtrRef"
}
public static void javaMethod(int val, Dog objPtr)
{
val = 7; // Modifies the copy
objPtr.SetName("objPtr") // Modifies the original Dog pointed to
// by the copy of the pointer passed.
objPtr = new Dog("newObjPtr"); // Modifies the copy of the pointer,
// leaving the original object alone.
}
public static void main()
{
int a = 0;
Dog d0 = new Dog("d0");
javaMethod(a, d0);
// a is still set to 0
// d0 now has name "objPtr"
}
Java只有两种类型的传递：通过值传递内置类型，通过指针值传递对象类型。问题的关键在于表达式pass by reference中的单词reference与Java中单词reference的通常含义完全不同
通常在Java中，引用是指对对象的引用。但是编程语言理论中的技术术语“按引用传递/值”指的是对保存变量的内存单元的引用，这是完全不同的。在Java中永远不能按引用传递，其中一种显而易见的方法是，当您希望从方法调用返回多个值时。考虑C++中的以下代码：< /P>
void getValues(int& arg1, int& arg2) {
arg1 = 1;
arg2 = 2;
}
void caller() {
int x;
int y;
getValues(x, y);
cout << "Result: " << x << " " << y << endl;
}
但是，上面的C++中没有的简单模式在java java中是不可用的。 据我所知，Java只知道按值调用。这意味着对于基本数据类型，您将使用副本；对于对象，您将使用对象引用的副本。然而，我认为有一些陷阱；例如，这将不起作用：
public static void swap(StringBuffer s1, StringBuffer s2) {
StringBuffer temp = s1;
s1 = s2;
s2 = temp;
}
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer("Hello");
StringBuffer s2 = new StringBuffer("World");
swap(s1, s2);
System.out.println(s1);
System.out.println(s2);
}
public static void appendWorld(StringBuffer s1) {
s1.append(" World");
}
public static void main(String[] args) {
StringBuffer s = new StringBuffer("Hello");
appendWorld(s);
System.out.println(s);
}
public static void appendWorld(String s){
s = s+" World";
}
public static void main(String[] args) {
String s = new String("Hello");
appendWorld(s);
System.out.println(s);
}
public static void appendWorld(StringBuffer s1) {
s1.append(" World");
}
public static void main(String[] args) {
StringBuffer s = new StringBuffer("Hello");
appendWorld(s);
System.out.println(s);
}
public static void appendWorld(String s){
s = s+" World";
}
public static void main(String[] args) {
String s = new String("Hello");
appendWorld(s);
System.out.println(s);
}
class StringWrapper {
public String value;
public StringWrapper(String value) {
this.value = value;
}
}
public static void appendWorld(StringWrapper s){
s.value = s.value +" World";
}
public static void main(String[] args) {
StringWrapper s = new StringWrapper("Hello");
appendWorld(s);
System.out.println(s.value);
}
编辑：我相信这也是在添加两个字符串时使用StringBuffer的原因，因为你可以修改原始对象，而不能修改字符串等不可变对象。我不相信还没有人提到Barbara Liskov。当她在1974年设计CLU时，她遇到了同样的术语问题，她发明了“通过共享调用”这个术语，也称为“通过对象共享调用”和“通过对象调用”，用于这种特定情况下的“通过值调用”，其中值是一个引用。这将让您了解Java是如何真正工作的，在下一次讨论Java通过引用传递或通过值传递时，您只需笑一笑:-
public class PassByCopy{
public static void changeName(Dog d){
d.name = "Fido";
}
public static void main(String[] args){
Dog d = new Dog("Maxx");
System.out.println("name= "+ d.name);
changeName(d);
System.out.println("name= "+ d.name);
}
}
class Dog{
public String name;
public Dog(String s){
this.name = s;
}
}
1. Person person;
2. person = new Person("Tom");
3. changeName(person);
4.
5. //I didn't use Person person below as an argument to be nice
6. static void changeName(Person anotherReferenceToTheSamePersonObject) {
7. anotherReferenceToTheSamePersonObject.setName("Jerry");
8. }
我只是说Java是按值传递的 Java总是按值传递参数，而不是按引用传递参数
public class PassByCopy{
public static void changeName(Dog d){
d.name = "Fido";
}
public static void main(String[] args){
Dog d = new Dog("Maxx");
System.out.println("name= "+ d.name);
changeName(d);
System.out.println("name= "+ d.name);
}
}
class Dog{
public String name;
public Dog(String s){
this.name = s;
}
}
changeReference(f);
我希望您现在了解了在Java中作为参数传递对象的工作原理：不，它不是按引用传递
public class PassByCopy{
public static void changeName(Dog d){
d.name = "Fido";
}
public static void main(String[] args){
Dog d = new Dog("Maxx");
System.out.println("name= "+ d.name);
changeName(d);
System.out.println("name= "+ d.name);
}
}
class Dog{
public String name;
public Dog(String s){
this.name = s;
}
}
Java只有传递值。一个非常简单的例子来验证这一点
public void test() {
MyClass obj = null;
init(obj);
//After calling init method, obj still points to null
//this is because obj is passed as value and not as reference.
}
private void init(MyClass objVar) {
objVar = new MyClass();
}
我觉得争论通过引用传递还是通过值传递并没有多大帮助 如果您说Java是通过任何引用/值传递的，那么无论哪种情况，您都没有提供完整的答案。这里有一些额外的信息，希望有助于理解内存中发生了什么 在开始Java实现之前，我们将学习有关堆栈/堆的速成课程： 价值观以一种很好的有序方式在堆栈上上下移动，就像自助餐厅里的一堆盘子。 堆中的内存也称为动态内存，它是随意的、无序的。JVM只是尽可能地找到空间，并在不再需要使用它的变量时释放空间 好的。首先，本地原语进入堆栈。所以这个代码：
int x = 3;
float y = 101.1f;
boolean amIAwesome = true;
int problems = 99;
String name = "Jay-Z";
JButton[] marxBros = new JButton[3];
marxBros[0] = new JButton("Groucho");
marxBros[1] = new JButton("Zeppo");
marxBros[2] = new JButton("Harpo");
private static void shout(String name){
System.out.println("There goes " + name + "!");
}
public static void main(String[] args){
String hisName = "John J. Jingleheimerschmitz";
String myName = hisName;
shout(myName);
}
那么，价值，参考？你说土豆。Java总是按值传递，而不是按引用传递 首先，我们需要了解什么是按值传递和按引用传递 通过值传递意味着您正在内存中复制传入的实际参数值。这是实际参数内容的副本 Pass-by-reference也称为Pass-by-address，意思是存储实际参数地址的副本 有时Java会给人一种通过引用传递的错觉。让我们使用下面的示例来了解它的工作原理：
public class PassByValue {
public static void main(String[] args) {
Test t = new Test();
t.name = "initialvalue";
new PassByValue().changeValue(t);
System.out.println(t.name);
}
public void changeValue(Test f) {
f.name = "changevalue";
}
}
class Test {
String name;
}
Test t = new Test();
new PassByValue().changeValue(t);
public class PassByValue {
public static void main(String[] args) {
Test t = new Test();
t.name = "initialvalue";
new PassByValue().changeRefence(t);
System.out.println(t.name);
}
public void changeRefence(Test f) {
f = null;
}
}
class Test {
String name;
}
希望这会有所帮助。在java中，一切都是参考，所以当您有以下内容时： 点pnt1=新点0,0；Java有以下功能： 创建新的点对象 创建新的点参照，并将该参照初始化为以前创建的点对象上的点参照。 从这里开始，通过点对象生命周期，您将通过pnt1访问该对象 参考所以我们可以说，在Java中，通过对象的引用来操作对象。 Java不通过引用传递方法参数；它按值传递它们。我将使用以下示例： 程序流程：
Point pnt1 = new Point(0,0);
Point pnt2 = new Point(0,0);
X1: 0 Y1: 0
X2: 0 Y2: 0
X1: 0 Y1: 0
X2: 0 Y2: 0
X1: 100 Y1: 100
X2: 0 Y2: 0
(Name)[Location] -> [Value at the Location]
---------------------
(Ref2Foo)[223] -> 47
(Foo)[47] -> 5
public class PassByCopy{
public static void changeName(Dog d){
d.name = "Fido";
}
public static void main(String[] args){
Dog d = new Dog("Maxx");
System.out.println("name= "+ d.name);
changeName(d);
System.out.println("name= "+ d.name);
}
}
class Dog{
public String name;
public Dog(String s){
this.name = s;
}
}
简而言之，用Java自己的术语来说，Java是传递值，值可以是：实值或表示引用的值 我想我应该提供这个答案，以便从规范中添加更多细节 首先, 通过引用传递意味着被调用函数的参数将是 与调用方传递的参数相同的不是值，而是标识 -变量本身 传递值表示被调用函数的参数将是 调用方传递的参数
changeReference(f);
让我们考虑引用类型，状态
引用类型有三种：类类型、数组类型、， 和接口类型。它们的值是动态引用的 创建的类实例、数组或类实例或数组 分别实现接口 报告还指出 引用值通常只是引用是指向这些对象的指针，以及一个特殊的空引用，它不引用任何对象 某个引用类型的参数的值是指向对象的指针。请注意，一个变量，一个引用类型为返回类型的方法调用 ，以及一个新的实例创建表达式。。。全部解析为引用类型值 所以 将字符串实例引用的值绑定到方法新创建的参数param。这正是传递值定义所描述的。因此，Java是按值传递的 您可以跟随引用来调用方法或访问被引用对象的字段，这一事实与对话完全无关。通过引用传递的定义是 这通常意味着功能可以修改，即分配给 变量用作调用者将看到的参数 在Java中，修改变量意味着重新分配它。在Java中，如果在方法中重新分配变量，调用者将不会注意到它。修改变量引用的对象是一个完全不同的概念原语值也在Java虚拟机规范中定义。该类型的值是相应的整数或浮点值，适当编码为8、16、32、64等位。让我通过四个示例来解释我的理解。Java是按值传递的，而不是按引用传递的 /** 传递值 在Java中，所有参数都是按值传递的，即调用方看不到分配方法参数 */ 例1： 结果 例2： /** * *传递值 * */ 结果 例3： /** 这个“传递值”有一种“传递引用”的感觉 有些人说基本类型和“字符串”是“按值传递” 对象是“按引用传递” 但从这个例子中，我们可以理解它实际上只是传递值， 请记住，这里我们将引用作为值传递。 ie：引用是通过值传递的。 这就是为什么我们能够改变，并且在局部范围之后仍然保持不变。 但我们不能在原始范围之外更改实际引用。 下面的PassByValueObjectCase2示例演示了这意味着什么 */ 结果 例4： /** 除了示例3 PassByValueObjectCase1.java中提到的内容之外，我们不能在原始范围之外更改实际引用 注意：我不是在为私立班学生粘贴代码。学生的班级定义与例3相同 */ 结果 在Java中，仅传递引用并按值传递： Java参数都是按值传递的。方法使用时复制引用： 对于基元类型，Java行为很简单： 该值将复制到基元类型的另一个实例中 对于对象，这是相同的： 对象变量是指针桶，只包含使用new关键字创建的对象地址，并像原语类型一样进行复制 该行为可能与基本类型不同：因为复制的对象变量包含同一对象的相同地址。 对象的内容/成员仍可能在方法内修改，然后在外部访问，从而产生包含对象本身通过引用传递的错觉 字符串对象似乎是城市图例的一个很好的反例，说明对象是通过引用传递的： 实际上，使用方法，您将永远无法更新作为参数传递的字符串的值： 字符串对象，由声明为final的数组保存不能修改的字符。 只有对象的地址可以被另一个使用new的地址替换。
使用new更新变量将不允许从外部访问对象，因为变量最初是按值传递并复制的。Java是按值传递的堆栈内存 工作原理 让我们首先了解java存储基本数据类型和对象数据类型的位置 基本数据类型本身和对象引用存储在堆栈中。 对象本身存储在堆中 这意味着，堆栈内存存储基本数据类型以及 对象的地址 您总是传递引用值位的副本
public class PassByCopy{
public static void changeName(Dog d){
d.name = "Fido";
}
public static void main(String[] args){
Dog d = new Dog("Maxx");
System.out.println("name= "+ d.name);
changeName(d);
System.out.println("name= "+ d.name);
}
}
class Dog{
public String name;
public Dog(String s){
this.name = s;
}
}
与其他一些语言不同，Java不允许您在按值传递和按引用传递之间进行选择。所有参数都是按值传递的。方法调用可以将两种类型的值传递给方法，即原语值的副本，例如int和double的值以及对象引用的副本 当方法修改基元类型参数时，对该参数的更改对调用方法中的原始参数值没有影响 对于对象，对象本身不能传递给方法。因此，我们传递对象的引用地址。我们可以使用此引用操纵原始对象
public class PassByCopy{
public static void changeName(Dog d){
d.name = "Fido";
}
public static void main(String[] args){
Dog d = new Dog("Maxx");
System.out.println("name= "+ d.name);
changeName(d);
System.out.println("name= "+ d.name);
}
}
class Dog{
public String name;
public Dog(String s){
this.name = s;
}
}
Account account1 = new Account();
public class Test
{
public static void reverseArray(int[] array1)
{
// ...
}
public static void main(String[] args)
{
int[] array1 = { 1, 10, -7 };
int[] array2 = { 5, -190, 0 };
reverseArray(array1);
}
}
array1[0] = 5;
array1 = array2;
public class Test
{
public static int[] reverseArray(int[] array1)
{
int[] array2 = { -7, 0, -1 };
array1[0] = 5; // array a becomes 5, 10, -7
array1 = array2; /* array1 of reverseArray starts
pointing to c instead of a (not shown in image below) */
return array2;
}
public static void main(String[] args)
{
int[] array1 = { 1, 10, -7 };
int[] array2 = { 5, -190, 0 };
array1 = reverseArray(array1); /* array1 of
main starts pointing to c instead of a */
}
}
您还可以在main中将array2的值分配给array1。array1将开始指向b。已经有很好的答案涵盖了这一点。我想通过分享一个非常简单的例子来做一个小小的贡献，它将编译对比C++中的按引用和java中的逐值行为。 有几点： 术语reference是一个有两种不同含义的重载。在Java中，它只是指一个指针，但在按引用传递的上下文中，它表示传入的原始变量的句柄。 Java是按值传递的。在其他语言中，Java是C语言的后代。在C之前，FORTRAN和COBOL等一些但并非所有早期语言都支持PBR，但C不支持。PBR allo 我们使用这些其他语言对子程序中传递的变量进行更改。为了完成同样的事情，即改变函数中变量的值，C程序员将变量的指针传递到函数中。受C语言启发的语言，如Java，借鉴了这一思想，并继续像C一样传递指向方法的指针，只是Java调用其指针引用。同样，这是一个不同的使用词的参考比传递参考。 C++允许通过使用与字符相同的字符来声明引用参数，该字符恰好是用来指示C和C++中变量的地址的字符。例如，如果我们通过引用传入指针，那么参数和参数就不仅仅指向同一个对象。相反，它们是相同的变量。如果一个被设置为不同的地址或null，那么另一个也会被设置为null。 在下面的C++示例中，我通过引用传递一个指向空终止字符串的指针。在下面的Java示例中，我再次将Java引用传递给字符串，与按值指向字符串的指针相同。注意注释中的输出。 C++按引用传递示例：
using namespace std;
#include <iostream>
void change (char *&str){ // the '&' makes this a reference parameter
str = NULL;
}
int main()
{
char *str = "not Null";
change(str);
cout<<"str is " << str; // ==>str is <null>
}
program passByRefDemo;
type
iptr = ^integer;
var
ptr: iptr;
procedure setToNil(var ptr : iptr);
begin
ptr := nil;
end;
begin
new(ptr);
ptr^ := 10;
setToNil(ptr);
if (ptr = nil) then
writeln('ptr seems to be nil'); { ptr should be nil, so this line will run. }
end.
public class PassByCopy{
public static void changeName(Dog d){
d.name = "Fido";
}
public static void main(String[] args){
Dog d = new Dog("Maxx");
System.out.println("name= "+ d.name);
changeName(d);
System.out.println("name= "+ d.name);
}
}
class Dog{
public String name;
public Dog(String s){
this.name = s;
}
}
changeReference(f);
void cppMethod(int val, int &ref, Dog obj, Dog &objRef, Dog *objPtr, Dog *&objPtrRef)
{
val = 7; // Modifies the copy
ref = 7; // Modifies the original variable
obj.SetName("obj"); // Modifies the copy of Dog passed
objRef.SetName("objRef"); // Modifies the original Dog passed
objPtr->SetName("objPtr"); // Modifies the original Dog pointed to
// by the copy of the pointer passed.
objPtr = new Dog("newObjPtr"); // Modifies the copy of the pointer,
// leaving the original object alone.
objPtrRef->SetName("objRefPtr"); // Modifies the original Dog pointed to
// by the original pointer passed.
objPtrRef = new Dog("newObjPtrRef"); // Modifies the original pointer passed
}
int main()
{
int a = 0;
int b = 0;
Dog d0 = Dog("d0");
Dog d1 = Dog("d1");
Dog *d2 = new Dog("d2");
Dog *d3 = new Dog("d3");
cppMethod(a, b, d0, d1, d2, d3);
// a is still set to 0
// b is now set to 7
// d0 still have name "d0"
// d1 now has name "objRef"
// d2 now has name "objPtr"
// d3 now has name "newObjPtrRef"
}
我们通常会说，通过引用传递的变量可以进行变异。这个术语出现在教科书中是因为语言理论家需要一种方法来区分原始数据类型int、bool、byte和复杂的结构化对象数组、流、类，也就是说，那些可能是无限内存分配的对象。我想指出的是，在大多数情况下，你不必考虑这一点。我编程java多年，直到我学会C++。直到现在，我还不知道什么是passbyreference和passbyvalue。直观的解决方案总是对我有用，这就是为什么java是初学者最好的语言之一。因此，如果您当前担心，如果您的函数需要引用或值，只需按原样传递它就可以了。Java按值传递引用。简而言之，这种混淆是因为在Java中，所有非原始数据类型都是通过引用处理/访问的。然而，传递总是有价值的。所以对于所有非基本类型，引用都是通过其值传递的。所有的原始类型也都是通过值传递的。对于那些来自C++的人，当接触java时会开始混淆，这是错误的。java调用C++调用什么指针。java C++中不存在C++调用的内容。C++引用是指针类型，但具有全局范围。当您更改C++引用时，引用中的所有事件都会发生变化，无论是在调用函数中还是在调用函数中。Java不能做到这一点。Java是严格按值传递的，对Java引用的更改是严格本地的。Java被调用函数无法更改调用函数的引用值。您可以通过使用像AtomicReference这样的包装对象来模拟C++引用。C++引用与范围无关。在实现中，它们就像不允许有空值的指针。除此之外的主要区别在于，它们在语法上表现为引用数据的别名。在Java中，引用的工作方式几乎相同，但有特殊的规则允许：使用==运算符与null和其他引用值进行比较。C++也通过值，虽然该值可以是引用的指针/引用。调用方法对C++引用的更改也可以通过调用方法来显示。这在Java中是不存在的，也不是指针式的行为。在Java和C中，指针值的更改仅限于本地。我不知道如何正确地调用这种行为，但它有点类似于某些脚本语言的外部范围。例如，正确的按引用传递请参见此处的swap程序：不可能在Java中编写具有相同副作用的swap方法。语言引用的质量是C++引用中不存在的，它不存在于java引用或C指针中。我还要补充一点，即pass-by-value字面意思是传递堆栈中的文本值。那么，在第一个示例中，Fifi会发生什么情况？它是否不再存在，它是否从未创建过，或者它是否存在于堆中，但在堆栈中没有引用变量？对我来说，说对象的引用是按值传递的与说对象是按引用传递的是一样的。我是一个Java新手，但我认为与此相反，基本数据是passB
y值。@user36800:你错了。您是否使用Fifi完成了示例并仔细查看了结果？检查是否确实是fooaDog；尽管foo覆盖了d的值，但没有更改aDog，这表明函数的所有输入都是通过值传递的。@user36800:嗯，这两个语句都是错误的。通过引用传递对象意味着，如果函数修改变量，那么它将修改对象本身。这不是Java中发生的事情；对象不能通过引用传递，但只能将引用作为输入传递给函数，当函数执行d=newdogffi时；它覆盖输入变量d，该变量存储引用，但不是“引用传递的对象”。与C中的函数签名中的&d相反，它将通过引用传递。[cont]@dbrewster很抱歉，但是。。。Fifi不再在我们当中了JVM2.2非常清楚地表明了这一点：有。。。可以存储在变量中、作为参数传递、由方法返回和操作的两种值：原语值和引用值。对象引用是值。所有的东西都是通过值传递的。这表明java不是通过值，因为它不象C++那样把整个对象复制到堆栈上，如上面的例子……，狗Objo，…，没有，java按值传递引用。这就是为什么在java示例中覆盖objPtr时，原始Dog对象不会改变。但是，如果修改objPtr指向的对象，它会这样做。Java总是按值传递参数，但按值传递的是对对象的引用，而不是对象的副本。简单吗？我希望我学习Java的Herbert Schildt书在上面的例子中教过这个小的澄清问题，所以当在地址72的BBB创建新狗时，这是否意味着在返回时，创建的狗在72岁时，它的价值会丢失并恢复到42？@ebresie@ebresie大部分是的，我稍后会澄清大部分。指向74的新狗的唯一指针我想你指的是74而不是72是foo函数的参数。当foo返回时，它的所有参数都从堆栈中弹出，因此没有任何参数指向72，可以对其进行垃圾收集。我说的主要是因为没有发生逆转；调用者中的指针myDog一直指向42，并且从未更改，无论函数中发生了什么，因此，没有还原。但是，您不能更改该指针指向的位置。->但是，你不能用其他方法改变指针指向的位置。@NiharGht好的观点-我已经澄清了，如果仍然不清楚，请再次评论好的工作人员，你已经说清楚了。请有人投票否决这个答案，因为它不包含任何解释，而且有抄袭他人答案的味道！我没有足够的声望投票否决这个无用的答案。
array1[0] = 5;
array1 = array2;
public class Test
{
public static int[] reverseArray(int[] array1)
{
int[] array2 = { -7, 0, -1 };
array1[0] = 5; // array a becomes 5, 10, -7
array1 = array2; /* array1 of reverseArray starts
pointing to c instead of a (not shown in image below) */
return array2;
}
public static void main(String[] args)
{
int[] array1 = { 1, 10, -7 };
int[] array2 = { 5, -190, 0 };
array1 = reverseArray(array1); /* array1 of
main starts pointing to c instead of a */
}
}
using namespace std;
#include <iostream>
void change (char *&str){ // the '&' makes this a reference parameter
str = NULL;
}
int main()
{
char *str = "not Null";
change(str);
cout<<"str is " << str; // ==>str is <null>
}
public class ValueDemo{
public void change (String str){
str = null;
}
public static void main(String []args){
ValueDemo vd = new ValueDemo();
String str = "not null";
vd.change(str);
System.out.println("str is " + str); // ==> str is not null!!
// Note that if "str" was
// passed-by-reference, it
// WOULD BE NULL after the
// call to change().
}
}
program passByRefDemo;
type
iptr = ^integer;
var
ptr: iptr;
procedure setToNil(var ptr : iptr);
begin
ptr := nil;
end;
begin
new(ptr);
ptr^ := 10;
setToNil(ptr);
if (ptr = nil) then
writeln('ptr seems to be nil'); { ptr should be nil, so this line will run. }
end.