为什么同样是函数，调用之后，返回的值会不一样呢，如下面两段代码所示：

1. public class Test {
   
2.         public static void leftshift(int i, int j) {
   
3.                    i+=j;   //i=i+j
   
4.                 j=++j;  //j=++j
   
5.                 //System.out.println(i);
   
6.                 //System.out.println(j);
   
7.         }
   
8.         public static void main(String args[]) {
   
9.                 int i = 4, j = 2;
   
10.                 leftshift(i, j);
    
11.                 System.out.println(i);  
    
12.                 System.out.println(j);  
    
13.         }
    
14. }
    

复制代码

上面这段代码，返回的值，i=4，j=2，调用的方法中有两个式子i+=j；j=++j，两个式子并没有影响到在主函数定义的i和j.
而下面这段代码却是不一样，如下所示：

1. public class Demo {
   
2.         public static void main(String[] args){
   
3.                 int[] a=new int[1];                //创建整型数组a,并分配其空间大小为1
   
4.                 modify(a);                        //调用方法,并将数组a传入,参与运算
   
5.                 System.out.println(a[0]);        //打印数组a的0角标位上的数
   
6.         }
   
7.         public static void modify(int[] a){                //创建方法modify,有数组参与运算,没有具体的返回值
   
8.                 a[0]++;                        //数组a,的0角标位上的数自增,a[0]=a[0]+1
   
9.         }
   
10. }

复制代码

这段代码输出的结果是1
主函数中只是定义了该数组，并没有赋值，因为数组都有默认初始值，其初始值为0.
在函数中,有a[0]++这个式子,a[0]自增后,a[0]成了1.
想请问下,关于函数,这些是如何定义这块的,在线等解释.
为什么两段代码,调用函数,有一个,函数的值,影响到了主函数的值,而另一个却没有?

都是局部变量。
因为数组，列表都是可修改的，所以作为成员变量传入的是他们的引用，修改了会直接影响数组本身。

感觉是局部变量的问题

1. public class Test
   
2. {  
   
3.         public static void main(String args[])
   
4.                 {
   
5.                 int i = 4, j = 2;
   
6.                 leftshift(i, j);
   
7.                 System.out.println(i);  
   
8.                 System.out.println(j);  
   
9.         }
   
10.                  public static void leftshift(int i, int j)
    
11.                 {
    
12.                    i+=j;   //i=i+j
    
13.                 j=++j;  //j=++j
    
14.                 System.out.println(i);
    
15.                 System.out.println(j);
    
16.         }
    
17. }
    

复制代码

打印出来的结果是6，3，4，2.在leftshift函数里面，定义的局部变量i和j。是存在于栈内存中，运行得到新值6和3.
在函数运行完以后，系统就把他们干掉了。所以最后打印的还是4和2
第二块代码里面建立一个数组，数组是在对内存中，是有初始值的。而且一直有引用指向数组，所以数组没有被jvm干掉。

public class Test {
        public static void leftshift(int i, int j) {
                   i+=j;   //i=i+j
                j=++j;  //j=++j
                //System.out.println(i);
                //System.out.println(j);
        }
        public static void main(String args[]) {
                int i = 4, j = 2;
                leftshift(i, j);
                System.out.println(i);  
                System.out.println(j);  
        }
}
i和j是局部变量 存储在栈内存 作用范围只在本方法中有效调用leftshift()方法的时候 这个方法进栈内存 这两个变量随之进栈内存
之后进行    i+=j;  j=++j; 运算 之后leftshift() 方法出栈   i+=j;  j=++j; 随着方法出栈 也就是被干掉了
所以打印结果为主函数里定义的变量的值 i=4  j=2


public class Demo {
        public static void main(String[] args){
                int[] a=new int[1];                //创建整型数组a,并分配其空间大小为1
                modify(a);                        //调用方法,并将数组a传入,参与运算
                System.out.println(a[0]);        //打印数组a的0角标位上的数
        }
        public static void modify(int[] a){                //创建方法modify,有数组参与运算,没有具体的返回值
                a[0]++;                        //数组a,的0角标位上的数自增,a[0]=a[0]+1
        }
}

这个程序在主函数里定义了一个整型数组 数组也是一个对象 所以会存储在堆内存中  定义变量a指向了堆内存中的这个数组
调用modify()方法把这个数组传进方法中进行运算后 堆内存中的数据是不会随方法的出栈而出栈的 它是利用java中特有的垃圾回收机制 等待jvm空闲时去回收它
所以最后打印的结果为调用方法运算后的结果
建议楼主复习一下 堆内存 和 栈内存 的区别 这些题就会迎刃而解了

我发表下我的看法
第一段代码，楼主就是自己挖坑自己跳，把函数的参数设为i j，和主函数变量名一样，结果自己搞混了，
函数的未知数可以为ij，也可以是xy，你把函数ij改成xy，是不是好理解，这个函数只是自己在运算，对主函数
的变量没影响。

第二段代码的函数参数类型是数组，你调用函数是把a数组赋给了这个函数，函数的运算就会影响到a数组