既然内部类是外部类的成员变量，那么是否可以为外部类定义子类，在子类中在定义一个内部类来重写父类中的内部类？

可以.
package com.ccsu.xie.test;

import com.ccsu.xie.test.Outer2.Inner;

public class OuterTest{
        public static void main(String[] args) throws Exception{
                        Outer.Inner inner1 = new Outer().new Inner();
                        inner1.innerMethod("Father method");
                       
                        Outer2.Inner inner2 = new Outer2().new Inner();
                        inner2.innerMethod("Son Method");
                       
        }

}

class Outer {

        class Inner {
                public void innerMethod(String str) {
                        System.out.println(str);
                }

        }
}
class Outer2 extends Outer {
        class Inner {
                public void innerMethod(String str) {
                        System.out.println(str);
                }
        }

}

谢达 发表于 2013-4-8 09:00
可以.
package com.ccsu.xie.test;

代码最好加上相应的注释，会清晰些，谢谢

黄玉昆 发表于 2013-4-8 09:02
代码最好加上相应的注释，会清晰些，谢谢

好的...下次注意

应该可以的

1. class A
   
2. {
   
3.         public class B
   
4.         {
   
5.                 public void show(){
   
6.                         System.out.println("我是父类的classB");
   
7.                 }
   
8.         }
   
9.         public void fashow(){
   
10.                 new B().show();
    
11.         }
    
12. }
    
13. class C extends A
    
14. {
    
15.         public class B
    
16.         {
    
17.                 public void show(){
    
18.                         System.out.println("我是子类的classB");
    
19.                 }
    
20.         }
    
21.         public void fashow(){
    
22.                 new B().show();
    
23.         }
    
24. }
    
25. class Demo
    
26. {
    
27.         public static void main(String []args){
    
28.                 C a = new C();
    
29.                 a.fashow();
    
30.                 A b = new C();
    
31.                 b.fashow();
    
32.         }
    
33. }

复制代码

如果问题未解决，请继续追问，如果没有问题了，请将帖子分类 改为“已解决”，谢谢

我觉得,这跟子类中出现和父类同名的同类型成员变量是一个情况,应该不能覆盖.借楼上那位代码一用 稍作修改

1. class A
   
2. {
   
3.         public class B
   
4.         {
   
5.                 public void show(){
   
6.                         System.out.println("我是父类的classB");
   
7.                 }
   
8.         }
   
9.         //我把那个fashow()方法去掉了.直接在main中创建B的实例然后调用show方法.
   
10.         //用fashow的话,我觉得必然会先从本类成员B去创建实例,会产生误解,无法判断是否覆盖.
    
11.         //因为父类子类都有Class B.而fashow()方法也被复写了.
    
12. }
    
13. class C extends A
    
14. {               
    
15.         public class B
    
16.         {
    
17.                 public void show(){
    
18.                         System.out.println("我是子类的classB");
    
19.                 }
    
20.         }
    
21. }
    
22. class Demo2
    
23. {
    
24.         public static void main(String []args){
    
25.                 C a = new C();//声明为C子类类型
    
26.                 a.new B().show();
    
27.                 A b = new C();//声明为A父类类型
    
28.                 b.new B().show();
    
29.                 //那么编译器会优先从声明的类型去调用成员.
    
30.         }
    
31. }

复制代码

结果如下