class test{
   int a;
   test(int i){
           a=i;
   }
   test incrbyten(){
           test temp=new test(a+10);
           return temp;
   }
}

class retob{
   public static void main(String args[]){
           test ob1=new test(2);
         test ob2;
         ob2=ob1.incrbyten();
         System.out.println("ob1.a"+ob1.a);
         System.out.println("ob2.a"+ob2.a);
         ob2=ob2.incrbyten();
         System.out.println("ob2.a after second increase: "+ob2.a);
   }
}



我始终不明白class test中test incrbyten()是成员函数。但为什么incrbyten()前面还加test，这不是自调用吗？是递归吧。而且我没找到调处的条件。
对它的理解进入了死循环，怎么也想不出输出结果：
ob1.a ：2
ob2.a :12
ob2.a after second increase: 22
但事实上，调试通过了

当然不是递归调用了:

1. test incrbyten(){
   
2.            test temp=new test(a+10);
   
3.            return temp;
   
4.    }
   

复制代码

很明显了,返回值为test类型,test类就是你自己定义的那个test类.

class test{
   int a;//定义了一个成员变量a
   test(int i){
           a=i;
   }
   test incrbyten(){
           test temp=new test(a+10);
           return temp;
   }
}

class retob{
   public static void main(String args[]){
         test ob1=new test(2);//1..创建对象并且传递了一个实际参数2，这个时候就会去test类里面找到相对应的构造函数进行初始化，并且把2的值赋值给了a，这时a的值是2.

         test ob2;//定义了一个局部变量ob2

         ob2=ob1.incrbyten();//2..由于上面我已经创建了一个对象，这个ob1已经指向了这个对象，并且调用了本类中一个incrbyten()方法，值得一提的是test incrbyten()这个方法的返回值类型是一个
                               个类类型的变量test，还有的就是这个方法体里面又创建了一个对象，相当于在堆内存中又开辟了一个新的空间，这时的a已经是2，2+10=12，那么这次传递的实际参数就是
                                12.这时找到了相对应的构造函数进行了初始化，并且赋值给了a，这时a的值就是12了，这时0b2指向了这个对象。注意的是是，这时堆内存中有创建了2个对象了。ob1和ob2
                                在ob1空间里面a的值是2.在ob2空间里面a的值是12
         System.out.println("ob1.a"+ob1.a);//这里输出的就是ob1里面a的值2
         System.out.println("ob2.a"+ob2.a);//这里输出的就是ob2里面a的值12
         ob2=ob2.incrbyten();//ob2调用了test incrbyten()这个方法，那么又在堆内存中新开辟了空间，初始化过程类似于2步骤。
         System.out.println("ob2.a after second increase: "+ob2.a);//打印输出的就是22了。还有的就是递归吧，就是一个show方法体里面调用自己show方法。这才是递归。
   }
}



我始终不明白class test中test incrbyten()是成员函数。但为什么incrbyten()前面还加test，这不是自调用吗？是递归吧。而且我没找到调处的条件。
对它的理解进入了死循环，怎么也想不出输出结果：
ob1.a ：2
ob2.a :12
ob2.a after second increase: 22
但事实上，调试通过了

      递归是一种方法（函数）调用自已编程技术， 递归就是程序设计中的数学归纳法。简单说就是在方法中调用自己的方法，楼主这个test构造器虽然调用自身，但构造器有个特点就是它只会执行一次，所以楼主这个不是递归,更不会死循环。来说说这个程序的过程吧：
    1、生成ob1时初始化test（2） a值为2 ；此时ob1中的a是2.
    2、生成test类型的ob2（所谓一个类型可以理解为它包含如a之类的成员变量的一种东东），
    3、ob1走Incrbyten方法，把a初始化成了12，此时ob2中的a是12.
    4、输出两个对象的成员变量a的值
    5、ob2再走一趟incrbyten后，a被初始化为了22，把此时的test类型对象又的给了ob2自己，此时的ob2的a值为22.
    6、输出ob2的a值为22.

楼主你走入误区了：
  test incrbyten(){
           test temp=new test(a+10);
           return temp;
   }
这个函数确实是test的的成员函数，但它更是test类中的方法。
从你方法里面的内容返回值为temp，而你定义temp为test类型的
所以，test代表的是返回值类型，而不是你想的test构造

这个函数不会陷入死循环。
当test ob1=new test(2);时，
传入2，则a=2
当         test ob2;
         ob2=ob1.incrbyten();
这里ob2是和ob1有关的，调用incrbyten();方法，a=10+2=12
返回的还是test类，所以下面还能调用ob2
                  ob2=ob2.incrbyten();
这是ob2再次调用它的incrbyten();a=12+10=22

所以楼主只要知道 test incrbyten(){
           test temp=new test(a+10);
           return temp;
   }
中的test是返回值类型，也就是说这个函数返回的是test类，就明白了

   test incrbyten(){
           test temp=new test(a+10);
           return temp;
   }

这里的test 是返回类型
方法的基本格式是: 权限修饰符   返回值类型   方法名 (参数1,参数2,...){ 方法体   return}
权限修饰符: public pretected  private  default(不写就是这种类型)
返回值类型: 可以使8中基本数据类型  引用数据类型   void(什么都不返回)
方法名和参数就不说了,

要把引用和对象在内存中存储的地方和过程要好好看一下

incrbyten()前面的Test是这个函数的返回类型，返回值是个Test对象，这不是递归，没有问题，不会死循环，楼主理解有误

我始终不明白class test中test incrbyten()是成员函数。但为什么incrbyten()前面还加test，这不是自调用吗？是递归吧。而且我没找到调处的条件。
解释：不是自调用，这个方法返回一个test对象，属于类成员函数！