java调c 参数传递_java中参数传递实例

//在函数中传递基本数据类型，

2. public class Test {

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

5.         int temp = i;

6.         i = j;

7.         j = temp;

8.     }

10.     public static void main(String[] args) {

11.         int a = 3;

12.         int b = 4;

13.         change(a, b);

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

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

17.     }

18. }

19.

20. 结果为:

21. a=3

22. b=4

23. 原因就是 参数中传递的是 基本类型 a 和 b 的拷贝,在函数中交换的也是那份拷贝的值 而不是数据本身;

=====================================================

例4:

String 不改变，数组改变

Java代码 复制代码

1.

2. public class Example {

3.     String str = new String("good");

4.

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

6.

7.     public static void main(String args[]) {

8.         Example ex = new Example();

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

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

11.         System.out.println(ex.ch);

12.     }

13.

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

15.         str = "test ok";

16.         ch[0] = 'g';

17.     }

18. }

19. 程序3输出的是 good and gbc.

=============================================================

传值---传递基本数据类型参数

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的值在调用前后并没改变。

======================================================

引用传递---对象作为参数

如果在方法中把对象(或数组)作为参数，方法调用时，参数传递的是对象的引用(地址)，即在方法调用时，实际参数把对对象的引用(地址)传递给形式参数。这是实际参数与形式参数指向同一个地址，即同一个对象(数组)，方法执行时，对形式参数的改变实际上就是对实际参数的改变，这个结果在调用结束后被保留了下来。

Java代码

class Book{

String name;

private float price;

Book(String n,    float p ){                //构造方法

name = n;

price = p;

}

static  void  change(Book a_book,    String n,    float p){    //静态方法，对象作为参数

a_book.name = n;

a_book.price = p;

}

public void output(){        //实例方法，输出对象信息

System.out.println("name: " + name + "\t" + "price: " + price);

}

}

public class PassAddr{

public static void main(String [] args){

Book b = new Book("java2",    32.5f);

System.out.print("before call:\t");        //调用前

b.output();

b.change(b,    "c++",    45.5f);            //引用传递，传递对象b的引用，修改对象b的值

System.out.print("after call:\t");            //调用后

b.output();

}

}

运行结果：

before    call:    name:java2        price:32.5

after       call:    name:c++          price:45.5

说明：调用change(b,"c++",45.5f)时，对象b作为实际参数，把引用传递给相应的形式参数a_book,实际上a_book也指向同一个对象，即该对象有两个引用名：b和a_book。在执行方法change()时，对形式参数a_book操作就是对实际参数b的操作。

=====================================================

//对象的引用(不是引用的副本)是永远不会改变的

2. class A {

3.     int i = 0;

4. }

5.

6.

7. public class Test {

8.

9.     public static void add(A a) {

10.         a = new A();

11.         a.i++;

12.     }

13.

14.     public static void main(String args[]) {

15.         A a = new A();

16.         add(a);

17.         System.out.println(a.i);

18.     }

19. }

20.

21. 输出结果是0

22. 在该程序中，对象的引用指向的是A ,而在change方法中，传递的引用的一份副本则指向了一个新的OBJECT，并对其进行操作。

23. 而原来的A对象并没有发生任何变化。 引用指向的是还是原来的A对象。

====================================================

//传的是引用数据类型

2. public class Test {

4.     public static void change(int[] counts) {

5.         counts[0] = 6;

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

7.     }

9.     public static void main(String[] args) {

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

11.         change(count);

12.     }

13. }

14.     运行结果是：6

15. 在方法中 传递引用数据类型int数组，实际上传递的是其引用count的拷贝，他们都指向数组对象，在方法中可以改变数组对象的内容。即:对复制的引用所调用的方法更改的是同一个对象。