fuliang wrote:
二、反驳经典java书籍中的论点：
既然java中的referece的行为更象指针。那么下面来看看其作为参数传的的时候行为究竟如何（by value or by referece）：
在一些经典的java书上（《Core java》和《Thinking in java》堪称是最经典的两部了吧），书上都明确指出All by Value.
即：不管是基本类型还是object都是值传递，并举了足以“让高手信服的例子”,笔者认为其论据“严重不足”:

Some people will say incorrectly that objects are passed "by reference." In programming language design, the term pass by reference properly means that when an argument is passed to a function, the invoked function gets a reference to the original value, not a copy of its value. If the function modifies its parameter, the value in the calling code will be changed because the argument and parameter use the same slot in memory. The Java programming language does not pass objects by reference; it passes object references by value. Because two copies of the same reference refer to the same actual object, changes made through one reference variable are visible through the other. There is exactly one parameter passing mode -- pass by value -- and that helps keep things simple.

Pass by Value
In Java methods, arguments are passed by value.

When invoked, the method receives the value of the variable passed in. When the argument is of primitive type, pass-by-value means that the method cannot change its value. When the argument is of reference type, pass-by-value means that the method cannot change the object reference, but can invoke the object's methods and modify the accessible variables within the object.

This is often the source of confusion--a rogrammer writes a method that attempts to modify the value of one its arguments and the method doesn't work as expected. Let's look at such method and then investigate how to change it so that it does what the programmer originally intended.

Q. What is the differences between pass-by-value and pass-by-reference?

A: These two will never mix!!!
Pass-by-value : You make a copy of the parameter (argument), and use it inside of the methods. The value of the parameter (argument) will not be affected outside of the method.

Pass-by-references : you do NOT make a copy of the parameter, you use the parameter itself!

Q. Why we say, in c or Java, everything is pass-by-value?
A:
In c and Java, everything is pass-by-value.

In c++ and Pascal, you can pass-by-value or pass-by-reference.

When we code in C, you pass pointers to a method, the value of pointer (address) will never change, but the value the pointer points to will change.

In language theory, C is a only-pass-by-value language. Actually, this is exactly Java does. Java Object reference is equivalent to C pointer, the difference is you cannot dereference it, which makes java safer, but less flexible.

Since in C, you can dereference a pointer, you actually can prove the pointer is passed by value. A simple test can prove that, you dereference the pointer inside/outside the method call, you will get two different values, which proves inside the method, what we are using actually a copy of the pointer, not the pointer itself. That is exactly what pass-by-value means. You make a copy of the parameter (argument), and use it inside of the methods. The value of the parameter (argument) will not be affected outside of the method.

In Java, value of an object reference is the reference. That is the source of confusion. However, if you read it twice, it only makes sense. Doesn't it?

public class TestParameter {
  public TestParameter() {
  }

  public static void main(String[] args) {
    TestParameter tp=new TestParameter();
    StringBuffer sb=new StringBuffer("java");
    System.out.println("The inital value of StringBuffer is:"+sb);
    tp.testNew(sb);
    System.out.println("The value of StringBuffer after invoking method testNew is:"
                       +sb);
    tp.testAppend(sb);
    System.out.println("The value of StringBuffer after invoking method testAppend is:"
                       +sb);
  }

  public String testAppend(StringBuffer sb){
    sb.append(",test");
    System.out.println("The value of StringBuffer in method testAppend is:"+sb);
    return sb.toString();

  }

  public String testNew(StringBuffer sb){
    sb=new StringBuffer();
    sb.append(",test");
    System.out.println("The value of StringBuffer in method testNew is:"+sb);
    return sb.toString();
  }

}

ken0719 wrote:
关于传值还是传引用，我也有着个困惑，开始学java看书的时候，知道说的是java的参数是传值，写代码验证，如果传递一个基本类型，是值传递的，如果参数是一个对象，在方法中对该句柄重新初始化一个对象，原来的对象也不会改变，但是后来发现一个问题，例如，传递一个StringBuffer类型参数，在方法中调用StringBuffer的append方法，原来的对象的内容也是会改变的，看着又像是传递引用了。