class LianXi
{
        public static void main(String[] args)
        {
                for(int count=0; count<10;count++)
                        {
                        System.out.println(count);
                        count*=0.1;
                        }
                        System.out.println("over");
               
        }
}
==================================

class LianXi
{
        public static void main(String[] args)
        {      int count;
                for(count=0; count<10;count++)
                        {
                        System.out.println(count);
                        }
                count*=0.1;
                        System.out.println("over");
               
        }
}
第一种情况为什么会出现死循环呢？？它与第二种情况有什么区别吗？请详细说明一下！谢谢

第一种情况：
class LianXi
{
        public static void main(String[] args)
        {
                for(int count=0; count<10;count++)
                        {
                        System.out.println(count);
                        count*=0.1;
                        }
                        System.out.println("over");
               
        }
}
首先，这是一个很低级的错误，楼主在循环体内修改了循环变量 count 的值
在编程时，在循环体内应用循环变量的值，本身就是编程的大忌
count*=0.1; 使循环变量的值无限趋于0 它永远不会满足<10的条件，所以是死循环；

第二种情况：
class LianXi
{
        public static void main(String[] args)
        {      int count;
                for(count=0; count<10;count++)
                        {
                        System.out.println(count);
                        }
                count*=0.1;
                        System.out.println("over");
               
        }
}
很明显 楼主意识到刚才第一种情况的问题，将循环变量改在循环体外引用
上述循环才可以顺利运行；
另外在提醒一下楼主，如果循环变量的值是在for循环结构头部初始化部分定义的
不管在循环体内，还是循环体外，都不要引用循环变量的值
因为这样在循环体外引用循环变量的值是语法错误

1. class LianXi
   
2. {
   
3.          public static void main(String[] args)
   
4.         {
   
5.                  for(int count=0; count<10;count++)
   
6.                          {
   
7.                          System.out.println(count);
   
8.                          count*=0.1;//count=count*0.1;你在循环内部让count的值乘以0.1再赋给count,那么count的值永远小于10，当然会出现死循环
   
9.                          }
   
10.                          System.out.println("over");
    
11.                  
    
12.         }
    
13. }
    
14. class LianXi
    
15. {
    
16.          public static void main(String[] args)
    
17.         {      int count;
    
18.                  for(count=0; count<10;count++)
    
19.                          {
    
20.                          System.out.println(count);
    
21.                          }
    
22.                  count*=0.1; //这个放在循环的外面，对循环里的count值没有影响，循环可以正常的转圈，转完，over.
    
23.                         System.out.println("over");
    
24.                  
    
25.         }
    
26. }

复制代码

第一种情况是因为count*=0.1;语句在影响count的值，导致了无限循环的出现。第二种情况count*=0.1;语句在for循环的外面，影响不了循环里的count值，所以循环可以正常运行然后输出结果，最后打印over。

焦晨光 发表于 2012-7-21 09:18
第一种情况：
class LianXi
{

那你能具体说一下，第一种情况的它是怎么进行循环的吗？能不能具体一点？？谢谢:)

class LianXi
{
        public static void main(String[] args)
        {
                for(int count=0; count<10;count++)
                        {
                        System.out.println(count);
                        //count*=0.1;  //注意这里：count是for循环变量，所以你不可以在for循环内，给count赋值运算。否则，会出问题；
      int b=(int)(count * 0.1); //count*=0.1;相当于int b=(int)(count * 0.1)
      System.out.println(b);  //输出一下b的结果，更清楚
      System.out.println();
                        }
                        System.out.println("over");
               
        }
}
/*
class LianXi
{
        public static void main(String[] args)
        {      int count;      //这里定义了没有初始值的整型变量
                for(count=0; count<10;count++) //这里是给count赋值为0，作为循环变量                        
                       {
                        System.out.println(count);
                        }
                count*=0.1; //这里会得到上面for循环十次以后，count的值9，然后做赋值运算
                        System.out.println("over");
        }
}
*/

class LianXi
{
        public static void main(String[] args)
        {
                for(int count=0; count<10;count++)
                        {
                        System.out.println(count);
                        count*=0.1;
//第一次执行到循环体时，count=0，执行count*=0.1后，运算结果为count=0*0.1=0，然后执行count++，count=1
//第二次进入循环，count=1，执行count*=0.1后，运算结果为count=1*0.1=0.1，但是count是int型，所以会舍掉末尾的.1，即count=0(死循环的关键就在这里了)，然后执行count++, count=1
//再往后的循环就不断重复第二步
                        }
                        System.out.println("over");

        }
}

1. class LianXi
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 for(int count=0; count<10;count++)
   
6.                         {
   
7.                         System.out.println(count);
   
8.                         count*=0.1;
   
9.                         }
   
10.                         System.out.println("over");
    
11.                
    
12.         }
    
13. }
    

复制代码

第二段代码

1. class LianXi
   
2. {
   
3.         public static void main(String[] args)
   
4.         {      int count;
   
5.                 for(count=0; count<10;count++)
   
6.                         {
   
7.                         System.out.println(count);
   
8.                         }
   
9.                 count*=0.1;
   
10.                         System.out.println("over");
    
11.                
    
12.         }
    
13. }
    

复制代码

这一段代码里   count*=0.1;
是死循环的原因  ; count*=0.1;等价于 count=count*0.1;
就是说 count 的值只会 是0*0.1*0.1*0.1..........
再者.........

你的count 的初始值是0......
0乘以任何都为0
不会超过for的条件
count<10

第二段里
你的 count*=0.1;
虽然运算了 但是没有进行输出  这条语句是在for循环之外的
但是你的输出语句是在for循环内部的


如果你想让for 打印count的数值
我帮你把代码改了  增加了一个sum记录

1. class LianXi
   
2. {
   
3. public static void main(String[] args)
   
4. {
   
5. for(int count=0; count<10;count++)
   
6. {
   
7. double sum=count;
   
8. sum*=0.1;
   
9. System.out.println(sum);
   
10. }
    
11. System.out.println("over");
    
12. 
    
13. }
    
14. }
    

复制代码

希望对你有帮助

007lzg 发表于 2012-7-21 09:33
那你能具体说一下，第一种情况的它是怎么进行循环的吗？能不能具体一点？？谢谢 ...

for(int count=0; count<10;count++)
                {
                System.out.println(count);  //第一次为0
                count*=0.1;   //等价  count=(int) (count*0.1);
                //count*=0.1后仍为0
                //进行第二次循环count++，现在count为1
                //System.out.println(count);  输出为1,
               //count=(int) (count*0.1);  这句是关键，1*0.1后强转为int类型,所以count为0
              //以上就是循环的整个过程，输出结果为01111111111111111111....
             //所以是个死循环
                }
                System.out.println("over");//这句永远不会执行
             }

程潇 发表于 2012-7-21 09:58
class LianXi
{
        public static void main(String[] args)

谢谢，讲的非常明白！:victory:

应文 发表于 2012-7-21 09:49
class LianXi
{
        public static void main(String[] args)

谢谢，现在也终于明白了！:)

1. class LianXi
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 for(int count=0; count<10;count++)
   
6.                         {
   
7.                         System.out.println(count);
   
8.                         count*=0.1;
   
9.                         }
   
10.                         System.out.println("over");
    
11.                
    
12.         }
    
13. }

复制代码

在count*=0.1;这一句，你的count会永远等于0，原因如下：
第一次 count++   -->  count=1,然后count*=0.1  -->count=(int)0.1 -->count=0;
第二次 count++   -->  count=1,然后count*=0.1  -->count=(int)0.1 -->count=0; //因为你的count定义为int型，所以count永远为0，后面无限循环，无法跳出。
如果count*=0.1放在循环体外边的话就不会有这种情况