您的位置:

java中参数的传递方式,java函数作为参数传递

本文目录一览:

java中参数传递方式

在 Java 应用程序中永远不会传递对象,而只传递对象引用。因此是按引用传递对象。Java应用程序按引用传递对象这一事实并不意味着 Java 应用程序按引用传递参数。参数可以是对象引用,而 Java 应用程序是按值传递对象引用的。

对象是按引用传递的;

Java 应用程序有且仅有的一种参数传递机制,即按值传递;

按值传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的一个副本;

按引用传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的内存地址,而不是值的副本。

Java 应用程序中的变量可以为以下两种类型之一:引用类型或基本类型。当作为参数传递给一个方法时,处理这两种类型的方式是相同的。两种类型都是按值传递的;没有一种按引用传递。

注:参数是按值而不是按引用传递的,说明 Java 应用程序有且仅有的一种参数传递机制,即按值传递。

Java中函数参数的传递是怎样进行的?

Java中函数参数的传递是按值传递。

下面证明Java中参数传递是完完全全是传值而不是传址。

一:

package com.sitinspring;

public class ChangeClass{

public void changeInt(int i){

i=5;

}

public void changeLong(long i){

i=555;

}

public void changeString(String str){

str="5555";

}

public void changeMember(Member member){

member=new Member("Cindy",35);

}

public void changeMemberField(Member member){

member.setAge(20);

member.setName("Andy");

}

public static void main(String[] args){

ChangeClass changeClass=new ChangeClass();

int intValue=10;

changeClass.changeInt(intValue);

System.out.println(intValue);

long longValue=10;

changeClass.changeLong(longValue);

System.out.println(longValue);

String stringValue="1234";

changeClass.changeString(stringValue);

System.out.println(stringValue);

Member member2=new Member("Douglas",45);

changeClass.changeMember(member2);

System.out.println(member2);

Member member=new Member("Bill",25);

changeClass.changeMemberField(member);

System.out.println(member);

}

}

二:

package com.sitinspring;

public class Member{

private String name;

private int age;

public Member(String name,int age){

this.age=age;

this.name=name;

}

public String toString(){

return "Member name="+name+" age="+age;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

}

输出:

10

10

1234

Member name=Douglas age=45

Member name=Andy age=20

解释:

第一个输出10是因为int是基本类型,传递的参数是intValue的拷贝,对拷贝的修改对原值intValue没有影响.

第一个输出10和上面是一个道理.

第三个输出1234.由于String是类类型, str是stringValue的地址拷贝,参数str指向的地址和stringValue的一致,但在函数changeString 中,由于String的特殊性, str=“5555”和str=new String(“5555”)是等价的, str指向了新的”5555”所在的地址,此句后str就与原来的stringValue彻底脱离了联系.

第四个输出Member?name=Douglas?age=45的道理和上面相同.

第五个输出Member?name=Andy?age=20是因为changeMemberField函数中修改了参数member 的值,也就是修改member指向实例的值,而这个实例正是member指向的值,因此member就变成了name=Andy 且age=20.

结论:

Java中参数传递的都是值,对应基本类型,传递的是原值的拷贝;对于类类型,传递的是引用即地址的拷贝.

对于函数对参数的改变是否会影响原值的问题:值类型自然不会影响到原值.而对于类类型要看改变的是参数的地址还是值,如果是前者,参数和原引用指向了不同的地址,它们自然脱离了关系;如果是后者,修改的实例就是原引用指向的实例,这当然对原值进行了修改.

java中的参数(对象)是怎样传递的

基本类型传值,比如int,float,char,double

引用类型传引用,也就是地址,比如数组,自己创建的类的对象,

传值对原来的值没有影响,传引用有影响。传值直接把原来的数拷贝一份,和原来的数没有关系了。传引用,比如对象是a,a指向一个地址,这个地址里放它的各种属性,你把a传过去就相当于告诉程序要修改那个地址里的东西,不改变a的值(a本身是个地址),a还是指向那个地址,不过地址里的数据会发生改变,会影响到a.属性的值。

最后,有一个特殊的,String,它虽然是引用类型,传的是地址,但是对它进行操作不影响原来的字符串,因为它定义的时候是用final修饰的,一修改就自动创建新的副本。

谁知道Java中参数是引用传递还是值传递?

java中方法参数传递方式是按值传递。所谓值传递,就是将实际参数值的副本(复制品)传入方法内,而自己本身不会受到任何影响。

如果参数是基本类型,传递的是基本类型的字面量值的拷贝。 

如果参数是引用类型,传递的是该参量所引用的对象在堆中地址值的拷贝。

Java参数传递是值传递还是引用传递

以下是csdn中查到的一些资料,希望有所帮助

java 传递参数的两种方式:

Java中没有指针,所以也没有引用传递了,仅仅有值传递不过可以通过对象的方式来实现引用传递 类似java没有多继承 但可以用多次implements 接口实现多继承的功能

值传递:方法调用时,实际参数把它的值传递给对应的形式参数,方法执行中形式参数值的改变不影响实际参 数的值。

引用传递:也称为传地址。方法调用时,实际参数的引用(地址,而不是参数的值)被传递给方法中相对应的形式参数,在方法执行中,对形式参数的操作实际上就是对实际参数的操作,方法执行中形式参数值的改变将会影响实际参数的值。

a.传递值的数据类型:八种基本数据类型和String(这样理解可以,但是事实上String也是传递的地址,只是string对象和其他对象是不同的,string对象是不能被改变的,内容改变就会产生新对象。那么StringBuffer就可以了,但只是改变其内容。不能改变外部变量所指向的内存地址)。

b.传递地址值的数据类型:除String以外的所有复合数据类型,包括数组、类和接口

值传递的例子:

[java] view plain copy

package com.other.test;

public class Test {

public static void change(int i, int j) {

int temp = i;

i = j;

j = temp;

}

public static void main(String[] args) {

int a = 3;

int b = 4;

change(a, b);

System.out.println("a=" + a);

System.out.println("b=" + b);

}

}

输出的结果是 a=3 b=4,传递的值并不会改变原值

引用传递的例子:(数组)

[java] view plain copy

package com.other.test;

public class Test {

public static void change(int[] counts) {

counts[0] = 6;

System.out.println(counts[0]);

}

public static void main(String[] args) {

int[] count = { 1, 2, 3, 4, 5 };

change(count);

System.out.println(count[0]);

}

}

输出结果是6 6 也就是引用的值改变了原来的值

引用传递的例子:(对象)

定义一个A对象:

[java] view plain copy

package com.other.test;

public class A {

int i = 0;

}

对上边对象操作的类:

[java] view plain copy

package com.other.test;

public class Test {

public static void add(A a) {

//a = new A();   ①

a.i++;

}

public static void main(String args[]) {

A a = new A();

add(a);

System.out.println(a.i );

}

}

当把①注解掉时,输出的结果是1,当①没有注解是是0,原因是 a =new A();构造了新的A对象就不是传递的那个对象了。

看看String的情况:

[java] view plain copy

package com.other.test;

public class Test {

String str = new String("old");

char[] ch = { 'a', 'b', 'c' };

public static void main(String args[]) {

Test ex = new Test();

ex.change(ex.str, ex.ch);

System.out.print(ex.str + " and ");

System.out.println(ex.ch);

}

public void change(String str, char ch[]) {

str = "new";

ch[0] = 'd';

}

}

输出的结果的是 old and dbc也就是传递String并不会改变原值,而是创建了一个新值。 ch[]就是一个简单的数组的传递。

( 对象包括对象引用即地址和对象的内容)

String 比较特别,看过String 代码的都知道, String 是 final的。所以值是不变的。 函数中String对象引用的副本指向了另外一个新String对象,而数组对象引用的副本没有改变,而是改变对象中数据的内容.

对于对象类型,也就是Object的子类,如果你在方法中修改了它的成员的值,那个修改是生效的,方法调用结束后,它的成员是新的值,但是如果你把它指向一个其它的对象,方法调用结束后,原来对它的引用并没用指向新的对象。

Java参数,不管是原始类型还是引用类型,传递的都是副本(有另外一种说法是传值,但是说传副本更好理解吧,传值通常是相对传址而言)。

如果参数类型是原始类型,那么传过来的就是这个参数的一个副本,也就是这个原始参数的值,这个跟之前所谈的传值是一样的。如果在函数中改变了副本的值不会改变原始的值.

如果参数类型是引用类型,那么传过来的就是这个引用参数的副本,这个副本存放的是参数的地址。如果在函数中没有改变这个副本的地址,而是改变了地址中的值,那么在函数内的改变会影响到传入的参数。如果在函数中改变了副本的地址,如new一个,那么副本就指向了一个新的地址,此时传入的参数还是指向原来的地址,所以不会改变参数的值。