关于Android中Java与Javascript之间的传值研究

Android中提供的WebView的功能不可谓不强大，并且WebView对于Javascript也能够很好的支持，Google官网也提供了在WebView中如何实现的Java和JavaScript的互相访问。来看一下源代码：

1 WebViewDemo.java文件：

public class WebViewDemo extends Activity {

private WebView mWebView;

private Handler mHandler = new Handler();

public void onCreate(Bundle icicle) {

super.onCreate(icicle);

setContentView(https://www.sodocs.net/doc/0111849399.html,yout.webviewdemo);

mWebView = (WebView) findViewById(R.id.webview);

WebSettings webSettings = mWebView.getSettings();

webSettings.setJavaScriptEnabled(true);

mWebView.addJavascriptInterface(new Object() {

public void clickOnAndroid() {

mHandler.post(new Runnable() {

public void run() {

mWebView.loadUrl("javascript:wave()");

}

});

}

}, "demo");

mWebView.loadUrl("file:///android_asset/demo.html");

}

}

来分析一下这段代码：

WebSettings webSettings = mWebView.getSettings();

webSettings.setJavaScriptEnabled(true);

首先生成一个WebSettings对象，其次setJavaScriptEnabled(true);通过这句声

明使WebView能够支持JavaScript脚本。

紧接着mWebView.addJavascriptInterface这句，这个方法的原型如下：

addJavascriptInterface(Object obj,String interfaceName)，该方法将一个java对象绑定到一个javascript对象中，而这个javascript对象的名字就是第二个参数interfaceName。这样在WebView进行初始化以后，就可以通过window. interfaceName来访问Java对象了。这里的interfaceName就是Demo。

第一个参数则是个初始化了一个Java的类，注意这里的clickOnAndroid()方法，这里文档里是这样描述的The Java object that is bound runs in another thread and not in the thread that it was constructed in.

也就是说addJavascriptInterface这里要绑定的类新申请了个进程来处理，这个是需要注意的地方，因此这也是使用了Handler的目的。

mWebView.loadUrl("file:///android_asset/demo.html");这句话是加载了本地的demo.html页面，这个页面是存放在工程的assets下的，为了让WebView从apk文件中加载assets，Android SDK提供了一个schema，前缀为"file:///android_asset/"。WebView遇到这样的schema，就去当前包中的assets目录中找内容。如上面的“file:///android_asset/demo.html”

mWebView.loadUrl("javascript:wave()");这句话就是Java调用Javascript的函数了。这个wave()是在页面中的Javascript脚本中定义的。

下面再来看看在demo.html中是怎样调用的Java函数的，下面是demo.html的代码

Click me!

其中wave() 是被Java程序调用的。通过点击来调用window.demo.clickOnAndroid()函数，这样就调用了Java的clickOnAndroid()方法。

这样，通过上面的例子可以看出，实现Java和Javascript之间的交互是比较容易的，下面再来看看如何实现Java和Javascript的传值。

基本上传值的主要思路就是通过函数的参数来进行的，把上面例子进行了修改，将函数加了参数，看修改后如下：

public void clickOnAndroid(final String str)在这个函数添加了一个String 的参数，在HTML里的调用改为如下即可：

window.demo.clickOnAndroid(str)

其中参数str可以在调用以前设置好var str = 1234567890，任意一个值或者是你自己需要得到的页面中的某一个值。这样就实现了JavaScript向Java传值。

那么Java向JavaScript传值也是采用的函数参数的方式，看一下HTML中的改动：function wave(str)

在Java中也需要做些改动，

mWebView.loadUrl("javascript:wave(‘"+str+"’)");

中间的str是String类型，将需要传给JavaScript的值放入其中。这样就实现了Java向JavaScript的传值过程。

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品而已。

java中的值传递和引用传递

转载 原文地址：https://www.sodocs.net/doc/0111849399.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 {

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 {

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) {

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的数据传输设计的实验报告 高灵琪 1110230015

基于java的数据传输设计的实验报告 基于Java和OPC技术的分布式远程监控系统，系统的结构模型如图1所示。系统的功能是：实现对生产过程的数据采集和存贮，并在远程客户端实现对采集过程的监测和控制。 １.介绍 系统采用多层Client/Server结构。总体上可以分为3个层次：数据服务器层、应用服务器层和客户端。数据服务器负责提供所需的数据，包括系统的实时数据、历史数据和报警信息等；应用服务器接收客户端发出的请求信息，根据客户端的请求与数据服务器进行交互，实现客户端的请求。客户端负责数据曲线的显示，并负责处理用户的监控请求。 2.１系统中的数据传送问题 本系统采用分布式技术，应用服务器和远程客户端分别位于网络中不同的主机上，采集的数据用RMI技术通过网络从服务器端传送到客户端。 系统中，客户端需要完成两项任务，一是对采集过程的监测和控制，并用波形图把采集的数据实时地显示在客户端界面上，这就要求数据采集服务器采集的数据实时的传送到客户端，保证监控的实时性。客户端的另一项任务是，把从服务器端传送过来的数据保存在客户端计算机上，以便用户能浏览和分析采集到的数据。为保证对数据分析的正确和完整，数据采集服务器采集的数据应全部传送到客户端，这就要求数据传送的准确性，即数据应无丢失的在网络上进行传送。总之，数据从服务器端传送到远程客户端时，应满足数据传送的实时性和准确性。 然而，当数据在网络上进行传送时，由于网络的连接情况和拥塞情况具有一定的随机性，很多时候会出现网络抖动的情况，造成客户端与服务器端失去连接，使数据传送中断。为保证数据传送的实时性和准确性，需采取措施，当网络连接出现短时断开的时候，客户端和服务器端应能自动重新建立连接，使实时监控和数据保存继续进行。对于由于网络短时中断时没能传送的数据，应采用缓存的方法，待连接重新建立后，再把这些数据进行传送。 ３.１数据传送方案及数据缓存的实现 如前所述，客户端需要完成两项任务：一是对数据采集进行实时监控，二是把从服务器端传送过来的数据保存在客户端计算机上。在这两项任务中，实时监控任务要求保证数据的实时性，即服务器端采集的数据应实时地传送到客户端，让用户及时了解数据采集的情况。而数据保存任务需要的是数据传送的准确和完整，即采集的数据应无丢失的从服务器端传送到客户端。考对传送的要求，为保证他们都能满足各自的功能，本系统在设计数据传送时，把实时监控部分和数据保存部分分开，即分别通过不同的途径从服务器端获得数据。 对数据保存部分，采用在服务器端先用数组缓存数据，缓存数组中的数据达到一定数量后，由服务器主动一次性把这些数据传送到客户端。具体的方法是：在服务器端，对每一通道的数据先用两个数组交替进行缓存，数据采集服务器传送过来的数据先放进数组1，当数据满一定数量后（例如200个），由数组 2接着接收数据，与此同时，新开一个线程，把数组中的数据通过远程方法调用主动传送给客户端。在传送数组时如果网络是中断的，则可利用后面介绍的重连接机制，让客户和服务器重新建立连接，只要在数组2接收200个数据的过程中，连接能够重新建立，把数组1传送成功，就可以保证数据无丢失的传送。这就是本远程监控系统在网络短时中断时，利用数组对数据进行缓存的原理所在。数组2接收满200个数据后，新开一个线程传送数组2，同时由数组1

关于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/0111849399.html, = n;

java 值传递 引用传递

Java代码 public class ParamTest { // 初始值为0 protected int num = 0; // 为方法参数重新赋值 public void change(int i) { i = 5; //不能改变 } // 为方法参数重新赋值 public void change(ParamTest t) { ParamTest tmp = new ParamTest(); tmp.num = 9; t = tmp; //不能改变 } // 改变方法参数的值 public void add(int i) { i += 10; //不能改变 } // 改变方法参数属性的值 public void add(ParamTest pt) { pt.num += 20; //改变 } public static void main(String[] args) { ParamTest t = new ParamTest();

System.out.println("参数--基本类型"); System.out.println("原有的值：" + t.num); // 为基本类型参数重新赋值 t.change(t.num); System.out.println("赋值之后：" + t.num); // 为引用型参数重新赋值 t.change(t); System.out.println("运算之后：" + t.num); System.out.println(); t = new ParamTest(); System.out.println("参数--引用类型"); System.out.println("原有的值：" + t.num); // 改变基本类型参数的值 t.add(t.num); System.out.println("赋引用后：" + t.num); // 改变引用类型参数所指向对象的属性值 t.add(t); System.out.println("改属性后：" + t.num); } } 这段代码的运行结果如下： 参数--基本类型 原有的值：0 赋值之后：0 运算之后：0

java引用传递还是值传递详细解说

这个在Java里面是经常被提起的问题，也有一些争论，似乎最后还有一个所谓的结论：“在Java里面参数传递都是按值传递”。事实上，这很容易让人迷惑，下面先分别看看什么是按值传递，什么是按引用传递，只要能正确理解，至于称作按什么传递就不是个大问题了。 1：按值传递是什么 指的是在方法调用时，传递的参数是按值的拷贝传递。示例如下： public class TempTest { private void test1(int a){ //做点事情 } public static void main(String[] args) { TempTest t = new TempTest(); int a = 3; t.test1(a);//这里传递的参数a就是按值传递 } } 按值传递重要特点：传递的是值的拷贝，也就是说传递后就互不相关了。 示例如下： public class TempTest { private void test1(int a){ a = 5; System.out.println("test1方法中的a==="+a); } public static void main(String[] args) { TempTest t = new TempTest(); int a = 3; t.test1(a);//传递后，test1方法对变量值的改变不影响这里的a System.out.println(”main方法中的a===”+a); } } 运行结果是： test1方法中的a===5 main方法中的a===3 2：按引用传递是什么

指的是在方法调用时，传递的参数是按引用进行传递，其实传递的引用的地址，也就是变量所对应的内存空间的地址。 示例如下： public class TempTest { private void test1(A a){ } public static void main(String[] args) { TempTest t = new TempTest(); A a = new A(); t.test1(a); //这里传递的参数a就是按引用传递 } } class A{ public int age = 0; } 3：按引用传递的重要特点 传递的是值的引用，也就是说传递前和传递后都指向同一个引用（也就是同一个内存空间）。示例如下： 第1行public class TempTest { 第2行private void test1(A a){ 第3行 a.age = 20; 第4行System.out.println("test1方法中的age="+a.age); 第5行} 第6行public static void main(String[] args) { 第7行TempTest t = new TempTest(); 第8行 A a = new A(); 第9行 a.age = 10; 第10行t.test1(a); 第11行System.out.println(”main方法中的age=”+a.age); 第12行} 第13行} 第14行class A{ 第15行public int age = 0; 第16行} 运行结果如下： test1方法中的age=20

【黑马程序员】Java中方法的参数传递问题

【黑马程序员】Java中方法的参数传递问题最近有很多同学，就算是就业班毕业之后，还依然在问java方法的调用中值的传递问题，实际参数究竟什么时候才会改变？接下来我们先由一个例子来引出大家的问题，请看如下例子，并回答下面代码中的四个问题 public class Demo { public static void main(String[] args) { int a = 10; change(a); System.out.println(a); // 1：请问输出什么？ String str = "abc"; change(str); System.out.println(str);// 2：请问输出什么？ Student s = new Student("张三",13); System.out.println(s); // 输出 Student [name=张三, age=13] change(s); System.out.println(s); // 3：请问输出什么？ change1(s); System.out.println(s); // 4：请问输出什么？ } public static void change(String s) { s = s+"def"; } public static void change(int a) { a = a + 10; } public static void change(Student s) { s = new Student("李四",14); } public static void change1(Student s) { s.setName("李四"); s.setAge(14); } } 大家看完上面的题目之后，估计有很多同学能回答出前两问，1：输出10, 2:输出abc，因为这类的参数传递在咱们java基础课程的第5天和第13天都有讲到。但是虽然讲了，但

java值传递原理

Java值传递规则 首先明确一个概念：什么是引用？引用就是堆区内，对象的地址。 结合上次介绍的内存分配图： ss 即：s和ss都是引用。 本次介绍的值传递范围是：给方法传参数（实参->形参）。 结论：java中向方法传递的参数是栈区内的值（主要分为基本数据类型的值和对象的引用）。“传递”的过程实际上是一次拷贝的过程。 根据copy的特性：修改拷贝后的副本对原参数无任何影响，不论是值还是引用。 关于副本：副本的作用域就是整个方法，方法结束后，副本失效。 下面是示例程序： public class PassParamter { public PassParamter() { } public void methodA(ComplexNumber comNum) { // comNum是实参的一个副本，下面改变这个副本， // 这个副本指向了一个新new出来的对象。 comNum = new ComplexNumber(1, 2); } public void methodB(ComplexNumber comNum) { // comNum引用是实参的一个副本，与实参指向同一个对象，下面是通过副本修改对象的值，与通过实参修改对象效果上是一致的。 comNum.setRealPart(2); } public void methodC(int num) { // num是实参的一个副本，下面将这个副本的值加1

num++; } public static void main(String[] args) { PassParamter test = new PassParamter(); ComplexNumber comNum = new ComplexNumber(5, 5); System.out.println("调用methodA方法之前，comNum: " + comNum.toString()); test.methodA(comNum); System.out.println("调用methodA方法之后，comNum: " + comNum.toString()); System.out.println("调用methodB方法之前，comNum: " + comNum.toString()); test.methodB(comNum); System.out.println("调用methodB方法之后，comNum: " + comNum.toString()); int num = 0; System.out.println("调用methodC方法之前，num: " + num); test.methodC(num); System.out.println("调用methodC方法之后，num: " + num); // 运行结果： // 调用methodA方法之前，comNum: 5.0 + 5.0i // 调用methodA方法之后，comNum: 5.0 + 5.0i // 调用methodB方法之前，comNum: 5.0 + 5.0i // 调用methodB方法之后，comNum: 2.0 + 5.0i // 调用methodC方法之前，num: 0 // 调用methodC方法之后，num: 0 下面是对运行结果的解释： /** *Java的参数传递策略： *0，所谓传值的意思是：在调用方法时，将参数的值复制一份，方法里面用复件，方法外面用原件，复件改变了，不影响原件；原件改变了，不影响复件。 *1，对于基本数据类型，比如int，long等类型，采用传值的策略。将参数的值复制一份后传给方法，方法可以改变参数值的复件，但不会改变参数值的原件。 *2，对于对象类型，也采用的传值策略，不过，是将参数的引用复制（2个引用指向同一个对象）一份传给方法，方法可以改变参数引用的复件，但不会改变参数引用的原件。 * *解释三个输出： *1，调用methodA方法时，首先将comNum对象的引用复制一份，将引用的复件

值传递和引用传递

值传递：(形式参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。 引用传递：(形式参数类型是引用数据类型参数)：也称为传地址。方法调用时，实际参数是对象(或数组)，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。

前天在做系统的时候被Java中参数传递问题卡了一下，回头查阅了相关的资料，对参数传递问题有了新的了解和掌握，但是有个问题感觉还是很模糊，就是Java中到底是否只存在值传递，因为在查阅资料时，经常看到有人说Java只有值传递，但有人说既有值传递，也有引用传递，对于两个观点个人觉得应该是站的角度不同而得出两个不同的说法，其实两个说法其中的原理是一样的，只要咱们懂得其中的原理，那么至于叫什么也就无所谓了，下面是我在网上看到的一个帖子，解释的感觉挺全面，就转过来，以供以后学习参考： 1：按值传递是什么 指的是在方法调用时，传递的参数是按值的拷贝传递。示例如下： [java]view plain copy 按值传递重要特点：传递的是值的拷贝，也就是说传递后就互不相关了。 示例如下： [java]view plain copy 运行结果是： [java]view plain copy

2：按引用传递是什么 指的是在方法调用时，传递的参数是按引用进行传递，其实传递的引用的地址，也就是变量所对应的内存空间的地址。示例如下： [java]view plain copy 3：按引用传递的重要特点 传递的是值的引用，也就是说传递前和传递后都指向同一个引用（也就是同一个内存空间）。 示例如下： [java]view plain copy

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;