这里的for循环条件的执行顺序是怎样的？懂for(int x=0;x<5;x++)这种类型的，不过这个看着很迷糊，最后打印了A,B。

1. package com.itcast.deepStudy;
   
2. 
   
3. 
   
4. class Fu{
   
5.         boolean show(char a)
   
6.         {
   
7.                 System.out.println(a);
   
8.                 return true;
   
9.         }
   
10. }
    
11. public class Demo extends Fu
    
12. {
    
13.         public static void main(String[] args)
    
14.         {
    
15.                 int i=0;
    
16.                 Fu f = new Demo();
    
17.                 Demo d = new Demo();
    
18.                 for(f.show('A');f.show('B')&&(i<2);f.show('C'))
    
19.                         //for(int x=0;x<5;x++)
    
20.                 {
    
21.                         i++;
    
22.                         d.show('D');
    
23.                 }
    
24.         }
    
25.         boolean show(char a)
    
26.         {
    
27.                 System.out.println(a);
    
28.                 return false;
    
29.         }
    
30. }

复制代码

第一个条件false后执行了第二个条件，第二个条件false了就不执行第三个条件了，新手求解释，毕老师讲的没听懂。

因为第三次运行时i自增到2不满足条件i<2了，所以就不执行了
for(f.show('A');f.show('B')&&(i<2);f.show('C'))

package com.itcast.deepStudy;


class Fu{
        boolean show(char a)
        {
                System.out.println(a);
                return true;
        }
}
public class Demo extends Fu
{
        public static void main(String[] args)
        {
                int i=0;
                Fu f = new Demo();
                Demo d = new Demo();
                for(f.show('A');f.show('B')&&(i<2);f.show('C'))   //因为逻辑运算符&&，具有短路功能，所以只要有一项不符合要求，即从当前判断条件中断，右面的判断条件不在执行
                        //for(int x=0;x<5;x++)
                {
                        i++;
                        d.show('D');
                }
        }
        boolean show(char a)
        {
                System.out.println(a);
                return false;
        }
}

shaohuashang 发表于 2012-9-18 09:43
因为第三次运行时i自增到2不满足条件i

既然自增的话，会调用到d.show('D');的吧，但没打印呢，for内的代码块好像没执行到。

不好意思，是我看错题了

这是一个多态的问题也即Fu f = new Demo();

                                      Demo d = new Demo();
多态非静态成员函数的特点是：
编译看左边，运行看右边
多态静态成员函数的特点是：
编译和运行都看左边

多态中，成员变量无论是编译和运行都要参考左边（即引用变量所属的类）
上面的题目：
首先要明白 for(f.show('A');f.show('B')&&(i<2);f.show('C'))
这个语句用的&&说明，
我们知道&&和&的区别是如果判断&&左边为假，则后面就不会运行
而&需要两边都要执行
（1）读f.show('A')非静态的，编译看左边，运行看右边，则运行Demo()中的show方法，
         打印A  返回false
（2）读f.show('B')是非静态的，还是运行Demo()中的show方法，
         故打印B  返回false
（3）&&两个false，则为false，故左边（i<2）和f.show('c')不执行，for循环结束
所以打印结果为''A''B'

武庆东 发表于 2012-9-18 09:53
package com.itcast.deepStudy;

了解了，原来短路了，谢谢啊。

首先在Demo继承Fu的时候，他覆写了Fu的show方法。
f对象的创建是一个多态的应用。
他的show方法应该是Demo的方法。即返回值为false。

• for(f.show('A');/*这里打印的是A,返回值为false但是没用作用*/  f.show('B')/*这里打印的是B，返回值为false，跳出循环*/&&(i<2);f.show('C'))
•                         //for(int x=0;x<5;x++)
•                 {
•                         i++;
•                         d.show('D');
•                 }
  
  

吴通 发表于 2012-9-18 10:06
这是一个多态的问题也即Fu f = new Demo();

                                      Demo d = new Demo(); ...

看你的贴总能学到很多 呵呵

class Fu{
        boolean show(char a)
        {
                System.out.println(a);
                               System.out.println("Fu中的Show"); //测试Fu中的show方法
                return true;
        }
}
public class Demo extends Fu
{
        public static void main(String[] args)
        {
                int i=0;
                Fu f = new Demo();  //这是多态：父类或者接口的引用指向了自己的子类对象。
                Demo d = new Demo();
                for(f.show('A');f.show('B')&&(i<2);f.show('C'))
                        //for(int x=0;x<5;x++)
                {
                        i++;
                        d.show('D');
                }
        }
        boolean show(char a)
        {
                System.out.println(a);
                                 System.out.println("Demo中的Show");//测试Demo中的show方法
                return false;
        }
}

这里要说明几点：
1、对于分析此类子父类继承，并有多态的程序的时候，我们可以添加一条打印语句进行区分，这样就可以清晰的分析程序运行的顺序。
     输出结果：
     A
     Demo中的Show
     B
     Demo中的Show
     这里可以看到，程序调用了两次show方法，而且都是Demo中的Show方法。这是因为子类覆盖了父类中的show方法
     
2、多态调用中，简单描述子父类中成员特点：

      成员变量：对于成员变量在多态调用时，编译和运行都看等号左边。

      成员函数：对于成员函数在多态调用时，编译看左边，运行看右边（ 因为在子父类中，成员函数有覆盖的特性）。在本题中用到这条

      静态函数：对于静态函数在多态调用时，编译和运行都看等号左边。

3、需要了解&&运算符的特点： 会产生短路情况，如果可以通过左边表达式得到最终结果，右边就不会在运算。例如：A&&B  如果A为true，则B运算；如果A为false，整个表达式的结果就为False，则B不运算。

综合上述分析，我们可以推出整个程序运行的顺序：
for(f.show('A');f.show('B')&&(i<2);f.show('C'))
(1)执行初始化条件：f.show('A')   子类覆盖父类的方法，则输出A，并打印 Demo中的Show，返回false
     执行完后，变成：for（false;f.show('B')&&(i<2);f.show('C'))
(2)执行循环条件：f.show('B')&&(i<2);     因为是&&，先看左边f.show('B'），子类覆盖父类的方法，则输出B，并打印 Demo中的Show，返回false ；此时整个表达式为false，不运行右边
       的（i<2）。整个循环结束

f.show('B')调用的是Demo()中的show方法，结果flase，条件不成立，所以。。。

都是前辈，受教了！{:soso_e183:}