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. }

复制代码

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

这是典型的基本数据类型和引用数据类型的传递问题。
告诉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 。

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语言是异曲同工之妙！*/


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

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

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 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

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

观察add方法中这句：i=new Integer(val);
是不是重新定义了一个Integer对象，并将它赋值给i，而其前面没有对i改变过，后面的已经没有机会更改了。
所以，add方法并没用改变i，最后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值，该值并未被改变
}
}

为什么呢  

因为
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 ，难道没有调用到那个方法么？

}

}

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

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


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 ，难道没有调用到那个方法么？

}

}