4.
写出程序结果       
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 f=new Demo();
                Demo d=new Demo();
                for(f.show('A'); f.show('B')&&(i<2);f.show('C'))
                {
                        i++;
                        d.show('D');
                }       
        }
        boolean show(char a)
        {
                System.out.println(a);
                return false;
        }
}
A B

因为你子类Demo对父类Fu的方法show（）重写了，
所以再for里面f.show（'A'）的结果是 A 和false
同样          f.show（'B'）的结果也是B 和false
            而for的条件中就变成false&&i<2的是false，所以循环体不执行

最终答案就A   B

对啊，就是 A B
你执行到 for(f.show('A'); f.show('B')&&(i<2);f.show('C')) 开始有输出
先执行初始化语句 f.show('A'); 输出 A ，而 f.show('A') = false, (f指向的是子类对象，show()被重写，返回值是 boolean 型变量 false)
然后执行判断 f.show('B')&&(i<2); 先输出 B , 而 f.show('B') = false,
所以判断语句的结果是 false ,退出循环，执行主程序隐藏的 return; ，程序结束
结果输出就是 A B

for(f.show('A'); f.show('B')&&(i<2);f.show('C'))
f.show('A')  ,f调用的是Demo自己的show方法，打印A,返回false
f.show('B')，f调用的仍然是Demo自己show方法，打印B,返回false，因为两个布尔表达式用&&连接，&&属于短路与符号，所以并不会执行后面的语句，for循环里面的语句也不会执行，所以最终输出的是AB

class Fu
{
        boolean show(char a)
        {
                System.out.println(a);
                return true;
        }
}
class Demo extends Fu //Demo继承了Fu类，并复写了Fu类的show方法
{
        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'))
                {
                        i++;
                        d.show('D');
                }        
        }
        boolean show(char a)  //复写了父类的show方法
        {
                System.out.println(a);
                return false;
        }
}

分析：
1、f其实指向了一个Demo对象，所以其show方法其实调用的是Demo类中的show方法，返回的是true。
2、要明确for循环的执行顺序：
     for（A ； B ； C）
     {   D；     }
     执行的顺序是：A-->判断B条件是否满足--->（如果满足）D-->C-->再判断B--->（如果满足）D-->C-->。。。。再判断B--->（如果不满足）退出循环
3、按照2中所叙的顺序进行分析。
①执行f.show('A')，输出A；
②执行f.show('B') ，输出B，但是注意，此时这个f.show方法调用的是Demo类的show方法，返回了false。
③根据&&的短路规则，由于&&左边的f,show('B')返回了false，整个条件表达式结果为false，即条件不满足，退出for循环。

程序的执行顺序就是这样啦。希望能够帮到你哟。

楼上说得没错，就是"父类引用指向子类对象"，父类那个show方法根本没用到。
楼主你把下面的程序复制到你的IDE运行一下就好理解了。

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

复制代码

这个很简单啊，只要理解循环体执行顺序，一步一步看，就会得到答案的；
for(A;B;C)假设这三个表达式，A--〉B--〉循环体--〉C--〉B--〉循环体--〉C--
头两步执行完，判断为条件判断为false，循环体不执行，所以输出A  B

程序运行到for时，f.show('A')调用的子类的show方法所以第一个输出A，返回false。然后运行f.show('B')，也是调用子类的show方法，输出B，返回false。
这时由于for不满足条件了所以会退出for循环，程序结束

版主为什么还不来给我加技术分啊，我是第一个回答对的啊:(

for(f.show('A'); f.show('B')&&(i<2);f.show('C'))
                {
                        i++;
                        d.show('D');
                }  
f.show('A');  调用
        boolean show(char a)
        {
                System.out.println(a);    //打印A  并且返回false。
                return false;   
        }
f.show('B'); 调用
        boolean show(char a)
        {
                System.out.println(a); //打印B，返回false。判断表达式为假，循环体不执行。
                return false;              //所以执行结果是 A  B
        }

哈哈，你们都感谢我吧，是我给版主留言 进来看的，

代码中 Fu f = new Demo()父类引用指向了子类对象，当你调用某个方法时它会先在子类中寻找，没有的话才去父类中寻找。因为你在子类中重写了父类中的show方法，所以你调用的都是子类中的show方法。
for(f.show('A'); f.show('B')&&(i<2);f.show('C'))这段代码执行的结果就是输出A，返回false；输出B，返回false；f.show('B')&&(i<2)的结果是false，所以for循环结束。

此代码主要考点在多态和运算符上。首先Demo继承Fu类，对象f是Fu类引用子类Demo的实例，当调用方法时，是调用子类Demo中的方法，所以结果是A，false；for循环中，f.show("B")结果也是B，false，而&&运算符，只要一边是false，则结果是false，所以for循环中for(false,false),循环不会被执行，程序运行结束，所以最终输出结果是：
A
B