在理解这两个术语之前，您必须了解以下内容。每一个物体都有两个可以使它被区分的东西。

它的价值。 它的地址。

如果你说employee。name = "John"，要知道关于name有两件事。它的值是“John”，它在内存中的位置是一个十六进制数，可能像这样:0x7fd5d258dd00。

根据语言的体系结构或对象的类型(类、结构等)，可以传输“John”或0x7fd5d258dd00

传递“John”称为按值传递。

传递0x7fd5d258dd00称为引用传递。任何指向这个内存位置的人都可以访问“John”的值。

有关这方面的更多信息，我建议您阅读有关取消指针引用的内容，以及为什么选择struct(值类型)而不是类(引用类型)。

A major difference between them is that value-type variables store values, so specifying a value-type variable in a method call passes a copy of that variable's value to the method. Reference-type variables store references to objects, so specifying a reference-type variable as an argument passes the method a copy of the actual reference that refers to the object. Even though the reference itself is passed by value, the method can still use the reference it receives to interact with—and possibly modify—the original object. Similarly, when returning information from a method via a return statement, the method returns a copy of the value stored in a value-type variable or a copy of the reference stored in a reference-type variable. When a reference is returned, the calling method can use that reference to interact with the referenced object. So, in effect, objects are always passed by reference.

In c#, to pass a variable by reference so the called method can modify the variable's, C# provides keywords ref and out. Applying the ref keyword to a parameter declaration allows you to pass a variable to a method by reference—the called method will be able to modify the original variable in the caller. The ref keyword is used for variables that already have been initialized in the calling method. Normally, when a method call contains an uninitialized variable as an argument, the compiler generates an error. Preceding a parameter with keyword out creates an output parameter. This indicates to the compiler that the argument will be passed into the called method by reference and that the called method will assign a value to the original variable in the caller. If the method does not assign a value to the output parameter in every possible path of execution, the compiler generates an error. This also prevents the compiler from generating an error message for an uninitialized variable that is passed as an argument to a method. A method can return only one value to its caller via a return statement, but can return many values by specifying multiple output (ref and/or out) parameters.

请参阅c#讨论和示例链接文本

最简单的方法是在Excel文件中获取。举个例子，有两个数字，5和2分别在A1和B1单元格中，你想在第三个单元格中求出它们的和，假设是A2。

有两种方法可以做到这一点。

通过在单元格中输入= 5 + 2将它们的值传递给单元格A2。在这种情况下，如果单元格A1或B1的值发生变化，则A2中的总和保持不变。 或者通过输入= A1 + B1将单元格A1和B1的“引用”传递给单元格A2。在这种情况下，如果单元格A1或B1的值发生变化，A2中的总和也会发生变化。

在理解这两个术语之前，您必须了解以下内容。每一个物体都有两个可以使它被区分的东西。

它的价值。 它的地址。

如果你说employee。name = "John"，要知道关于name有两件事。它的值是“John”，它在内存中的位置是一个十六进制数，可能像这样:0x7fd5d258dd00。

根据语言的体系结构或对象的类型(类、结构等)，可以传输“John”或0x7fd5d258dd00

传递“John”称为按值传递。

传递0x7fd5d258dd00称为引用传递。任何指向这个内存位置的人都可以访问“John”的值。

有关这方面的更多信息，我建议您阅读有关取消指针引用的内容，以及为什么选择struct(值类型)而不是类(引用类型)。

It's a way how to pass arguments to functions. Passing by reference means the called functions' parameter will be the same as the callers' passed argument (not the value, but the identity - the variable itself). Pass by value means the called functions' parameter will be a copy of the callers' passed argument. The value will be the same, but the identity - the variable - is different. Thus changes to a parameter done by the called function in one case changes the argument passed and in the other case just changes the value of the parameter in the called function (which is only a copy). In a quick hurry:

Java only supports pass by value. Always copies arguments, even though when copying a reference to an object, the parameter in the called function will point to the same object and changes to that object will be see in the caller. Since this can be confusing, here is what Jon Skeet has to say about this. C# supports pass by value and pass by reference (keyword ref used at caller and called function). Jon Skeet also has a nice explanation of this here. C++ supports pass by value and pass by reference (reference parameter type used at called function). You will find an explanation of this below.

代码

因为我的语言是c++，我将在这里使用它

// passes a pointer (called reference in java) to an integer
void call_by_value(int *p) { // :1
    p = NULL;
}

// passes an integer
void call_by_value(int p) { // :2
    p = 42;
}

// passes an integer by reference
void call_by_reference(int & p) { // :3
    p = 42;
}

// this is the java style of passing references. NULL is called "null" there.
void call_by_value_special(int *p) { // :4
    *p = 10; // changes what p points to ("what p references" in java)
    // only changes the value of the parameter, but *not* of 
    // the argument passed by the caller. thus it's pass-by-value:
    p = NULL;
}

int main() {
    int value = 10;
    int * pointer = &value;

    call_by_value(pointer); // :1
    assert(pointer == &value); // pointer was copied

    call_by_value(value); // :2
    assert(value == 10); // value was copied

    call_by_reference(value); // :3
    assert(value == 42); // value was passed by reference

    call_by_value_special(pointer); // :4
    // pointer was copied but what pointer references was changed.
    assert(value == 10 && pointer == &value);
}

Java中的一个例子不会有什么坏处:

class Example {
    int value = 0;

    // similar to :4 case in the c++ example
    static void accept_reference(Example e) { // :1
        e.value++; // will change the referenced object
        e = null; // will only change the parameter
    }

    // similar to the :2 case in the c++ example
    static void accept_primitive(int v) { // :2
        v++; // will only change the parameter
    }        

    public static void main(String... args) {
        int value = 0;
        Example ref = new Example(); // reference

        // note what we pass is the reference, not the object. we can't 
        // pass objects. The reference is copied (pass-by-value).
        accept_reference(ref); // :1
        assert ref != null && ref.value == 1;

        // the primitive int variable is copied
        accept_primitive(value); // :2
        assert value == 0;
    }
}

维基百科

http://en.wikipedia.org/wiki/Pass_by_reference#Call_by_value

http://en.wikipedia.org/wiki/Pass_by_reference#Call_by_reference

这家伙说得很准:

http://javadude.com/articles/passbyvalue.htm

当通过引用传递时，基本上是传递一个指向变量的指针。通过值传递，即传递变量的副本。

在基本用法中，这通常意味着通过引用传递，对变量的更改将在调用方法中看到，而在通过值传递时则不会。