package cn.itcast;

public class TestDemo
{
        public static void main(String[] args)
        {
                int[] a=new int[1];
                modify(a);
                System.out.println(a[0]);
        }
        public static void modify(int[] a)
        {
                a[0]++;
        }
}

1. public class TestDemo {
   
2.         public static void main(String[] args) {
   
3. 
   
4.                 //1.1这里定义了一个int数组 a，并指定数组空间大小为1
   
5.                 int[] a = new int[1];
   
6.                 //1.2调用modify方法，把上面的数组a传递过去
   
7.                 modify(a);
   
8.                 //1.4
   
9.                 //取出数组中的第1个元素，由之前调用方法中可以知道此时这个元素的值为1，并将它打印
   
10.                 //结果输出1
    
11.                 System.out.println(a[0]);
    
12.         }
    
13. 
    
14.         //接受传过来的数组a
    
15.         public static void modify(int[] a) {
    
16.                 //1.3
    
17.                 //a[0]就是指数组中的第1个元素
    
18.                 //从数组中取第1个元素，因为之前定义数组的时候，并没有给数组赋值
    
19.                 //所以取出来的值默认是0
    
20.                 //然后a[0]++，就是0++,为1
    
21.                 //然后数组中的这个值就改变成1了
    
22.                 a[0]++;
    
23.         }
    
24. }

复制代码

详细的过程都写在上面的代码里边了，楼主仔细看一下就明白了

public class TestDemo
{
        public static void main(String[] args) //主函数，程序从这里开始执行；
         {
                int[] a=new int[1]; //创建了一个名为a的int类型的数组，数组长度为1，
                modify(a); //将a作为参数传入modify中，调用函数modify的方法；
                System.out.println(a[0]); //输出语句：打印0角标元素的值；
        }
         public static void modify(int[] a) //定义了一个modify方法，该方法传入的是int类型的数组；
         {
                a[0]++;    //自增语句；数组默认初始化为0，该语句自增后结果为1；
         }
}

public class TestDemo
{
              public static void main(String[] args)
             {
                            int[] a=new int[1];   ←创建了一个长度为1的int类型数组对象a；
                            modify(a);       ←调用modify方法。并且把数组a作为参数传入；
                            System.out.println(a[0]);     ←打印a[0]的值；
              }
               public static void modify(int[] a)   ← 定义一个静态方法，这样main主函数才能调用它，这个方法接收的参数是一个int类型的数组，
             {
                               a[0]++;   
             }
}

打印结果是1，对象a这个数组里面只有一个元素，就是a[0],modify方法对a[0]元素进行了自增，所以调用完modify方法后a[0]的值就成了1,

首先你把这个看懂就ok
成员变量和局部变量的区别
        (1)作用域
        成员变量：针对整个类都有效。
        局部变量：在某个范围内有效。(一般指的就是方法,语句体内)
        (2)存储位置
                成员变量：随着对象的创建而存在，存储在堆内存中。随着对象的消失而消失。
                局部变量：在方法被调用，或者语句被执行的时候存在，存储在栈内存中。
                                  当方法调用完，或者语句结束后，就自动释放。
        (3)初始值
                成员变量：都有默认初始值。
                局部变量：没有默认初始值，使用前，必须赋值。