我写了如下一个小程序：
public class Java {
        public static void main(String[] args)
        {
                StringBuilder str = new StringBuilder();
                print(str, 4);
        }
        public static void print(StringBuilder str, int length)
        {
                StringBuilder strTemp = new StringBuilder();
                if(length == 1)
                {
                        str.append("1");
                }
                else
                {
                        length--;
                        print(str, length);
                        strTemp.append(str.toString() + length);
                        str = strTemp;
                }
                System.out.println(str);
        }
}

为什么输出结果不是 1 11 112  113 怎么能达到这种累加的输出效果，哪点出问题了

1  11  112 1123.。。。写错， 求高手进来指点啊！万分感激！

strTemp是方法内的局部变量，每个方法都有自己的strTemp。
把 strTemp.append(str.toString() + length);  改成 str.append(length);  如果想要得到你想要的结果不需要把str.toString()再append进去了。
再把str = strTemp;注释掉就可以了。

多问一句， strTemp 虽然是局部变量。可是进行了str = strTemp操作后，str不是指向strTemp所拥有的对象么？为什么不起作用？

知道为什么str = strTemp赋值不好使了，JAVA这个不能通过形参传回改变后的值。 如下例子：
public class Java{
        public static void main(String[] args)
        {
                String str = new String("HI!");
                change(str);
                System.out.println(str);
        }
        public static void change(String str)
        {
                str = new String("Hello!");
        }
}
打印结果是 HI。。。。
解决方式，可以将str不作为形参，而作为返回值传回，就OK了。
话说C++有引用可以保证修改的是 同一个， JAVA怎么做能达到这种效果。懂C++,对JAVA的变量存储便懵了。。有人解惑么

李金中 发表于 2014-2-10 13:10
知道为什么str = strTemp赋值不好使了，JAVA这个不能通过形参传回改变后的值。 如下例子：
public class Ja ...

main 里的str指向一个内存地址,这个地址存储着一个"HI!"String对象。
change 里的str也指向"HI!"所在的内存。
接者change里的str指向了另一个内存地址,这个地址存储着一个"Hello!"String对象。
所以得不到想要的结果。
你看下下面这样做就可以：
public class Java{
        public static void main(String[] args)
        {
                StringBuilder str = new StringBuilder("HI!");
                change(str);
                System.out.println(str);
        }
        public static void change(StringBuilder str)
        {
                //str = new String("Hello!");
                int len = str.length();
                str.append("Hello!");
                str.delete(0, len);
        }
}

看了你的解释，发现其实我想问的是，如果我想修改指向的 地址，该怎么做。比如：
public class JavaText{
    public static void main(String[] args)
    {
            StringBuilder str = null;
            change(str);
            System.out.println(str);
    }
    public static void change(StringBuilder str)
    {
            //str = new String("Hello!");
           // int len = str.length();
           // str.append("Hello!");
           // str.delete(0, len);
                    str = new StringBuilder("Hello");
                   
    }
}
我怎么 通过函数，使得str指向我所想要的对象，如打印”Hello“

不错

1.   public static void print(StringBuilder str, int length)
   
2.         {
   
3.                 StringBuilder strTemp = new StringBuilder();
   
4.                 if(length == 1)
   
5.                 {
   
6.                         str.append("1");
   
7.                 }
   
8.                 else
   
9.                 {
   
10.                         length--;
    
11.                         print(str, length);
    
12.                         strTemp.append(str.toString() + length);
    
13.                         str = strTemp;
    
14.                 }
    
15.                 System.out.println(str);
    
16.         }

复制代码

str = strTemp;这个赋值肯定一次都不会执行的，因为程序每次执行到 print(str, length);的时候都会跳到从头执行print方法，而print(str, length);之后的代码要等到这个递归结束后才执行，但是只要  if(length == 1)成立的话就会执行if语句里面代码，后面的else是不会执行的，所以那哥永远赋不上值...

1. public static void print(StringBuilder str, int length)
   
2.         {
   
3.                 StringBuilder strTemp = new StringBuilder();//每次递归局部变量strTemp都是一个新建的对象，里面都是空的
   
4.                 if(length == 1)
   
5.                 {
   
6.                         str.append("1");
   
7.                 }
   
8.                 else
   
9.                 {
   
10.                         length--;
    
11.                         print(str, length);
    
12.                         //运行到这里时，str.toString()都为1。没有接收到递归中因str=strTemp产生的str的变化
    
13.                         strTemp.append(str.toString() + length);//因为strTemp每次都是在上面新建的对象，都是空的，只是在这里添加了新的内容。
    
14.                         str = strTemp;
    
15.                 }
    
16.                 System.out.println(str);
    
17.         }
    
18.         //加上了返回值，使得可以接收递归中因str=strTemp产生的str的变化
    
19.         public static StringBuilder print_2(StringBuilder str, int length)
    
20.         {
    
21.                 StringBuilder strTemp = new StringBuilder();
    
22.                 if(length == 1)
    
23.                 {
    
24.                         str.append("1");
    
25.                 }
    
26.                 else
    
27.                 {
    
28.                         length--;
    
29.                         str = print_2(str, length);//接收递归中因str=strTemp产生的str的变化
    
30.                         strTemp.append(str.toString() + length);
    
31.                         str = strTemp;
    
32.                 }
    
33.                 System.out.println(str);
    
34.                 return str;
    
35.         }
    
36.         //不添加新的变量strTemp
    
37.         public static void print_3(StringBuilder str, int length)
    
38.         {
    
39.                 if(length == 1)
    
40.                 {
    
41.                         str.append("1");
    
42.                 }
    
43.                 else
    
44.                 {
    
45.                         length--;
    
46.                         print_3(str, length);
    
47.                         str.append(length);
    
48.                 }
    
49.                 System.out.println(str.toString());
    
50.         }
    
51.         //不使用递归实现
    
52.         public static void print_4(StringBuilder str, int length)
    
53.         {
    
54.                 int index = 1;
    
55.                 while(index<=length)
    
56.                 {
    
57.                         if(index==1)
    
58.                                 str.append(1);
    
59.                         else
    
60.                                 str.append(index-1);
    
61.                         System.out.println(str.toString());
    
62.                         index++;
    
63.                 }
    
64.         }

复制代码

这个问题实际上是解决另外一个问题的小问题，十分感谢，虽然我已经解决。我现在的问题实际上是7L描述的，JAVA屏蔽了指针后，我怎么达到类似对指针进行修改的问题，只能通过返回值么

眷恋之地 发表于 2014-2-11 00:06

为什么方法3中不需要返回值也可以，方法1中就不可以？

乔青山 发表于 2014-2-11 15:44
为什么方法3中不需要返回值也可以，方法1中就不可以？

因为 方法3中修改的是原个地址指向的内容。。。所以，再去取的话，就是修改后的了

李金中 发表于 2014-2-10 20:15
看了你的解释，发现其实我想问的是，如果我想修改指向的 地址，该怎么做。比如：
public class JavaText{
  ...

你也说了，我认为只有通过返回值了