1. public class IntToBinaryDemo {
   
2.         public static void main(String[] args) {
   
3.                 int num = 6;
   
4. 
   
5. public static void toBinary2(int num) {
   
6.                 if (num > 0) {
   
7.                         toBinary2(num / 2);
   
8.                         System.out.print(num % 2);
   
9.                        
   
10.                 }
    
11.         }
    
12. }
    

复制代码

这个递归求6的二进制数
把toBinary2(num / 2);
放在System.out.print(num % 2);前面与后面输出的结果一个是110，一个是011
这样结果产生的原因是什么？

首先6传进来执行System.out.print(num % 2);  //6%2=0
输出0 然后执行toBinary2(num / 2);//因为是递归调用所以在把3传进来 判断3是不是大于0是  如果大于就输出的是1     然后3在除以2 结果是1 判断1是否大于0  如果大于1 在把1传进来  1对2取余 结果是1  然后1在除以2 结果是0  判断0>0  条件为假  所以推出递归
所以执行结果为011
而把toBinary2(num / 2)；放在上面  就是先递归调用最后输出  如果还不懂那就用eclipse调试吧

//首先你这个程序没写全吧
public class IntToBinaryDemo
{
        public static void main(String[] args)
        {
                int num =6;
                toBinary2(num);

        }
        public static void toBinary2(int num)
        {
                if(num>0)
                {
                        toBinary2(num/2);//6>0 调用toBinary2(num/2);
                        //3>0满足调用toBinary2,
                        //num变为1.
                        //实际
                        //打印是从1开始的 :1%2=1;3%2=1;6%2=0 =>110
                        System.out.print(num%2);
                        
                }
        }
}
第二种 ///////////////////////////
public class IntToBinaryDemo
{
        public static void main(String[] args)
        {
                int num =6;
                toBinary2(num);

        }
        public static void toBinary2(int num)
        {
                if(num>0)
                {
                        System.out.print(num%2);

                        //[1]6>0;打印6%2=0；此时
                        //[2]6执行递归操作 toBinary2 6=》3  ；3》0
                        //        打印 3%2=1
                        //[3]3执行递归操作 3=》1；
                        //        1满足》0
                        //        打印 1%2=1
                        //        即为：011

                        toBinary2(num/2);
                       
                       
                       
                }
        }
}

楼主按照下面的方式应该会更好理解

同样，如果toBinary2(num / 2);在System.out.print(num % 2);后面楼主应该可以自己推导出来吧

先求模再递归的话，和先递归再求模，明显反了啊，所以结果一定反了。

楼主看看俺画的图，上面是先打印后迭代，下面的是先迭代后打印，应该可以一目了然了

首先，你要明白递归的工作原理。
拿你的代码说吧，
public static void toBinary2(int num) {           //1

                if (num > 0) {

                        toBinary2(num / 2);              //2

                        System.out.print(num % 2);   //3
                }      
}

程序运行时，运行到 2 的时候，就又调用了 toBinary2 这个函数，3 这个语句就会先暂停，不会执行。当 2 调用的函数执行结束时，再返回到之前的程序，这样，3 语句才执行。
一层一层执行的。形象的比喻，一层一层往里走，当里面的事情都处理完后，再出来处理外面的事情。

当你把 2 3 语句调换后，每次都是先执行打印语句，再执行 2 语句调用函数，这样打印出来的数据当然是倒序的。

而正常情况下，我们算二进制的时候，都是先除完，再把结果从下往上写。


综合，2 3 语句不能调换。。