在Java当中，构造方法、函数，传递参数是最为常见的，有时候我们希望能带出计算结果，重新赋给传入值，实现对变量赋值的更新。
假如一个方法试图将一个参数值增加至原来的3倍，我们可能会写下如下代码： 

class PassValue 
{   //方法是否对参数构成影响？------传值的方式
      public static void main(String[] args) 
     {
            int i = 10;
            callByValue(i);
            System.out.println(i);
      }   
     //申明一个没有返回值的【值调用】静态方法；     
       static void callByValue(int n)
      {
             n = n*3;
      }
}



结果：返回10，也就是说，我们的i没有受到任何的影响；


其原理是i=10;当执行方法的时候，n拷贝了i的数值，并形成一个副本n=10；执行n=n*3;后n的值变为30；方法结束后，n不再使用，对我们先前的i没有任何的影响；



-------------------------------------------------------------------- 


class PassValue 
{   //方法是否对参数构成影响？------传值的方式
      public static void main(String[] args) 
     {
            int i = 10;
            i=callByValue(i);//我们强行赋值；
            System.out.println(i);
      }   
     //申明一个没有返回值的【值调用】静态方法；     
       static int callByValue(int n)
      {
             n = n*3;
             return n;
      }
}



结果：返回30， 在该示例代码中，通过把修改以后的参数n的值返回，来为变量i赋值，强制修改按值传递参数的值，从而达到修正参数值的目的；



--------------------------------------------------------------------


对于引用型传值和数值型传递的对比： 


class PassValue 
{
      public static void main(String[] args) 
     {
          int i = 10;
          callByValue(i);
          System.out.println("值调用下i值:"+i);
	 System.out.println("-------------------------------------");


	 test person=new test(2);//初始化getmoney 为2；
            System.out.println("先前的person的getmoney:"+person.getmoney);
	  callByReference(person);

           System.out.println("使用callByReference(person)之后的person的getmoney:"+person.getmoney);
           System.out.println("代入person后的方法使得person的值发生了改变！");


      }   
//申明一个没有返回值的【值调用】静态方法；     
       static void callByValue(int n)
      {

             n= n*3;
      }

//申明调没有返回值的【调用引用】静态方法
      static void callByReference(test i)
      {
            i.add(i.getmoney);
      }
}

class test //构造一个 test 类，有一个getmoney的int属性，它的方法使原始赋值增为原来的3倍；
{      int getmoney;
	    public test(int n)
	    {
                 getmoney=n;
	     }
	    public void add(int a)
	    {
	        getmoney=a*3;
	    }

}



值调用下i值:10


先前的person的getmoney:2


使用callByReference(person)之后的person的getmoney:6


代入person后的方法使得person的值发生了改变！



--------------------------------------------------------------


上面的一段程序有点绕，其实简单的看就是int i = 10; callByValue(i);后i值没有变；而test person=new test(2);callByReference(person);后person的值变了；



给大家来个更简单的说明问题： 


class PassValue 
{
     public static void main(String[] args) 
     {
         int a = 10;
         int[] b = {1,2,3};
         test(a,b);
         System.out.println(a);
         System.out.println(b[0]);

     }        
     static void test(int n,int[] t)
     {
         n = 0;
         t[0] = 12345;
      }

}



输出结果为:10 12345


同样都是传入参数，为什么变量a的值未改变，而b[0]的值发生了改变呢？


在参数传递时，一般存在两种参数传递的规则，在Java语言中也是这样，这两种方式依次是：



l 按值传递(by value)



按值传递指每次传递参数时，把参数的原始数值拷贝一份新的，把新拷贝出来的数值传递到方法内部，在方法内部修改时，则修改的时拷贝出来的值，而原始的值不发生改变。



说明：使用该方式传递的参数，参数原始的值不发生改变。



l 按址传递(by address)



按址传递指每次传递参数时，把参数在内存中的存储地址传递到方法内部，在方法内部通过存储地址改变对应存储区域的内容。由于在内存中固定地址的值只有一个，所以当方法内部修改了参数的值以后，参数原始的值发生改变。



说明：使用该方式传递的参数，在方法内部修改参数的值时，参数原始的值也发生改变。



在Java语言中，对于那些数据类型是按值传递，那些数据类型是按址传递都作出了硬性规定，如下所示：



l 按值传递的数据类型：八种基本数据类型和String



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



文笔不好，大家凑合看看咯。