这个函数的运行结果不太能理解

public class Test6 {

   public static void main(String[] args) {

      int a = 10;

      int b = 20;

      System.out.println("a:" + a + ",b:" + b);//a:10,b:20

      change(a, b);

      System.out.println("a:" + a + ",b:" + b);//a:10,b:20    System.out.println("********************************")     int[] arr = { 1, 2, 3, 4, 5 };

      change(arr);

      System.out.println("arr[1]" + arr[1]);//4   }

   public static void change(int[] arr) {

      for (int x = 0; x < arr.length; x++) {

         if (arr[x] % 2 == 0) {

            arr[x] *= 2;

         }

      }

   }

   public static void change(int a, int b) {

      System.out.println("a:" + a + ",b:" + b);//a:10,b:20

      a = b;

      b = a + b;

      System.out.println("a:" + a + ",b:" + b);//a:20,b:40

   }

}

基本数据类型有8种，byte,char,int,float,short,double,long,boolean.其他的都是引用类型。顾名思义，引用类型的实例在栈中，保存的是数据在堆中的物理地址，只是一个“引用”。就相当于一个箭头，指向堆中的数据一样。

public class Test6 {

           public static void main(String[] args) {

              int a = 10;

              int b = 20;

              System.out.println("a:" + a + ",b:" + b);//a:10,b:20

              change(a, b);

              System.out.println("a:" + a + ",b:" + b);//a:10,b:20    System.out.println("********************************")     int[] arr = { 1, 2, 3, 4, 5 };
             
              int [] arr=new int[]{1,2,3,4,5,6};//定义一个数组。
              change(arr);// 你的代码中arr还没有定义，请先定义一个数组。不然会提示        arr cannot be resolved to a variable
                      //chang(arr),将数组arr中的所有偶数乘以2 。 所以后面的arr[1]的值 由2 变成 2*2==4
              System.out.println("arr[1]" + arr[1]);// arr[1]==4,所以结果：arr[1]4
              }

         

           public static void change(int[] arr) {

              for (int x = 0; x < arr.length; x++) {

                 if (arr[x] % 2 == 0) {//遍历数组 arr中的每一个元素。并判继是否为偶数。

                    arr[x] *= 2;//等价于 arr[x]=arr[x]*2     将数组中的所有偶数乘以2

                 }

              }

           }

         

           public static void change(int a, int b) {

              System.out.println("a:" + a + ",b:" + b);//a:10,b:20

              a = b;        //a==b,b==b 所以，a:20,b:20

              b = a + b;// b=b+b--->b=20+20; 所以，a:20,b:40

              System.out.println("a:" + a + ",b:" + b);//a:20,b:40

           }

        }

结果：
a:10,b:20
a:10,b:20
a:20,b:40
a:10,b:20
arr[1]4

（一）基本数据类型：传值，方法不会改变实参的值。

1. 　　public class TestFun {
   
2. 　　public static void testInt(int i){
   
3. 　　i=5;
   
4. 　　}
   
5. 　　public static void main(String[] args) {
   
6. 　　int a=0 ;
   
7. 　　TestFun.testInt(a);
   
8. 　　System.out.println("a="+a);
   
9. 　　}
   
10. 　　}

复制代码

程序执行结果：a=0 。
（二）传引用，方法体内改变形参引用，不会改变实参的引用，但有可能改变实参对象的属性值。

1. public static void main(String[] args)
   
2. {
   
3.         int temp[]={1,3,5};
   
4.         fun(temp);
   
5.         for(int i=0;i<temp.length;i++)
   
6.                 System.out.println(temp[i]);
   
7. }
   
8. 
   
9. public void fun(int x[])
   
10. {
    
11.         x[0]=6;
    
12. }

复制代码

结果为：6,3,5.
因为数组是引用类型，所以方法本身没有任何返回值，修改后的结果也会被保存下来。

总结：
　　第一：形参不会改变实参的值。
      第二：数组引用类型，改变了堆内存中的内容，因此会保存下来。
你不明白的地方，也许就是对实参、形参，引用类型的传值不太明白吧？

主要是基本数据类型和引用数据类型的区别
public class Test6 {
        public static void main(String[] args) {
                int a = 10;
                int b = 20;
                System.out.println("a:" + a + ",b:" + b);//a:10,b:20
                change(a, b);
                System.out.println("a:" + a + ",b:" + b);//a:10,b:20,change函数运算结束弹栈了,所以结果还是a:10,b:20
                System.out.println("********************************")                int[] arr = { 1, 2, 3, 4, 5 };
                change(arr);
                System.out.println("arr[1]" + arr[1]);//4,数组存储在堆内存中,相当于指向的是其地址值,而地址值没有变化,所以返回了运算后的结果
        }

        public static void change(int[] arr) {
                for (int x = 0; x < arr.length; x++) {
                        if (arr[x] % 2 == 0) {
                                arr[x] *= 2;
                        }
                }
        }

        public static void change(int a, int b) {
                System.out.println("a:" + a + ",b:" + b);//a:10,b:20
                a = b;
                b = a + b;
                System.out.println("a:" + a + ",b:" + b);//a:20,b:40
        }
}
  参数的问题：
  基本数据类型：形参的改变对实参没有影响
  引用数据类型：形参的改变直接影响实参.

我给你加了注释，希望帮助到你

1. public class Test {
   
2.    public static void main(String[] args) {
   
3.       int a = 10;
   
4.       int b = 20;
   
5.       System.out.println("a:" + a + ",b:" + b);//a:10,b:20
   
6.       change(a, b);//调用change方法
   
7.       System.out.println("a:" + a + ",b:" + b);//a:10,b:20    还是原来的数据
   
8.       System.out.println("********************************")  ;  
   
9.       int[] arr = { 1, 2, 3, 4, 5 };
   
10.       change(arr);
    
11.       
    
12.       /*
    
13.        * 这里的arr[1] 原来是2，所以符合转换方法要求，就乘以2结果就得4
    
14.        */
    
15.       System.out.println("arr[1]" + arr[1]);
    
16.    }
    
17.    
    
18.    
    
19.    public static void change(int[] arr) {
    
20.            //遍历数组
    
21.       for (int x = 0; x < arr.length; x++) {
    
22.       //如果数组里的值为2的整数倍，则原来的值乘以二
    
23.          if (arr[x] % 2 == 0) {
    
24.             arr[x] *= 2;
    
25.          }
    
26.       }
    
27.    }
    
28.    public static void change(int a, int b) {
    
29.            //先打印原来的数 的值
    
30.       System.out.println("a:" + a + ",b:" + b);//a:10,b:20
    
31.       a = b;//把b的值赋给a，则a=20
    
32.       b = a + b;//这里a已经是20，再加上b的20赋给b，就得到b=40
    
33.       System.out.println("a:" + a + ",b:" + b);//a:20,b:40
    
34.    }
    
35. }

复制代码

这个类里面你定义了两个静态函数
第一个函数是对数组进行操作，如果某一个数组元素能被2整除，那么这个元素的值就乘以2，所以运行完这个函数，被2整除的数组元素全部加倍。
第二个函数就是简单的赋值，先将参数b的值赋给a，之后b的值就是2b了。{:soso_e128:}