1. public class Test2{
   
2. public static void add(Integer i){
   
3.        int val=i.intValue();
   
4.        val+=3;
   
5.        i=new Integer(val);
   
6.        System.out.println( i );  //这里打印是3
   
7. }
   
8. public static void main(String args[]){
   
9.       Integer i=new Integer(0);
   
10.       add(i);
    
11.       System.out.println(i.intValue());  //为什么这里结果是 0 ，难道没有调用到那个方法么？
    
12. }
    
13. }

复制代码

楼主看下面的注释，不知道我这样理解有没有错，我是这样想的，希望对你有帮助


public class Test2{
public static void add(Integer i){
       int val=i.intValue();
       val+=3;
       i=new Integer(val);
       /*
        * 自动拆箱，i获得实例化传的参值0，在赋值给val，然后val在加3这时val的值是3
        * 而i又重新实例化了，传入的值是val，所以打印就是3
        */
       System.out.println( i );  //这里打印是3

}
public static void main(String args[]){
      Integer i=new Integer(0);
      add(i);
      /*
       *因为你定义了一个Integer i并实例化传了个参数0 ,这里就是所谓的自动装箱。
       *你用i调用了intValue()，得到对象里面的值
       */
      System.out.println(i.intValue());  //为什么这里结果是 0 ，难道没有调用到那个方法么？

}

}

我认为吧，像Integer对象中这些基本数据类型，在调用函数时是值传递，不是引用传递。你调用add（）方法后，返回一个结果，但是原来的Integer i=new Integer(0); ，在主函数中还存在，并没有改变。

为什么呢  

因为
public class Test2{

public staticintadd(Integer i){ i虽然是被传进来了 但是它只是个引用，方法调用结束，它就拜拜了

       int val=i.intValue();

       val+=3;

       i=new Integer(val);

       System.out.println( i );  //这里打印是3
   return i;
}

public static void main(String args[]){

      Integer i=new Integer(0);

     int a= add(i); 你是往方法里传入了一个i  但是方法得到的那个i不是你主函数里的i　　而是它的引用，不是同一个东西

      System.out.println(a);  //为什么这里结果是 0 ，难道没有调用到那个方法么？

}

}

public class Test2 {   
public static void add(Integer i) {
  int val = i.intValue();
  val += 3;
  i = new Integer(val);
  System.out.println(i);                      // 这里打印是3
}
public static void main(String args[]) {
  Integer i = new Integer(0);
  add(i);                                            
  System.out.println(i.intValue());        // 这里打印0，因为add(i)中的i值在add方法执行完后就已经失效，这里打印的i值是main函数的i值，该值并未被改变
}
}

观察add方法中这句：i=new Integer(val);
是不是重新定义了一个Integer对象，并将它赋值给i，而其前面没有对i改变过，后面的已经没有机会更改了。
所以，add方法并没用改变i，最后a为0。

执行main方法，然后执行Integer i=new Integer(0); i=0;
调用add方法，出入0，运算打印3；
接着执行 System.out.println(i.intValue());  调用i的值，为0 啊。

public static void add(Integer i)你定义这个方法的同时，定义了一个 Integer i，这个i是这个方法体里的局部变量。
add(i)；调用这个方法时，是把main函数里面的i的值赋给了add方面里面的i。
如果我在main函数里面顶一个int x =3； 然后调用add(x);实际相当于add(Integer i = x)，这样你应该能看懂了，x把自己的值赋给了i，那么之后就没他什么事了，他该是多少就是多少，不会参与add方法里面的计算！你两次打印的i不是同一个i，一个是add方法里面的局部变量，一个是main函数的，只不过他们有相同的变量名，让你误以为他们是同一个Integer

调用了，但是你没有打印调用的值，应该这样

1. public class Test2{
   
2. public static void add(Integer i){
   
3.        int val=i.intValue();
   
4.        val+=3;
   
5.        i=new Integer(val);
   
6.        System.out.println( i );  
   
7. }
   
8. public static void main(String args[]){
   
9.       Integer i=new Integer(0);
   
10.      
    
11.       System.out.println(add(i));  
    
12. }
    
13. }

复制代码

public class Test2{
        public static void add(Integer i){
       int val=i.intValue();  //将i转化为int型  var=0
       val+=3;   //val=val+3,
       i=new Integer(val);  //i=3
       System.out.println( i );  //这里打印是3   
            System.out.println(i.intValue());  //打印3
}

public static void main(String args[]){
      Integer i=new Integer(0);   //i就是int类型的0的包装类的对象  i=0  //这句话很重要。就是一种自动自动装箱。
      add(i);   //调用add();
          System.out.println(i);   //打印0
      System.out.println(i.intValue());  //为什么这里结果是 0 ，难道没有调用到那个方法么？ //
}

}

/*　Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。*/

/*intValue（）
如Integer类型，就会有intValue（）方法，意思是说，把Integer类型转化为Int类型。*/

/*函数的执行都是从主函数开始，从主函数结束。。。这是当初我们C语言来时讲的。。。java当然基础语法跟C语言是异曲同工之妙！*/


/*我在你的函数基础上加了几条语句。。调试~~！*/

这是典型的基本数据类型和引用数据类型的传递问题。
告诉LZ确实没调用到add()方法。

首先，LZ先明白这两种类型的值在传递时的原理
1，传递的是基本数据类型时，形参的改变对实参不影响。
2，传递的是引用数据类型时，形参的直接影响实参

LZ打印输出的是i.intValue()的值，为什么结果是0呢。
原因：因为 i 已经被封装成对象了，所以这里的 i 是引用数据类型， i 也没有调用add()方法。只有add(i)这里面
的 i 调用了这个方法，它们只是名字相同而已，因为这个方法必须要传入基本类型的值才会被调用运行。
结果：所以add(i)的值为3，而这里 System.out.println(i.intValue());  打印输出的结果肯定是  0 。

楼主要知道 java 和C语言的区别
java 程序设计语言总是采用     “值调用”   也就是说 方法得到的是所有参数值 的一个拷贝 ，而且 方法不能修改任何传递给他的参数变量的值，

比如
int  number=10;
Hello.change(number);
先不管方法要做什么 方法结束后  number 的值 依然是10 没有变！
看下面 ：
public static void trigger(int x){

   x = x*10;
}

然后 调用：
int number=10;
trigger(bumber);
无论怎样 调用这个方法之后  number 的值依然是10


但是 一般方法提供的参数 有两种类型：
1.基本数据类型
2.对象引用

很多程序设计语言 提供了两种参数传递方式：值调用 和引用调用 。但是
请记住： java 使用采用的是 值调用     ！！！没有引用调用！！
总结如下：
在java中
一个方法不能修改一个基本数据类型的参数的值
一个方法可以改变一个对象参数的状态，但是不能实现让一个对象参数引用一个新的对象！

你写得这个方法 打印出来的永远是零 看看我的解释

看了这么多回答，大致了解了，谢谢各位了！