1. class Fu
   
2. {
   
3.       boolean show(char a)
   
4.       {
   
5.            System.out.println(a);
   
6.            return true;
   
7.       }
   
8. 
   
9. }
   
10. 
    
11. class Demo extends Fu
    
12. {
    
13.      public static void main(String[] args)
    
14.     {
    
15.           int i=0;
    
16.           Fu p=new Fu();
    
17.           Fu f=new Demo();
    
18.           Demo d=new Demo();
    
19.           for(f.show('A');p.show('B')&&(i<2);f.show('C'))
    
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. 
    
31. }
    

复制代码

显示的结果是：ABDCBDCB, 怎么会显示这个结果呢？

for(f.show('A');p.show('B')&&(i<2);f.show('C'))
            {
                  i++;
                 d.show('D');
            }
看这个for循环语句，在for中第一个;前的是初始化语句，在第一次循环时执行，即f.show('A');因为f是父类引用指向子类对象，所以调用了子类的show方法，但是，这句只是初始化false并没有起作用，A被打印出来。进行到第二个;前，此时p.show进行的是调用父类的方法，并返回true，调用show打印了B。而此时在&&两端都是true所以，打印for循环内的语句，输出D。之后运算第三个;前的语句，打印了C。
第二轮循环，初始化语句就跳过，所以f.show("A")被跳过。执行第二;前的语句，输出B，然后上例输出了D，C
当执行到第三轮的时候，初始化语句跳过，执行第二;前语句，输出了B，但是此时由于前两次i++，此时i已经等于2不满足于条件所以不继续运行跳出循环。
总结下来就是打印了ABDCBDCB

class Fu
{
      boolean show(char a)
      {
           System.out.println(a);
           return true;
      }

}

class Demo extends Fu
{
     public static void main(String[] args)
    {
          int i=0;
          Fu p=new Fu();//建立父类对象,
          Fu f=new Demo();//建立父类引用指向子类对象,是多态在程序中的体现形式
                  //多态中成员的特点:非静态成员方法，编译看左边，运行看右边  其他情况，编译运行都看左边
          Demo d=new Demo();//建立子类对象
          for(f.show('A');p.show('B')&&(i<2);f.show('C'))
                /*
                        1,f.show('A')运行时看等号右边,即Demo类中的show方法,打印A,返回false(初始化语句的返回没啥用)
                        2,执行判断语句,p.show('B'),父类对象直接调用父类中的show,打印B,返回true,
                        &&双与时,两边同为真,才为真,此时i=0<2,满足判断语句,执行for循环中的内容
                        3,i++,i=1,执行d.show('D');直接调用子类中的show,打印D,返回false
                        4,执行循环操作表达式f.show('C'),和第一步一样,打印C,返回false.
                        5,执行判断语句,即重复2步骤,打印B,此时i=1<2,执行for循环中的内容
                        6,执行3步骤,打印D,此时i++后,为2
                        7,重复4步骤,打印C
                        8,重复2步骤,打印B,而此时i=2不满足i<2条件,跳出循环!!
                          故:打印顺序为A,B,D,C,B,D,C,B
                         其实只要明白多态和for循环的特点,然后一步一步慢慢来就好,多态的特点前期只要记住就好,不用过深研究

                */
            {
                  i++;
                 d.show('D');
            }
    }
    boolean show(char a)
    {
          System.out.println(a);
           return false;
    }
}

• //刚乱码了 不好意思。。
• class Fu
• {
•       boolean show(char a)
•       {
•            System.out.println(a);
•            return true;
•       }
• }
• class Demo extends Fu
• {
•      public static void main(String[] args)
•     {
•           int i=0;
•           Fu p=new Fu();
•           Fu f=new Demo();//多态，运行结果看右边。
•           Demo d=new Demo();
•           for(f.show('A');p.show('B')&&(i<2);f.show('C'))//楼主应该是为什么结果没有变化的疑惑，for循环里面 p.show('B')&&(i<2) 才是判断条件的，你这代码里面条件i<2以前一直是真，结果跟正常的for循环没什么两样啊，想有变化， 只能修改  条件判断语句，  运行结果 楼上都跟你讲了，我就不多说了。。
•             {
•                   i++;
•                  d.show('D');
•             }
•     }
•     boolean show(char a)
•     {
•           System.out.println(a);
•            return false;
•     }
• }
  

在for循环语句中例如for（A；B；C)其中A一般是初始化语句因此只执行一次，C是在循环语句结束后才进行操作，B放的的判断语句，对于本题 for(f.show('A');p.show('B')&&(i<2);f.show('C')) { i++; d.show('D'); }for.show('A')先执行然后执行p.show('B')因为他的返回语句是true所以会接着进行判断i<2，下面进行循环体，i++，然后show('D'),在运行show('C');循环玩一次因为show('A')在初始化地方所以不会在执行，直接运行show('B')下面就一样了，最后一次循环完之后，接着会运行判断模块这时候打印B，但是如果把show('B')和i<2换一下位置就不会运行show('B')了。本题可以改一下把fu类中的返回值改成false结果为AB，这要用到&&的计算规律

我总觉得缺少一个判断语句

class Demo extends Fu
{
     public static void main(String[] args)
    {
          int i=0;
          Fu p=new Fu();//创建父类对象
          Fu f=new Demo();//父类的引用创建了子类对象转到for循环
          Demo d=new Demo();//子类创建了对象，转到for循环
          for(f.show('A');p.show('B')&&(i<2);f.show('C'))
            {
                  i++;//i=1;i=2//ABDCBDCB  
                 d.show('D');//第一次for循环的顺序是for(1;2;3)先执行1和2满足的话执行for循环里面的所以
                             //f.show()打印A,p.show()打印B,然后执行d.show()打印D再执行f.show()打印c
            }
    }                        //第二次循环没有f对象就不初始化不访问f.show(),访问p.show()打印B,接着访问d.show()
                             //打印D,然后访问f.show()打印C,第三次只有父类有对象,只能访问p.show();i<2不满足就不在往下执行了
    boolean show(char a)
    {
          System.out.println(a);
           return false;
    }
}

1.     for(f.show('A');p.show('B')&&(i<2);f.show('C'))
   
2.             {
   
3.                   i++;
   
4.                  d.show('D');
   
5.             }
   
6. 
   
7. /*
   
8. 假定ABCD代表for语句的4个部分。
   
9. for首先执行初始化语句 打印A
   
10. 然后执行判断语句      打印B    此时I=0
    
11. 满足条件，执行主语句  打印D
    
12. 主语句结束执行C部分   打印C
    
13. 
    
14. 开始循环 执行判断语句 打印B    此时I=1
    
15. 满足条件，执行主语句  打印D
    
16. 主语句结束执行C部分   打印C
    
17. 
    
18. 
    
19. 开始循环 执行判断语句 打印B    此时I=2
    
20. 不满足条件，for语句结束。
    
21. 
    
22. 
    
23. 显示的结果是：ABDCBDCB
    
24. */

复制代码