java传递参数的两种方式

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

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

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

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

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

值传递的例子：

[java] view plain copy

print ?

1. package com.other.test;  
2.   
3. public class Test {  
4.     public static void change(int i, int j) {   
5.         int temp = i;   
6.         i = j;   
7.         j = temp;  
8.     }   
9.   
10.     public static void main(String[] args) {   
11.         int a = 3;   
12.         int b = 4;   
13.         change(a, b);   
14.         System.out.println(”a=” + a);   
15.         System.out.println(”b=” + b);  
16.     }  
17. }  

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

print ?

1. package com.other.test;  
2.   
3. public class Test {  
4.     public static void change(int[] counts) {   
5.         counts[0] = 6;   
6.         System.out.println(counts[0]);  
7.     }   
8.   
9.     public static void main(String[] args) {   
10.         int[] count = { 1, 2, 3, 4, 5 };   
11.         change(count);  
12.         System.out.println(count[0]);  
13.     }   
14. }  

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

print ?

1. package com.other.test;  
2.   
3. public class A {  
4.     int i = 0;  
5. }  

package com.other.test;

public class A {
    int i = 0;
}

对上边对象操作的类：

[java] view plain copy

print ?

1. package com.other.test;  
2.   
3. public class Test {  
4.     public static void add(A a) {   
5.         //a = new A();   ①  
6.         a.i++;  
7.     }   
8.   
9.     public static void main(String args[]) {   
10.         A a = new A();   
11.         add(a);   
12.         System.out.println(a.i );  
13.     }   
14. }  

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

print ?

1. package com.other.test;  
2.   
3. public class Test {  
4.     String str = new String(“old”);   
5.     char[] ch = { ‘a’, ‘b’, ‘c’ };   
6.     public static void main(String args[]) {   
7.         Test ex = new Test();   
8.         ex.change(ex.str, ex.ch);   
9.         System.out.print(ex.str + ” and ”);   
10.         System.out.println(ex.ch);  
11.     }   
12.   
13.     public void change(String str, char ch[]) {   
14.         str = ”new”;   
15.         ch[0] = ‘d’;  
16.     }  
17. }  

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一个，那么副本就指向了一个新的地址，此时传入的参数还是指向原来的地址，所以不会改变参数的值。

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

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

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

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

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

值传递的例子：

[java] view plain copy

print ?

1. package com.other.test;  
2.   
3. public class Test {  
4.     public static void change(int i, int j) {   
5.         int temp = i;   
6.         i = j;   
7.         j = temp;  
8.     }   
9.   
10.     public static void main(String[] args) {   
11.         int a = 3;   
12.         int b = 4;   
13.         change(a, b);   
14.         System.out.println(”a=” + a);   
15.         System.out.println(”b=” + b);  
16.     }  
17. }  

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

print ?

1. package com.other.test;  
2.   
3. public class Test {  
4.     public static void change(int[] counts) {   
5.         counts[0] = 6;   
6.         System.out.println(counts[0]);  
7.     }   
8.   
9.     public static void main(String[] args) {   
10.         int[] count = { 1, 2, 3, 4, 5 };   
11.         change(count);  
12.         System.out.println(count[0]);  
13.     }   
14. }  

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

print ?

1. package com.other.test;  
2.   
3. public class A {  
4.     int i = 0;  
5. }  

package com.other.test;

public class A {
    int i = 0;
}

对上边对象操作的类：

[java] view plain copy

print ?

1. package com.other.test;  
2.   
3. public class Test {  
4.     public static void add(A a) {   
5.         //a = new A();   ①  
6.         a.i++;  
7.     }   
8.   
9.     public static void main(String args[]) {   
10.         A a = new A();   
11.         add(a);   
12.         System.out.println(a.i );  
13.     }   
14. }  

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

print ?

1. package com.other.test;  
2.   
3. public class Test {  
4.     String str = new String(“old”);   
5.     char[] ch = { ‘a’, ‘b’, ‘c’ };   
6.     public static void main(String args[]) {   
7.         Test ex = new Test();   
8.         ex.change(ex.str, ex.ch);   
9.         System.out.print(ex.str + ” and ”);   
10.         System.out.println(ex.ch);  
11.     }   
12.   
13.     public void change(String str, char ch[]) {   
14.         str = ”new”;   
15.         ch[0] = ‘d’;  
16.     }  
17. }  

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一个，那么副本就指向了一个新的地址，此时传入的参数还是指向原来的地址，所以不会改变参数的值。