Java中的各种参数传递方式

1.基本数据类型传递

以整型为例

 public void swap1(int a,int b)//基本类型传参交换
   {
       int temp=a;
       a=b;
       b=temp;
       System.out.println("swap函数中 a="+a+",b="+b);
   }

 test t=new test();
       int a=5,b=6;
       System.out.println("传参之前  a="+a+",b="+b);
       t.swap1(a,b);
       System.out.println("传参之后  a="+a+",b="+b);

从允许结果中可以发现调用swap函数之后，a b的值并没有发生变化，这是因为swap方法中的局部变量是生存在栈上面的，当方法执行完毕以后，方法里面的局部变量也就消失了。

2.两个参数为引用类型的交换

 public void swap2(A a,A b)//类类型传参交换
   {
       A temp=a;
       a=b;
       b=temp;
       System.out.println("swap函数中： a.val="+a.getVal()+",b.val="+b.getVal());
   }

test t=new test();
      A a=new A();
      a.setVal(1);
      A b=new A();
      b.setVal(2);
      System.out.println("传参之前： a.val="+a.getVal()+",b.val="+b.getVal());
      //System.out.println(a);
      t.swap2(a,b);
       System.out.println("传参之后： a.val="+a.getVal()+",b.val="+b.getVal());
       //System.out.println(a);

从运行结果中可以看成两个引用变量a b也没有改变，原因和前面一样，函数里面的引用变量a b temp都是局部的，当方法执行完以后就消失了。

3.参数为引用类型的重新赋值

 public void assign_again(A a)
   {
       a.setVal(9);
       System.out.println("在assign_again方法中: a.val="+a.getVal());
   }

test t=new test();
    A a=new A();
    a.setVal(1);
    System.out.println("传参之前： a.val="+a.getVal());
    t.assign_again(a);
    System.out.println("传参之后： a.val="+a.getVal());

从运行结果中可以看出a,val发生了变化，这是因为虽然assign方法中的a是一个局部变量，方法执行完就消失了，但是在执行的时候，也就是方法中的局部变量a还有效的时候，它指向主函数中创建的那个A对象，在assign方法中对val做出了改变，虽然它自己消失了，但是改变的影响是存在的。

4.两个传递的参数为数组的交换

  public void swap3(int a[],int b[])
   {
       int temp[];
       temp=a;
       a=b;
       b=temp;
       System.out.println("在方法中：");
       for(int i=0;i<3;i++)
           System.out.print(a[i]+" ");
       System.out.println();
       for(int i=0;i<3;i++)
           System.out.print(b[i]+" ");
       System.out.println();
   }

  test t=new test();
    int a[]={1,2,3};
    int b[]={4,5,6};
    t.swap3(a,b);
    System.out.println("在主函数中：");
    for(int i=0;i<3;i++)
        System.out.print(a[i]+" ");
    System.out.println();
       for(int i=0;i<3;i++)
           System.out.print(b[i]+" ");
       System.out.println();

从运行结果中可以看成，主函数中数组a b的内容没有改变,这种情况和3中交换两个引用变量的情况一样，数组名也是一个引用变量，数组也是一个对象

5.传递参数为数组的重新赋值

 public void assign_array(int [] a)
    {
        a[0]=0;
        a[1]=0;
        a[2]=0;
    }

 test t=new test();
       int a[]={1,2,3};
       for(int i=0;i<3;i++)
           System.out.print(a[i]+" ");
       System.out.println();
       t.assign_array(a);
       for(int i=0;i<3;i++)
           System.out.print(a[i]+" ");

这种情况类似于类型3，可以把数组中的元素认位是对象里面的实例变量val

6.传递的参数是两个String类型的交换

 public void swap4(String s1,String s2)
   {
       String temp;
       temp=s1;
       s1=s2;
       s2=temp;
       System.out.println("方法中： s1="+s1+",s2="+s2);
   }

test t=new test();
    String s1="aaa";
    String s2="bbb";
    System.out.println("传参之前： s1="+s1+",s2="+s2);
    t.swap4(s1,s2);
    System.out.println("传参之后： s1="+s1+",s2="+s2);

String类型也是一个对象，这种情况同类型2

7.传递参数为String的重新赋值

  public void assign_string(String s1)
    {
        s1="bbb";
        System.out.println("传参之后： s1="+s1+"  s1.hashcode "+s1.hashCode());
    }

 test t=new test();
    String s1= new String("aaa");
    System.out.println("传参之前： s1="+s1+"  s1.hashcode "+s1.hashCode());
    t.assign_string(s1);
    System.out.println("传参之后： s1="+s1+"  s1.hashcode "+s1.hashCode());

运行结果很奇怪，为什么s1的值没有改变？hashcode可以看成是字符串内容的id,也就是说我传递了一个引用变量过去进行重新赋值，结果却得到了另外一个新的对象。是的，当你在方法中使用s1="bbb"时其实就是创建了一个新的对象，然后用传递的引用变量指向这个新的对象，因此主函数里面的引用变量指向的对象并没有发生改变

再来看下面这段代码

test t=new test();
    String s1="aaa";
    String s2="aaa";
    String s3="bbb";
    System.out.println("s1.hashcode="+s1.hashCode()+"  s2.hashcode="+s2.hashCode()+"  s3.hashcode="+s3.hashCode());

从运行结果中可以看出s1 s2指向的对象是一样的？但是为什么？我明明创建了两个,一个是s1 ，一个是s2.这是因为我们其实并没有真正的创建两个string对象。使用String s1=“aaa"时会在栈里面创建一个s1引用变量，然后查看字符串池里面有没有aaa,如果没有就将aaa加入符号池，如果有则不加，直接让s1指向"aaa”,这就是为什么后面s2="aaa"却没有创建一个对象