Java语言中方法之间数据传递的探讨
Java语言中方法之间数据传递的探讨
导语：在面向对象的Java语言中，方法是处理数据的基本模块，方法之间的数据传递是掌握编程方法的关键。下面就由为大家介绍一下Java语言中方法之间数据传递的探讨，欢迎大家阅读!
1问题的提出
在面向对象的Java语言中，类是问题空间的高度抽象和概括，是一个模板，而对象是类的特例，解空间的具体实现则是由若干个类的对象集合而成。方法是类的动态属性，代表了类所具有的功能和操作。Java语言中的方法既可以在类中，也可以在接口中声明，但是，它们只能在类中实现。Java语言中的所有操作都是用方法来实现的。
一个方法通过另一个方法的调用被激活，一个被调用的方法被激活，既需要指定被调用方法的方法名，也需要为被调用的方法提供相应的数据，以便于被调用方法对数据的加工处理，乃至于将加工处理的结果返回给方法的调用者。
2Java语言中方法间的数据传递方法
方法是数据加工处理或相应操作的基本模块，为了实现某种需求而调用一个方法，需要为被调用的方法传递数据，以便于被调用的方法依据所提供的数据进行相应的操作。
C++语言的函数间的数据传递可以分为：数值传递、地址传递和引用传递。地址传递的形参是同类型的指针，由于指针操作的不安全等问题，Java语言屏弃了指针，故Java语言方法之间的数据传递只有数值传递和引用传递。
2.1方法间的数值传递
所谓的数值传递又称为值传递，数值传递的特征是：调用方法的实参可以是常量、变量或者是表达式，形参则是对应数据类型的变量。如果实参是变量，则实参和形参是相互独立的两个单元。在方法调用的过程中，实参的值将拷贝到形参中，此后形参的任何修改都不会影响实参。数值传递方法见例1。
[例1]数值传递调用方法举例：
importjava.io.*;
publicclassValueTransmit
{publicstaticvoidmain(Stringargs[])
{intx=5,y=66;
System.out.println(“在主方法，交换前的：x=”+x+“,y=”+y);
swap(x,y);
System.out.println(“在主方法，交换后的：x=”+x+“,y=”+y);
}
staticvoidswap(intx,inty)
{inttemp;
System.out.println(“在swap方法未交换时：x=”+x+“,y=”+y);
temp=x;x=y;y=temp;
System.out.println(“在swap方法交换之后：x=”+x+“,y=”+y);
}
}
例1程序的输出结果如下所示：
在主方法，交换前的：x=5,y=66
在swap方法未交换时：x=5,y=66
在swap方法交换之后：x=66,y=5
在主方法，交换前的：x=5,y=66
在例1程序中，方法调用的“swap(x,y);”中的实在参数x，y 是两个单元，而形式参数中的x，y又是两个单元，它们是互相独立的。所以，对形式参数的改变并不影响实在参数的内容;程序的运行结果也验证上述观点。具体参数传递请见图1所示。
2.2方法间的引用传递
方法之间的数据传递还有一种方法，就是引用传递。引用传递的实质就是将实在参数的地址传递给形式参数引用，也就是形式参数是实在参数的别名。引用传递方法请见例2。
[例2]引用传递方法举例：
//ReferenceTransmit.java参考源代码如下：
importjava.io.*;
publicclassReferenceTransmit
{publicstaticvoidmain(Stringargs[])
{inta[]={9,-3,6,22,-77,999},n=6;
System.out.print(“数组排序前的情况：”);
for(inti=0;i<6;i++)
System.out.print(“”+a[i]+“”);
System.out.println(“”);
SelectSort(a,n);
System.out.print(“选择排序后的情况：”);
for(inti=0;i<6;i++)
System.out.print(“”+a[i]+“”);
}
staticvoidSelectSort(intarr[],intn)
{inttemp,p;
for(inti=0;i {p=i;
for(intj=i+1;j if(arr[p]>arr[j])p=j;
if(p!=i){temp=arr[p];arr[p]=arr[i];arr[i]=temp;} }
}
}
例2程序的执行结果如下所示：
数组排序前的情况：9-3622-77999
选择排序后的情况：-77-36922999
在例2程序的方法调用语句“SelectSort(a,n);”中，a是数组名，是地址常量，是数据区域的首地址;SelectSort(intarr[],intn)的形式参数arr[]是数组的引用，而不是数组声明或定义。在形式参数和实在参数的结合中，形式参数arr是实在参数a的别名。在方法SelectSort()中，对arr[i]的任何修改，实际上就是对实在参数a[i]的修改。程序的运行结果也证明了这一点。
3Java语言方法返值的分类
方法调用有时需要将方法的处理结果返回给方法的调用者，这样的方法将有返值。依据方法返值与否可以将方法分为无返值方法和有返值方法，本文的例1和例2中的方法都是无返值的方法。依据返值的具体数据类型又可以将方法分为返值为基本数据类型和返值为
对象的引用的方法。
3.1方法的返值为基本数据
返值为基本数据的方法在定义方法时要给出基本数据类型说明符。Java语言中，方法的返值为基本数据类型的方法，定义格式为：访问控制修饰返值数据类型方法名(形参表)
{方法体主体部分
return表达式;
}
其中：访问控制修饰符可以是public、final、static等，用于标识该方法的访问控制属性以及作用域选择等;而返值数据类型就
是Java语言的基本数据类型的标识符，用于表明该方法的返值为何种数据类型。返值为基本数据类型的方法请看例3。
[例3]返值为基本数据类型的方法：
//ReturnBasicDataType.java参考源代码如下：
importjava.io.*;
publilassReturnBasicDataType
{publicstaticvoidmain(Stringargs[])
{doublearr[]={1.2,290.5,5.7,64.0,879.5},av;
av=aver(arr,5);
System.out.println(“aver=”+av);
}
staticdoubleaver(doublea[],intn)
{doublesum=0.0;
for(inti=0;i returnsum/n;
}
}
例3的输出结果如下所示：
aver=248.18
本例中“staticdoubleaver(doublea[],intn)”是方法头。double是该方法的返值类型，即基本数据类型;参数doublea[]是引用传递,参数intn是数值传递。语句“returnsum/n;”是将sum/n的值返回给方法的调用者。
3.2方法的返值为对象的引用
另一种返值类型是对象引用。这种情况一般是：主调方法传递的是对象的地址，被调方法的形式参数是对应类型的引用，该方法的返值类型是同一类型的引用。返值为引用的方法见例4。
[例4]返值为引用的方法举例：
//ReturnReference.java参考源代码如下：
importjava.io.*;
publilassReturnReference
{publicstaticvoidmain(Stringargs[])
{examplex=newexample(),y;
x.setdata(123,“ABCD”);
System.out.println(x.getx()+“,”+x.gety());
y=tranobjct(x);
System.out.print(x.getx()+“,”+y.gety());
}
staticexampletranobjct(examplew)
{System.out.println(w.getx()+“,”+w.gety());
w.setdata(456,“efhi”);
System.out.println(w.getx()+“,”+w.gety());
examplez=newexample();
z.setdata(567,“MNIJ”);
returnz;
}
}
classexample
{intx;Stringy;
publicvoidsetdata(inta,Stringb)
{x=a;y=newString(b);}
publicintgetx(){returnx;}
publicStringgety(){returny;}
}
例4程序的运行结果如下所示：
123，ABCD
123，ABCD
456，efhi
456，MNIJ
例4的具体情况如图2所示：
图2可知：x和w引用所指的是同一个无名对象，所以，以w 引用对对象的操作实质就是对x引用所指对象的操作。而“examplez=newexample();”语句也创建一个无名对象，设置数据成员后，通过“returnz;”将此引用返给方法的调用者，使得引用y指向该对象，故有以上输出。
“tranobjct(x)”语句是将example类对象的引用(地址)x传递给tranobjct方法，而在tranobjct()方法中形式参数是example
类的对象的引用w。经过语句“w.setdata(456,”efhi“);”修改参数后，数据显示结果说明对象的数据成员修改正确。
又有“examplez=newexample();”语句创建一个新的对象z，通过“z.setdata(567,“MNIJ”);”语句将其数据成员分别设置为“567”和“MNIJ”，并由“returnz;”语句将example类型的引用返回给方法的调用者，即将example对象的引用z返值给同类的引用y。由“System.out.println(x.getx()+”,“+y.gety());”语句看出，“x.getx()”返回的是原对象经过“w.setdata(456,”efhi“);”语句修改后的数据成员x的值;而“y.gety()”返回的是
“z.setdata(567,”MNIJ“);”语句操作后数据成员y的值。
4结语
有些资料将“staticexampletranobjct(examplew)”方法称之为返值为对象的方法，笔者不能苟同。上述方法的返值类型貌似example类型的对象，其实质还是“example”类型对象的引用。何以见得?Java语言创建对象的一般格式是：类名引用名=new类名([初始化参数]);语句的“new类名([初始化参数])”部分是创建一个无名对象，再通过赋值操作将无名对象的首地址赋值给一个引用名，今后将以该引用来操作这个无名的对象。故不能将上述方法称为返值是对象的方法。
参数传递方式
引用在函数参数传递中的作用 传递参数有三种方法：1，传递对象本身。2，传递指向对象的指针。3，传递对象的引用。 (1)传值方式 ①传给被调用函数的是整型、长整型、浮点型或双精度型变量。被调用的函数得定义相应的变量为形参。 ②传给被调用函数的是结构变量。被调用函数得定义结构变量为形参。 ③传给被调用函数的是结构变量的成员。被调用函数得定义与该成员同类的变量为形参。 #include "stdio.h" ?#include
#include "stdio.h" void swapint(); int a,b; void main() { a = 5, b = 10; swapint(); printf("%d\n%d\n",a,b); } void swapint() { int temp; temp=a; a=b; b=temp; } （2）传址方式 ①传给被调用函数的是变量的地址。被调用函数得定义指针变量为形参。 ②传给被调用函数的是数组的地址即数组名。被调用的函数得定义数组或指针变量为形参。 ③传给被调用函数的是函数的地址即函数名称。被调用函数得定义指向函
数的指针变量为形参。④传给被调用函数的是结构的地址。被调用函数得定义结构指针为形参。 #include "stdio.h" ?#include
Java中传值与传引用的三种情况
java传值与传引用的三种情况大家先看一个例子: public class Example{ String str=new String("good"); char[]ch={'a','b','c'}; public static void main(String args[]){ Example ex=new Example(); ex.change(ex.str,ex.ch); System.out.print(ex.str+" and "); System.out.print(ex.ch); } public void change(String str,char ch[]){ str="test ok"; ch[0]='g'; } } 看看输出结果？ good and gbc java中没有了c＋＋中这样的引用符号，也没像c＃中那样提供了out与ref 那么它是怎么做的呢 做什么事情都要去除例外的东西，String类就是此类问题的一个特殊情况 为什么特殊呢？
因为它是一个引用类型，确执行的是值传递。这样说有些抽象，还是举个例子吧 值传递： class Str ｛ public static void main（String[] args） ｛ int i ＝ 900; System.out.println（i）; changeInt（i）; System.Out.println（i）; ｝ public static void changeInt（int s） ｛ s ＝ 34234; ｝ ｝ 结果： 900 900 这就是所谓的值传递。i把自己的副本给了函数changeInt的形参，而在changeInt中虽然将s赋值34234。但是对原来的i值并没有影响，因为它所修改的只是i的copy品而已。
C#中方法的参数有四种类型
C#中方法的参数有四种类型 1. 值参数(不加任何修饰符,是默认的类型) 2. 引用型参数(以ref 修饰符声明) 3. 输出参数(以out 修饰符声明) 4. 数组型参数(以params 修饰符声明) 1. 值传递: 值类型是方法默认的参数类型，采用的是值拷贝的方式。也就是说，如果使用的是值类型，则可以在方法中更改该值，但当控制传递回调用过程时，不会保留更改的值。 使用值类型的例子如：（下面的Swap()未能实现交换的功能，因为控制传递回调用方时不保留更改的值） using System; class Test { static void Swap(int x, int y) { int temp = x; x = y; y = temp; } static void Main() { int i = 1, j = 2; Swap(i, j); Console.WriteLine("i = {0}, j = {1}", i, j); } } /* * 输出结果为: i=1, j=2 * 未能实现Swap()计划的功能 */ 2. 引用传递(ref类型) ref关键字使参数按引用传递。其效果是，当控制权传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。 2.1. 若要使用ref 参数，则方法定义和调用方法都必须显式使用ref关键字。 2.2. 传递到ref 参数的参数必须最先初始化。这与out 不同，out 的参数在传递之前不需要显式初始化。 2.3. 如果一个方法采用ref 或out 参数，而另一个方法不采用这两类参数，则可以进行重载。
相关实例如下: using System; class Test { static void Swap(ref int x, ref int y) { int temp = x; x = y; y = temp; } static void Main() { int i = 1, j = 2; Swap(ref i, ref j); Console.WriteLine("i = {0}, j = {1}", i, j); } } /* * 引用类型实现了Swap()计划的功能: * 输出为: * i = 2, j =1 */ 3. 输出类型(out类型) out 关键字会导致参数通过引用来传递。这与ref 关键字类似。 与ref 的不同之处： 3.1. ref 要求变量必须在传递之前进行初始化，out 参数传递的变量不需要在传递之前进行初始化。 3.2. 尽管作为out 参数传递的变量不需要在传递之前进行初始化，但需要在调用方法初始化以便在方法返回之前赋值。 示例如下: using System; class Test { static void Swap(out int x, out int y) { //在这里进行了i和j的初始化
java中的值传递和引用传递
转载 原文地址：https://www.sodocs.net/doc/e615241191.html,/clara/archive/2011/09/17/2179493.html Java中的值传递和引用传递 当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递? 答:是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是该对象的引用一个副本。指向同一个对象,对象的内容可以在被调用的方法中改变，但对象的引用(不是引用的副本)是永远不会改变的。 Java参数，不管是原始类型还是引用类型，传递的都是副本(有另外一种说法是传值，但是说传副本更好理解吧，传值通常是相对传址而言)。 如果参数类型是原始类型，那么传过来的就是这个参数的一个副本，也就是这个原始参数的值，这个跟之前所谈的传值是一样的。如果在函数中改变了副本的值不会改变原始的值. 如果参数类型是引用类型，那么传过来的就是这个引用参数的副本，这个副本存放的是参数的地址。如果在函数中没有改变这个副本的地址，而是改变了地址中的值，那么在函数内的改变会影响到传入的参数。如果在函数中改变了副本的地址，如new一个，那么副本就指向了一个新的地址，此时传入的参数还是指向原来的地址，所以不会改变参数的值。 例： 1public class ParamTest { 2public static void main(String[] args){ 3/** 4 * Test 1: Methods can't modify numeric parameters 5 */ 6 System.out.println("Testing tripleValue:"); 7double percent = 10; 8 System.out.println("Before: percent=" + percent); 9 tripleValue(percent); 10 System.out.println("After: percent=" + percent); 11 12/** 13 * Test 2: Methods can change the state of object parameters 14 */ 15 System.out.println("\nTesting tripleSalary:"); 16 Employee harry = new Employee("Harry", 50000);
函数调用参数传递类型(java)的用法介绍.
函数调用参数传递类型（java）的用法介绍. java方法中传值和传引用的问题是个基本问题，但是也有很多人一时弄不清。 （一）基本数据类型：传值，方法不会改变实参的值。 public class TestFun { public static void testInt(int i){ i=5; } public static void main(String[] args) { int a=0 ; TestFun.testInt(a); System.out.println("a="+a); } } 程序执行结果：a=0 。 （二）对象类型参数：传引用，方法体内改变形参引用，不会改变实参的引用，但有可能改变实参对象的属性值。 举两个例子： （1）方法体内改变形参引用，但不会改变实参引用，实参值不变。 public class TestFun2 { public static void testStr(String str){ str="hello";//型参指向字符串“hello” } public static void main(String[] args) { String s="1" ;
TestFun2.testStr(s); System.out.println("s="+s); //实参s引用没变，值也不变 } } 执行结果打印：s=1 （2）方法体内，通过引用改变了实际参数对象的内容，注意是“内容”，引用还是不变的。 import java.util.HashMap; import java.util.Map; public class TestFun3 { public static void testMap(Map map){ map.put("key2","value2");//通过引用，改变了实参的内容 } public static void main(String[] args) { Map map = new HashMap(); map.put("key1", "value1"); new TestFun3().testMap(map); System.out.println("map size:"+map.size()); //map内容变化了 } } 执行结果，打印：map size:2 。可见在方法testMap()内改变了实参的内容。 （3）第二个例子是拿map举例的，还有经常涉及的是 StringBuffer ： public class TestFun4 {
C++中函数调用时的三种参数传递方式
在C++中，参数传递的方式是“实虚结合”。 ?按值传递(pass by value) ?地址传递(pass by pointer) ?引用传递(pass by reference) 按值传递的过程为：首先计算出实参表达式的值，接着给对应的形参变量分配一个存储空间，该空间的大小等于该形参类型的，然后把以求出的实参表达式的值一一存入到形参变量分配的存储空间中，成为形参变量的初值，供被调用函数执行时使用。这种传递是把实参表达式的值传送给对应的形参变量，故称这种传递方式为“按值传递”。 使用这种方式，调用函数本省不对实参进行操作，也就是说，即使形参的值在函数中发生了变化，实参的值也完全不会受到影响，仍为调用前的值。 [cpp]view plaincopy 1./* 2. pass By value 3.*/ 4.#include
如果在函数定义时将形参说明成指针，对这样的函数进行调用时就需要指定地址值形式的实参。这时的参数传递方式就是地址传递方式。 地址传递与按值传递的不同在于，它把实参的存储地址传送给对应的形参，从而使得形参指针和实参指针指向同一个地址。因此，被调用函数中对形参指针所指向的地址中内容的任何改变都会影响到实参。 [cpp]view plaincopy 1.#include
java参数传递(经典)
java参数传递（超经典） (2009-02-20 14:47:22)转载 分类：Java 标签：杂 谈 Java中的参数传递机制一直以来大家都争论不休，究竟是“传值”还是“传址（传引用）”，争论的双方各执一词，互不相让。不但“菜鸟”们一头雾水，一些“老鸟”也只知道结果却说不出所以然来。我相信看过下面的内容后，你就会明白一些。 先看基本类型作为参数传递的例子： public class Test1 { public static void main(String[] args) { int n = 3; System.out.println("Before change, n = " + n); changeData(n); System.out.println("After changeData(n), n = " + n); } public static void changeData(int nn) { n = 10; } } 我想这个例子大家都明白，基本类型作为参数传递时，是传递值的拷贝，无论你怎么改变这个拷贝，原值是不会改变的，输出的结果证明了这一点： Before change, n = 3 After changeData(n), n = 3 那么，我们现在来看看对象作为参数传递的例子，这也是大家争论的地方。public class Test2 { 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) {
总结Java方法(函数)传值和传引用的问题
总结Java方法(函数)传值和传引用的问题 java方法中传值和传引用的问题是个基本问题，但是也有很多人一时弄不清。 （一）基本数据类型：传值，方法不会改变实参的值。 public class TestFun { public static void testInt(int i){ i=5; } public static void main(String[] args) { int a=0 ; TestFun.testInt(a); System.out.println("a="+a); } } 程序执行结果：a=0 。 （二）对象类型参数：传引用，方法体内改变形参引用，不会改变实参的引用，但有可能改变实参对象的属性值。 举两个例子： （1）方法体内改变形参引用，但不会改变实参引用，实参值不变。 public class TestFun2 { public static void testStr(String str){ str="hello";//型参指向字符串“hello” } public static void main(String[] args) { String s="1" ;
TestFun2.testStr(s); System.out.println("s="+s); //实参s引用没变，值也不变 } } 执行结果打印：s=1 （2）方法体内，通过引用改变了实际参数对象的内容，注意是“内容”，引用还是不变的。 import java.util.HashMap; import java.util.Map; public class TestFun3 { public static void testMap(Map map){ map.put("key2","value2");//通过引用，改变了实参的内容 } public static void main(String[] args) { Map map = new HashMap(); map.put("key1", "value1"); new TestFun3().testMap(map); System.out.println("map size:"+map.size()); //map内容变化了 } } 执行结果，打印：map size:2 。可见在方法testMap()内改变了实参的内容。 （3）第二个例子是拿map举例的，还有经常涉及的是 StringBuffer ： public class TestFun4 {
深入了解C语言(函数的参数传递和函数使用参数的方法)
深入了解C语言(函数的参数传递和函数使用参数的方法) C语言生成的代码在执行效率上比其它高级语言都高.现在让我们来看看C语言生成的代码具体是什么样子的.当你看完本文对于C语言的了解一定会更深一步了. 本文通过一个个实际案例程序来讲解C语言. 研究案例一 工具: Turboc C v2.0,Debug,MASM v5.0,NASM 实例C程序: /* example1.c */ char ch; int e_main() { e_putchar(ch); } 目标内容:C语言调用函数的方法与细节 我们使用的C编译器是16位的Turboc C v2.0,它生成的是16位的代码,比较简单,方便我们来研究.同时我们也需要用到DOS下的DEBUG来进行反汇编.由于我们很多案例中的程序并不是完整的C程序,所以Turboc下的Tlink并不能为我们生成目标程序,所以我将使用MASM 中的link.exe,同时里面的https://www.sodocs.net/doc/e615241191.html,也可以为我们把exe文件转换成bin文件. 这个程序没有main函数,我们用e_main来代替main函数.这样我们能避开C语言对main函数进行一系列处理的代码.同样,我们也用e_putchar()来代替我们平常使用的putchar().这里"e"的意思就是"example". 没有了main函数,我们的C程序就没有了入口,所以在开始编译这段C代码之前,我还得写几行简单的汇编代码,通过它来作为我们程序的入口. ; C程序的入口start.asm [BITS 16] [global start] [extern _e_main] start: call _e_main 按照C语言的习惯,所以C总的名词都要自动在前面加一个"_"下划线.所以,我们在C中的e_main函数,如果要在汇编中调用,就变成了_e_main函数.这段汇编代码只有一句:call _e_main,就是调用我们在C中的e_main函数
java参数是如何传递的
java参数是如何传递的 总的来说，计算机语言给子程序传递参数的方法有两种。第一种方法是按值传递（call-by-value ）。这种方法将一个参数值（value ）复制成为子程序的正式参数。这样，对子程序的参数的改变不影响调用它的参数。第二种传递参数的方法是引用调用（call-by-reference ）。在这种方法中，参数的引用（而不是参数值）被传递给子程序参数。在子程序中，该引用用来访问调用中指定的实际参数。这样，对子程序参数的改变将会影响调用子程序的参数。你将看到，根据传递的对象不同，Java 将使用这两种不同的方法。 在Java 中，当你给方法传递一个简单类型时，它是按值传递的。因此，接收参数的子程序参数的改变不会影响到该方法之外。例如，看下面的程序： // Simple types are passed by value. class Test { void meth(int i，int j) { i *= 2;j /= 2; } } class CallByValue { public static void main(String args[]) { Test ob = new Test(); int a = 15，b = 20; System.out.println("a and b before call: " +a + " " + b); ob.meth(a，b); System.out.println("a and b after call: " +a + " " + b); } } 该程序的输出如下所示： a and b before call: 15 20 a and b after call: 15 20 可以看出，在meth( ) 内部发生的操作不影响调用中a和b的值。它们的值没在本例中没有变为30和10。 当你给方法传递一个对象时，这种情形就会发生戏剧性的变化，因为对象是通过引用传递的。记住，当你创建一个类类型的变量时，你仅仅创建了一个类的引用。因此，当你将这个引用传递给一个方法时，接收它的参数将会指向该参数指向的同一个对象。这有力地证明了对象是通过引用调用传递给方法的。该方法中对象的改变确实影响了作为参数的对象。例如，考虑下面的程序： // Objects are passed by reference. class Test { int a，b; Test(int i，int j) {a = i;b = j; } // pass an object void meth(Test o) {
SpringMVC向页面传递参数的4种方式
SpringMVC向页面传递参数的4种方式 1、使用HttpServletRequest和Session 然后setAttribute()，就和Servlet 中一样 request.setAttribute(“user”,user_data); 2、使用ModelAndView对象 @RequestMapping("/login.do") publicModelAndView login(String name,String pass) { User user = userService.login(name,pwd); Map
java参数传递时到底是值传递还是引用传递
java参数传递时到底是值传递还是引用传递(baidu搜集) 最近比较长一段时间以来，网上的IT同行里面比较流行“JAVA面试32问”，很多人的BLOG里都引用这些面试题，最近因为工作内容比较枯燥，也来看看这些试题以调节一下口味，其中有一道题让我很费解。 原题是：当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递? 用google查询结果，得到答案基本上是：值传递。当时觉得挺纳闷儿，为什么连参数的内容都被修改了，怎么还能说是“值传递”呢？因为在传统的印象里（尤其是从C++过来以后），值传递都应该是不改变原参数的。 问问周围的同事，也大都这么讲，但是也都讲不清这种理论的根源是什么。我这个人有个毛病，有事情想不通时就会憋得难受，后来在《Thinking in Java》的一段内容（注解[1]）里找到了自己的结论，我认为（《Thinking in Java》的作者也这么认为）：可以说是值传递，也可以说是引用传递。 一，认为是值传递。得出这种结论的前提必须是“参数的值就是对该对象的引用，而不是对象的内容”，这句话可能有些费解，举个例子加以说明。 public class Paier { public static void main(String[] args) { Paier paier = new Paier(); paier.test();
} public void test() { TestClass para1 = new TestClass(); para1.setTest(new Integer(10)); TestClass result1 = test1(para1); System.out.println("para1 = " + para1.getTest()); System.out.println("result1 = " + result1.getTest()); TestClass para2 = new TestClass(); para2.setTest(new Integer(10)); TestClass result2 = test2(para2); System.out.println("para2 = " + para2.getTest()); System.out.println("result2 = " + result2.getTest()); } public TestClass test1(TestClass t) {
Java值传递和引用
java语言深入（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 int 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); }
java对象、数组作为参数传递,静态变量、静态方法的使用,内部类,使用文档注释
java学习笔记(四)----对象、数组作为参数传递，静态变量、静态方法的使用，内部类，使用文档注释 2009-10-15 20:21 ＊＊＊对象作为参数传递＊＊＊ class passparam { int x; public static void main(String[] args) { passparam obj = new passparam(); obj.x=5; change(obj); System.out.println(obj.x); //如果change方法不是静态的，想调用它就得写成new passparam().change(obj); } public static void change(passparam obj) //如果这个函数前面没加static编译出错，因为非静态方法，不能被静态方法直接调用，main 是一个静态方法。 { obj.x=3;} } 结果：3 ＊＊＊数组作为参数传递＊＊＊ class passparam { int x; public static void main(String[] args) { passparam obj = new passparam(); int []x=new int[1]; x[0]=5; change(x); System.out.println(x[0]); } public static void change(int[] x) { x[0]=3; } } 结果：3 ＊＊＊静态变量、静态方法的使用＊＊＊ 静态变量相当于全局变量 class Chinese { static string country="中国"; //如果改为private static string country="中国" 下面的两处调用，就会出错 String name; int age; static void sing() { System.out.println("啊~~") void singOurCountry() { System.out.println(country); sing(); } }
关于JAVA中参数地址传递的问题
public class Test5 { public static void main(String[] args) { int [] a = { 1, 2, 3, 4, 5 }; int [] b = new int [a.length ]; System.out .println("交换前："); print (a); print (b); b = swap (a); System.out .println("交换后："); print (a); print (b); } private static void print(int [] a) { for (int i = 0; i < a.length ; i++) { System.out .print(" " + a[i]); } System.out .println(); } private static int [] swap(int [] c) { int [] tmp = new int [c.length ]; for (int j = 0; j < c.length ; j++) { tmp[j] = c[c.length - j - 1] + 10; } return tmp; } } 结果： 交换前： 1 2 3 4 5 0 0 0 0 0 交换后： 1 2 3 4 5 15 14 13 12 11 说明： 在该程序中，在调用swap()方法时，，数组a 将其地址传递给数组c ，所以a 和c 是指向同一个数组。 但在swap 方法中,新生成了一个数组tmp,改变是在tmp 数组上进行的.返回时把tmp 数组的首地址送数组b.所以b 指向改变后数组tmp. public class Test5 { public static void main(String[] args) { int [] a = { 1, 2, 3, 4, 5 }; int [] b = new int [a.length ]; System.out .println("交换前："); print (a); print (b); b = swap (a); System.out .println("交换后："); print (a); print (b); } private static void print(int [] a) { for (int i = 0; i < a.length ; i++) { System.out .print(" " + a[i]); } System.out .println(); } private static int[] swap(int [] c) { for (int j = 0; j < a.length ; j++) { c[j] = c[c.length - j - 1] + 10; } return c ; } } 结果： 交换前： 1 2 3 4 5 0 0 0 0 0 交换后： 15 14 13 24 25 15 14 13 24 25 说明： 在该程序中，在调用swap()方法时，数组a 将其地址传递给数组c ，所以a 和c 是指向同一个数组。 返回时,数组b 不再指向原来的数组,而指向c 所在的数组。 注: JAVA 中参数传递时是值传递,引用型与基本数据类型是不同的. 1 2 3 4 5 15 14 13 12 11 a[ ] c[ ] 0 0 0 0 0 b[ ] a[ ] c[ ] b[ ] 1 2 3 4 5 1 2 3 4 5 a[ ] c[ ] 0 0 0 0 0 b[ ] a[ ] c[ ] b[ ] 15 14 13 12 11
java中的值传递和引用传递
值传递：方法调用时，实际参数把它的值传递给对应的形式参数，方法执行中形式参数值的改变不影响实际参数的值。（参数类型为基本数据类型） 引用传递：也称为传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，方法执行中形式参数值的改变将会影响实际参数的值。（类和数组） 下面举例说明： 传值---传递基本数据类型参数 public class PassValue{ static void exchange(int a, int b){//静态方法，交换a,b的值 int temp; temp = a; a = b; b = temp; } public static void main(String[] args){ int i = 10; int j = 100; System.out.println("before call: " + "i=" + i + "\t" + "j = " + j);//调用前 exchange(i, j); //值传递，main方法只能调用静态方法 System.out.println("after call: " + "i=" + i + "\t" + "j = " + j);//调用后 } } 运行结果： before call: i = 10 j = 100 after call: i = 10 j = 100 说明：调用exchange(i, j)时，实际参数i，j分别把值传递给相应的形式参数a，b,在执行方法exchange()时，形式参数a，b的值的改变不影响实际参数i和j的值，i和j的值在调用前后并没改变。 引用传递---对象作为参数 如果在方法中把对象（或数组）作为参数，方法调用时，参数传递的是对象的引用（地址），即在方法调用时，实际参数把对对象的引用（地址）传递给形式参数。这是实际参数与形式参数指向同一个地址，即同一个对象（数组），方法执行时，对形式参数的改变实际上就是对实际参数的改变，这个结果在调用结束后被保留了下来。 class Book{ String name; private folat price; Book(String n, float ){ //构造方法 name = n; price = p; } static void change(Book a_book, String n, float p){ //静态方法，对象作为参数 a_https://www.sodocs.net/doc/e615241191.html, = n;
PHP页面间参数传递的四种方式
PHP 页面间参数传递的四种方式
分类： 网络文摘 2011-12-15 18:34 20269 人阅读 评论(12) 收藏 举报 phpsession 浏览器 inputaction 服务器
我们定义 page01.php 和 page02.php 两个 php 文件，将 page01 中的 内容想办法传递到 page02，然后供我们继续使用。
第一种： 使用客户端浏览器的 cookie。cookie 很容易理解，就是一个临时文件， 可以把它看成一个储藏室，浏览器在浏览的过程中记录一些信息，就暂 时存放在这里。 在 page01 中设置一个 cookie。 就是这么简单，我们已经创建 cookie 完毕。 我们定义了一个变量 mycookie，它的值是字符串'自灵'。 我们可以随便给 cookie 变量起名字，可以定义多个 cookie 变量。
在 page02 页面接受 cookie。
我们使用$_COOKIE[]提取 cookie 中的变量 mycookie，将它的值付给 $wuziling。然后简单的输出。 好了，到这里使用 cookie 从页面之间传递参数完毕。
第二种： 使用服务器端的 session。 理解 session 是一件很容易的事情。 与 cookie 的不同在于它是服务器端的临时储藏室。session 常被称作会话。 在 page01 中设置一个 session。 要想使用 session， 必须启动 session。 session_start();就是启动 session 的方法。一般要写在最前面。 第二个语句我定义了一个$_SESSION["temp"]数组，数组的名称是 $_SESSION["temp"]，里面存储了 3 个字符串。 在 page02 页面接受 session。 '; } ?> 首先启动会话。启动后我们在 page01 定义的变量已经可以使用了，不 需要其他任何获取的操作，这里不同于 cookie。
相关文档
- Java方法的参数传递
- java中方法中参数的传递
- C#中方法的参数有四种类型
- 编程高手之路—C语言(十一)函数参数的传递和值返回
- 参数值传递的三种方式
- 5-2html页面间参数传递的四种方式(精)
- C++中函数调用时的三种参数传递方式
- SpringMVC向页面传递参数的4种方式
- PHP页面间参数传递的四种方式
- 深入理解Java中方法的参数传递机制
- 函数参数的传递方式
- C中方法的参数可以有哪几种传递方式
- JAVA中方法的调用时参数的传递方式以及数组
- 【黑马程序员】Java中方法的参数传递问题
- PB窗口之间传递多参数的方法
- 深入了解C语言(函数的参数传递和函数使用参数的方法)
- JAVA中方法的调用时参数的传递方式以及数组
- 参数传递的三种方式
- 参数传递方式
- 函数调用参数传递类型(java)的用法介绍.