我们都知道，子类可以覆盖父类中的函数
我想知道，父类中在成员位置上定义了一个内部类，我子类继承后能覆盖此内部类吗？为什么？

1.父类中在成员位置上定义了一个内部类，相当于这个类的一个成员变量 。子类可以覆盖  。代码为证
class Out{
       
        class Inner{
                void print(){
                       
                       
                        System.out.println("i anm inner1");
                }
               
        }
       
}


class Out2 extends Out{
       
       
        class Inner{
                void print(){
                       
                       
                        System.out.println("i anm inner2");
                }
               
        }
}

public class Test {

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                        new Out2().new Inner().print(); // 打印 i anm inner2
        }

}

// 父类
class Fu{
        class T_1{                                        //定义一个内部类T1
                public void run(){                        //内部类中有run方法
                        System.out.println("Fu");
                }
        }
}
//子类
class Zi extends Fu{                                //子类继承父类
        class T_1{                                        //覆写其父类的内部类
                public void run1(){                //注意：为了做一点改变，特意让子类内部类中的方法名为run1
                        System.out.println("Zi");
                }
        }
}
//主函数
class Test{

        public static void main(String[] args){
                Zi z = new Zi();                                        //创建子类对象
                z.new T_1().run1();                                //调用子类对象中内部类的run1方法，编译通过
        }                                                              //输出结果为   “Zi”
}

由此可以看出，不管是什么样的类型，只要在类中声明，那么他就是该类的成员。

如果是静态的可以覆盖吗，在局部的内部类，如果有静态的属性，和方法，这是不能被覆写的， 只有在成员位置上而且都要有public 修饰

父类内部类是静态的也可以覆盖。

1. class OuterClass1
   
2. {
   
3.         private        int a = 10;
   
4.         static        class Inner
   
5.         {
   
6.                 private int a = 20;
   
7.                 private int b = 5;
   
8.                 void one(){
   
9.                         System.out.println(b);
   
10.                         System.out.println(a);
    
11.                         System.out.println(this.a);
    
12.                 }       
    
13.         }
    
14.         void test(){
    
15.                 Inner i = new Inner();
    
16.                 i.one();       
    
17.         }
    
18. }
    
19. 
    
20. class OuterClass2 extends OuterClass1
    
21. {       
    
22.         static        int b = 100;
    
23.         static        class Inner
    
24.         {
    
25.                 void one(){
    
26.                
    
27.                         System.out.println("b = "+ b);
    
28.                 }
    
29.         }
    
30.         void test(){
    
31.                 //Inner i = new Inner();
    
32.                 new Inner().one();       
    
33.         }
    
34. }
    
35. 
    
36. class TestInner{
    
37.         public static void main(String[] args){
    
38.                 new OuterClass2().test();
    
39.                 new OuterClass().test();
    
40.                 //OuterClass.Inner i = new OuterClass().new Inner();
    
41.                 //i.one();
    
42.                 //OuterClass.Inner i = new OuterClass.Inner();
    
43.                
    
44.                 //i.one();
    
45.         }
    
46. }
    

复制代码