问题已经解决
练习写了个小程序，发现了一个不能解决的错误，喜欢老少爷们儿们能够帮小弟一把。{:soso_e183:}。
class Outer
{
       int a=90;
       public abstract class InnerAbs
      {
            int b=80;
            abstract void inAbs();
      }
}
class AA extends Outer.InnerAbs
{
      void inAbs()
     {
           System.out.println("AA……inAbs");
     }
}
class Main
{
      public static void main(String[] args)
      {

      }
}
---------- javac ----------
Main.java:11: 错误: 需要包含Outer.InnerAbs的封闭实例
class AA extends Outer.InnerAbs
^
1 个错误
为什么会产生这样的错误？
能不能修改这个错误，同时还能保证AA能够继承Outer.InnerAbs ？

佟都 发表于 2012-8-6 23:09
---------- javac ----------
Main.java:11: 错误: 需要包含Outer.InnerAbs的封闭实例
class AA extends Ou ...

哇塞！ 这位兄弟好强悍哦，学这么长时间java了 我还是头一次见这么调用super语句的  out.super();   呵呵呵呵 受教了 受教了 佩服佩服啊！你解释的也很清楚，给你点金币花花吧  谢谢！

---------- javac ----------
Main.java:11: 错误: 需要包含Outer.InnerAbs的封闭实例
class AA extends Outer.InnerAbs
^
1 个错误
为什么会产生这样的错误？
能不能修改这个错误，同时还能保证AA能够继承Outer.InnerAbs ？
-----------------------------

编译器的意思是：要创建Outer.InnerAbs的子类对象必须保留一个外部类的引用。

原理如下：
当创建一个子类时，子类构造函数总会调用父类的构造函数，因此在创建
非静态内部类的子类时，必须保证让子类构造函数可以调用非静态内部类
的构造函数，调用非静态内部类的构造函数时，必须存在一个外部类对象，
因为当调用非静态内部类的实例方法时，必须有一个非静态内部类实例，
而非静态内部类实例必须寄存在外部内实例里。

代码可以修改如下：
class Outer
{
       int a=90;
       public abstract class InnerAbs
       {
             int b=80;
             abstract void inAbs();
       }
}

class AA extends Outer.InnerAbs
{
      //显式定义AA（非静态内部类子类）的构造函数
      AA(Outer out)
      {
         out.super();
      }

      void inAbs()
      {
            System.out.println("AA……inAbs");
      }
}

class Main
{
      public static void main(String[] args)
      {
            Outer out = new Outer();
            //非静态内部类子类的创建
            AA aa = new AA(out);
            aa.inAbs();
      }
}

问题已经解决

周坤 发表于 2012-8-6 00:44
class Outer
{
        int a=90;

也就是说 在其他外部类中使用一个非静态的内部类，必须要创建这个内部类对应的外部类的对象！ 原来如此，明白了。

1. public static abstract class InnerAbs

复制代码

楼主你看漏了哦，，这里加了static,,然后就可以在主函数里new对象了。

class Outer
{
        int a=90;
        public abstract class InnerAbs
       {
             int b=80;
             abstract void inAbs();
       }
}
class AA extends Outer.InnerAbs //InnerAbs内部类，为外部类Outer的一个成员属性，随着对象的创建而加载，不能直接调用内部类，要调用只能new Outer().InnerAbs。要想继承的话，只能把内部类改成静态内部类，public static abstract class InnerAbs{}，此时对着类的加载而加载。
{
       void inAbs()
      {
            System.out.println("AA……inAbs");
      }
}
class Main
{
       public static void main(String[] args)
       {

       }
}
不过，静态内部类要遵循静态内部类的条件，即该静态内部类只能直接访问外部类中的静态成员了

外部类不能访问内部类 的  把内部类 静态就可以解决啦

abstract class Outer
{
       int a=90;
       public static abstract class InnerAbs
      {
            int b=80;
            abstract void inAbs();
      }
}
class AA extends Outer.InnerAbs
{
      void inAbs()
     {
           System.out.println("AA……inAbs");
     }
}
class Main
{
      public static void main(String[] args)
      {
                new AA().inAbs();
      }
}

牛杨 发表于 2012-8-6 00:32
兄弟 只是在主函数里面定义个匿名对象，我刚才试了试好像不行啊？

public static abstract class InnerAbs

黑马振鹏 发表于 2012-8-6 00:28

兄弟 只是在主函数里面定义个匿名对象，我刚才试了试好像不行啊？

1. class Outer1
   
2. {
   
3.        int a=90;
   
4.        public static abstract class InnerAbs
   
5.        {
   
6.              int b=80;
   
7.              abstract void inAbs();
   
8.        }
   
9. 
   
10. }
    
11. class AA extends Outer1.InnerAbs
    
12. {
    
13.       void inAbs()
    
14.      {
    
15.            System.out.println("AA……inAbs");
    
16.      }
    
17. }
    
18. class Main
    
19. {
    
20.       public static void main(String[] args)
    
21.       {
    
22.               new AA();
    
23. 
    
24.       }
    
25. }

复制代码