java中的经典问题:传值与传引用


参数传递的秘密 

知道方法参数如何传递吗? 
记得刚开始学编程那会儿,老师教导,所谓参数,有形式参数和实际参数之分,参数列表中写的那些东西都叫形式参数,在实际调用的时候,它们会被实际参数所替代。 
编译程序不可能知道每次调用的实际参数都是什么,于是写编译器的高手就出个办法,让实际参数按照一定顺序放到一个大家都可以找得到的地方,以此作为方法调用的一种约定。所谓“没有规矩,不成方圆”,有了这个规矩,大家协作起来就容易多了。这个公共数据区,现在编译器的选择通常是“栈”,而所谓的顺序就是形式参数声明的顺序。 
显然,程序运行的过程中,作为实际参数的变量可能遍布于内存的各个位置,而并不一定要老老实实的呆在栈里。为了守“规矩”,程序只好将变量复制一份到栈中,也就是通常所说的将参数压入栈中。 
打起精神,谜底就要揭晓了。 
我刚才说什么来着?将变量复制一份到栈中,没错,“复制”! 

这就是所谓的值传递。


C语言的旷世经典《The C Programming Language》开篇的第一章中,谈到实际参数时说,“在C中,所有函数的实际参数都是传‘值’的”。 
马上会有人站出来,“错了,还有传地址,比如以指针传递就是传地址”。 
不错,传指针就是传地址。在把指针视为地址的时候,是否考虑过这样一个问题,它也是一个变量。前面的讨论中说过了,参数传递必须要把参数压入栈中,作为地址的指针也不例外。所以,必须把这个指针也复制一份。函数中对于指针操作实际上是对于这个指针副本的操作。 
Java的reference等于C的指针。所以,在Java的方法调用中,reference也要复制一份压入堆栈。在方法中对reference的操作就是对这个reference副本的操作。 
谜底揭晓 
好,让我们回到最初的问题上。 
在changeReference中对于reference的赋值实际上是对这个reference的副本进行赋值,而对于reference的本尊没有产生丝毫的影响。 
回到调用点,本尊醒来,它并不知道自己睡去的这段时间内发生过什么,所以只好当作什么都没发生过一般。就这样,副本消失了,在方法中对它的修改也就烟消云散了。 

也许你会问出这样的问题,“听了你的解释,我反而对changeInteger感到迷惑了,既然是对于副本的操作,为什么changeInteger可以运作正常?” 
呵呵,很有趣的大脑短路现象。 
好,那我就用前面的说法解释一下changeInteger的运作。 
所谓复制,其结果必然是副本完全等同于本尊。reference复制的结果必然是两个reference指向同一块内存空间。 
虽然在方法中对于副本的操作并不会影响到本尊,但对内存空间的修改确实实实在在的。 
回到调用点,虽然本尊依然不知道曾经发生过的一切,但它按照原来的方式访问内存的时候,取到的确是经过方法修改之后的内容。 
于是方法可以把自己的影响扩展到方法之外。


1.所有的参数传递都是 传值,从来没有 传引用 这个事实;
2. 所有的参数传递都会在 程序运行栈上 新分配一个 值 的复制品;

3.java只有按值传递,所谓的按地址(引用)传递,也属于按值传递,只不过这个“值”是个地址;

4.对于引用类型的传参也是传值的,传的是引用类型的值,其实就是对象的地址;

1.java参数是传递值的。
2.java所有对像变量都是对像的引用;

5.或者说:传递过去的都是拷贝,区别在于拷贝的是基本数据类型还是引用;

6.函数的形式参数,是传入参数的拷贝;引用变量之间拷贝的是【地址】,基本变量之间拷贝的是 内存中的值 (被称为直接量);
7.对象本身,与对象的地址 是2个东西,函数之间如果想【传递对象】,只能通过传递对象的地址来实现;

程序1:

public class Test
{
	String a = "123";
	public static void test(Test test)
	{
		test.a = "abc";
	}

	public static void main(String[] args)
	{
		Test test1 = new Test();
		test1.a = "567";
		System.out.println(test1.a); //567
		
		test(test1);
		System.out.println(test1.a); //abc
		
	}
}

程序2:

public class Test
{
	public static void test(String str)
	{
		str = "word";
	}

	public static void main(String[] args)
	{
		String string = "hello";
		System.out.println(string);  //hello
		test(string);
		System.out.println(string);  //hello
	}
}

程序3:

public class Test
{
	public static void test(StringBuffer str)
	{
		str.append("world");
	}
	public static void main(String[] args)
	{	
		StringBuffer str = new StringBuffer("hello");
		System.out.println(str);  //hello
		test(str);
		System.out.println(str);  //helloworld
	}
}


程序4:

public class Test
{
	public static void test(StringBuffer str)
	{
		str = new StringBuffer("world");
	}
	public static void main(String[] args)
	{	
		StringBuffer str = new StringBuffer("hello");
		System.out.println(str);  //hello
		test(str);
		System.out.println(str);  //hello
	}
}


1.传递的参数“值” 会在 函数当前运行栈上 复制一份。所有的 操作和赋值 都是对那个 参数“值”副本 进行的。操作能够 改变成员变量,因为参数“值”副本 是一个 地址,能够正确指向成员变量的位置。而赋值 则根本没用,因为只是改变了当前函数栈内 参数“值”副本 的内容,而没有改变上一层函数栈内的 对应“值”;

2.=和.

=(等号)操作的是变量的值;

.(句点)操作的是引用的值;

3.关于传参的问题只要把栈和堆搞明白了就应该很容易理解了:

java传参都是传值,也就是把栈里面的值复制一份传给参数;
当然如果是原始类型就是栈内原始类型值复制了一份传递;
如果是对象或者数组这样的引用类型,那么栈里面的值就是该对象的引用的值具体说就是地址了,把这个值复制一份传给方法,也就是复制了一个引用给方法去使用;

例如:
 public void func1(int a){}
 
 int i = 10;
 func1(i);  的时候,实际上是作了a=i的操作
 而对象
 public void fun2(Object o){}
 
Object m = new Object();
 func2(m);的时候,也其实是作了o=m的操作

另一个程序:
import java.io.Console;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.*; 

class People
{   
	public int age;  
	public static void Swap(People a1, People a2)
	{     
		People tem;   
		tem = a1;    
		a1 = a2;     
		a2 = tem; 
	}  
	public static void Change(People a1, People a2)
	{      
		a1.age = 250;  
		a2.age = 250;   
	}
}
public class Empty
{ 
	public static void main(String[]args)    
	{        
		People a1 = new People();    
		People a2 = new People();  
		a1.age = 1;  
		a2.age = 2;  
		
		//这里没能交换,看起来是按值传递       
		People.Swap(a1, a2);      
		System.out.printf("%d \t %d", a1.age, a2.age);             
		System.out.println();  
		
		//这里修改了变量,看起来是按引用传递        People.Change(a1, a2);    
		System.out.printf("%d \t %d", a1.age, a2.age); 
	}
}



看上图,方法的参数可以看做是另一个变量:a1_和a2_
它们只是和传入参数拥有相同的对象地址而已;
对于交换对象也只是对a1_和a2_这两个做交换罢了,不会影响a1,a2;
但如果是通过内存地址去修改对象内部,如改变age的值,则会影响a1,a2;




首先,推荐对Java有一定理解的同仁一本书《Practical Java》。在《Practical Java》中也有一个章节介绍Java中关于传值和传引用的问题,堪称经典。《Practical Java》在Java中,事实上底层工作原理不存在传引用的概念,这也象《Practical Java》中所说的那样,Java中只有传值。这句话理解起来需要费一定的周折。

熟悉C的程序员都用过指针,对指针可谓爱之深恨之切。指针是指向一块内存地址的内存数据(有些拗口),也就是说指针本身是一个占用4字节内存的int(32 位系统内),而这个int值恰恰又是另一块内存的地址。比如"hello"这个字串,存放在@0x0000F000这个地址到@0x0000F005这段内存区域内(包括0x00的结束字节)。而在@0x0000FFF0到@0x0000FFF03这四个字节内存放着一个int,这个int的值是 @0x0000F000。这样就形成了一个指向"hello"字串的指针。

在Java中,很多人说没有指针,事实上,在Java更深层次里,到处都是大师封装好的精美绝伦的指针。为了更容易的讲解Java中关于类和类型的调用,Java中出现了值与引用的说法。浅显的来说,我们可以认为Java中的引用与C中的指针等效(其实差别非常非常大,但是为了说明我们今天的问题,把他们理解为等效是没有任何问题的)。

所谓传引用的说法是为了更好的讲解调用方式。基于上面对指针的理解,我们不难看出,指针其实也是一个int值,所谓传引用,我们是复制了复制了指针的int值进行传递。为了便于理解,我们可以姑且把指针看作一种数据类型,透明化指针的int特性,从而提出传引用的概念。

重申一遍:Java中只有传值。

1所谓传值和传引用

传值和传引用的问题一直是Java里争论的话题。与C++不同的,Java里面没有指针的概念,Java的设计者巧妙的对指针的操作进行了管理。事实上,在懂C++的Java程序员眼中,Java到处都是精美绝伦的指针。
下面举个简单的例子,说明什么是传值,什么是传引用。
//例1
void method1(){
int x=0;
this.change(x);
System.out.println(x);
}

void change(int i){
i=1;
}

很显然的,在mothod1中执行了change(x)后,x的值并不会因为change方法中将输入参数赋值为1而变成1,也就是说在执行change(x)后,x的值z依然是0。这是因为x传递给change(int i)的是值。这就是最简单的传值。
同样的,进行一点简单的变化。
//例2
void method1(){
StringBuffer x=new StringBuffer("Hello");
this.change(x);
System.out.println(x);
}

void change(StringBuffer i){
i.append(" world!");
}
看起来没什么变化,但是这次mothed1中执行了change (x)后,x的值不再是"Hello"了,而是变成了"Hello world!"。这是因为x传递给change(i)的是x的引用。这是最经典的传引用。
似乎有些奇怪了,两段程序没有特别的不同,可是为什么一个传的是值而另一个传的是引用呢?......

2非要搞清楚传值还是传引用的问题吗?

搞清楚这自然是有必要的,不然我也不需要写这么多了,不过的确没有到"非要"的地步。


首先,如果我们不太关心什么是传值什么是传引用,我们一样能写出漂亮的代码,但是这些代码在运行过程中可能会存在着极大的隐患。全局变量是让大家深恶痛绝(又难以割舍)的东西,原因就是使用全局变量要特别注意数据的保护。如果在多线程的程序里使用全局变量简直就等于跟自己过不去。不了解传值和传引用的问题,跟使用全局变量不考虑数据保护的罪过是不相上下下的,甚至有时候比它还要糟。你会莫名其妙,为什么我的返回参数没有起作用,为什么我传进去的参数变成了这样......?
一个例子:
//例3
void mothed1(){
int x=0;
int y=1;
switchValue(x,y);
System.out.println("x="+x);
System.out.println("y="+y);
}
void switchValue(int a,int b){

int c=a;
a=b;
b=c;
}
上面是一个交换a,b值的函数,看起来似乎蛮正确的,但是这个函数永远也不会完成你想要的工作。
还有一个例子:
//例4
StringBuffer a=new StringBuffer("I am a ");
StringBuffer b=a;
a.append("after append");
a=b;
System.out.println("a="+a);
在编程过程中,经常会遇到这种情况,一个变量的值要被临时改变一下,等用完之后再恢复到开始的值。就好像上面的例子,a为了保持它的值,使用b=a做赋值,之后a被改变,再之后a把暂存在b里面的值取回来。这是我们一厢情愿的想法,而事实上,这段代码执行后,你会发现a的值已经改变了。
以上是两个最简单的例子,真正的程序开发过程中,比这要复杂的情况每天都会遇到。

3类型和类

Java 提出的思想,在Java里面任何东西都是类。但是Java里面同时还有简单数据类型int,byte,char,boolean,与这些数据类型相对应的类是Integer,Byte,Character,Boolean,这样做依然不会破坏Java关于任何东西都是类的提法。这里提到数据类型和类似乎和我们要说的传值和传引用的问题无关,但这是我们分辨传值和传引用的基础。

4试图分辨传值还是传引用

为什么是"试图分辨"呢?很简单,传值和传引用的问题无处不在,但是似乎还没有人能正统的给出标准,怎样的就是值拷贝调用,怎样的就是引用调用。面对这个问题,我们更多的应该是来自平时积累对Java的理解。
回过头来,我们分析一下上面的几个例子:
先看例1,即使你不明白为什么,但是你应该知道这样做肯定不会改变x的值。为了方便说明,我们给例子都加上行号。
//例1
1 void method1(){
2 int x=0;
3 this.change(x);
4 }
5
6 void change(int i){
7 i=7;
8}
让我们从内存的存储方式看一下x和I之间到底是什么关系。
在执行到第2行的时候,变量x指向一个存放着int 0的内存地址。

变量x---->[存放值0]

执行第3行调用change(x)方法的时候,内存中是这样的情形:x把自己值在内存中复制一份,然后变量i指向这个被复制出来的0。

变量x---->[存放值0]
↓进行了一次值复制
变量x---->[存放值0]

这时候再执行到第7行的时候,变量i的被赋值为7,而这一步的操作已经跟x没有任何关系了。

变量x---->[存放值0]

变量x---->[存放值7]

说到这里应该已经理解为什么change(x)不能改变x的值了吧?因为这个例子是传值的。
那么,试着分析一下为什么例三中的switchValue()方法不能完成变量值交换的工作?
再看例2。
//例2
1void method1(){
2 StringBuffer x=new StringBuffer("Hello");
3 this.change(x);
4}
5
6void change(StringBuffer i){
7 i.append(" world!");
8}
例2似乎和例1从代码上看不出什么差别,但是执行结果却是change(x)能改变x的值。依然才从内存的存储角度来看看例2的蹊跷在哪里。
在执行到第2行时候,同例1一样,x指向一个存放"Hello"的内存空间。

变量x---->[存放值"Hello"]

接下来执行第三行change(x),注意,这里就与例1有了本质的不同:调用change(x)时,变量i也指向了x指向的内存空间,而不是指向x的一个拷贝。

变量x \
-->[存放值"Hello"]
变量x /

于是,第7行对i调用append方法,改变i指向的内存空间的值,x的值也就随之改变了。

变量x \
-->[追加为"Hello World!"]
变量x /

为什么x值能改变呢?因为这个例子是传引用的。
这几个例子是明白了,可是很多人会开始有另一个疑问了:这样看来,到底什么时候是传的值什么时候是传得引用呢?于是,我们前面讲到的类型和类在这里就派上了用场:对于参数传递,如果是简单数据类型,那么它传递的是值拷贝,对于类的实例它传递的是类的引用。需要注意的是,这条规则只适用于参数传递。为什么这么说呢?我们看看这样一个例子:
//例5
String str="abcdefghijk";
str.replaceAll("b","B");
这两句执行后,str的内容依然是"abcdefghijk",但是我们明明是对str操作的,为什么是这样的呢?因为str的值究竟会不会被改变完全取决于replaceAll这个方法是怎么实现的。类似的,有这样一个例子:
//例6
1 void method1() {
2 StringBuffer x = new StringBuffer("Hello");
3 change1(x);
4 System.out.println(x);
5 }
6
7 void method2() {
8 StringBuffer x = new StringBuffer("Hello");
9 change2(x);
10 System.out.println(x);
11 }
12
13 void change1(StringBuffer sb) {
14 sb.append(" world!");
15 }
16
17 void change2(StringBuffer sb) {
18 sb = new StringBuffer("hi");
19 sb.append(" world!");
20 }
调用method1(),屏幕打印结果为:"Hello world!"
调用method2(),我们认为结果应该是"hi world",因为sb传进来的是引用。可是实际执行的结果是"Hello"!
难道change2()又变成传值了?!其实change1()和change2()的确都是通过参数传入引用,但是在方法内部因为处理方法的不同而使结果大相径庭。我们还是从内存的角度分析:
执行method1()和change1()不用再多说了,上面的例子已经讲解过,这里我们分析一下method2()和change2()。
程序执行到第8行,x指向一个存放着"Hello"的内存空间。

变量x---->[存放值"Hello"]

第9行调用change2,将sb指向x指向的内存空间,也就是传入x的引用。

变量x \
-->[存放值"Hello"]
变量x /

到这里为止还没有什么异样,接下来执行18行,这里就出现了类似传入值拷贝的变化:new 方法并没有改变sb指向内存的内容,而是在内从中开辟了一块新的空间存放串"hi",同时sb指向了这块空间。

变量x---->[存放值"Hello"]
×原有的引用被切断
变量x---->[另一块存放"hi"的空间]

接下来再对sb进行append已经和x没有任何关系了。
所以,还有一条不成规则的规则:对于函数调用,最终效果是什么完全看函数内部的实现。比较标准的做法是如果会改变引用的内容,则使用void作为方法返回值,而不会改变引用内容的则在返回值中返回新的值。
虽然已经说了这么多,但是感觉传值还是传引用的问题依然没有完全说清楚。因为这个问题本身就是很难归纳总结的问题,所以更多的理解要靠平时的积累和形成。下面几个例子,给大家尝试进行分析。
//例7,打印结果是什么?
public static void main(String[] args) {
int a;
int b;
StringBuffer c;
StringBuffer d;
a = 0;
b = a;
c = new StringBuffer("This is c");
d = c;

a = 2;
c.append("!!");

System.out.println("a=" + a);
System.out.println("b=" + b);
System.out.println("c=" + c);
System.out.println("d=" + d);
}

//例8,打印结果是什么?
public class Test{

public static void main(String[] args) {

StringBuffer sb = new StringBuffer("Hello ");

System.out.println("Before change, sb = " + sb);

changeData(sb);

System.out.println("After changeData(n), sb = " + sb);

}

public static void changeData(StringBuffer strBuf) {

StringBuffer sb2 = new StringBuffer("Hi ");

strBuf = sb2;

sb2.append("World!");

}

}




文章部分参考自:

Java基本功——Reference

传值还是传引用

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页