这点跟在第二种说法的理解是不谋而合的。

那么，问题二：

另附上文章证明：

第三点：内部类的继承

来看一个案例，如下一个外部类以及内部类：

package com.ee.niminglei;//外部类public class OutClass {
            //    内部类    public class InnerClass{
            //        内部类的公有方法        public void innerMethod(){
                        System.out.println("this is inner publicClassMethod");        }//        内部类的私有方法        private void innerMethod2(){
                        System.out.println("this is inner privateClassMethod");        }    }}

另外一个类ExtendsFromInner继承这个内部类，如下：

No enclosing instance of type ‘com.ee.niminglei.OutClass’ is in scope

没有封闭实例在com.ee.niminglei.OutClass的范围内。

那么为什么会有这个报错呢？

继承自内部类时，使用默认的构造器会报错，因为内部类会默认的获得指向其外部类对象的引用，所以继承内部类时应该在构造器参数中传递一个其外部类对象的引用（编译器要求你一定要这样做），然后在构造器中使用该外部类对象引用的super方法（该super方法调用的是这个外部类对象的内部类的构造方法）

所以，依据这个原因，如此做就不会报错了，如下：

所以得出结论是：

番外

在查看这篇文章的时候，提到了一个问题：

到一个外部类继承自另一个含有内部类的父类。然后在该类中重写了父类的内部类，这个时候会怎么样呢？父类的内部类会被覆盖吗？

来看一组代码：

package com.ee.niminglei;//外部类public class OutClass {
                public OutClass() {
                    System.out.println("这是外部类OutClass的构造函数");    }    //    内部类    public class InnerClass{
                    public InnerClass() {
                        System.out.println("这是内部类InnerClass的构造函数");        }    }}

有一个类继承该类，重写该类的内部类，如下：

package com.ee.niminglei;public class ExtendsFromInner extends OutClass {
                //    这个是重写父类的内部类构造方法    public class InnerClass{
                    public InnerClass() {
                        System.out.println("这个是重写父类OutClass的内部类InnerClass的构造函数");        }    }    public static void main(String[] args) {
                    new ExtendsFromInner();    }}

运行之后如下：

其实这同样是论证了内部类是一个独立的类。

第四点：内部类的使用场景

隐藏某些实现、多继承、单元测试、闭包问题（即如果一个类继承了某个父类，这个类还想实现一个接口，但是父类和这接口有些方法或属性有冲突，想把父类和接口的功能都保留下来，那么，就可以用内部类来配合，用接口加内部类来实现闭包）

也就是为类的多态提供了另一个延展。

参考

其它

一篇详谈内部类，如下：

匿名内部类

参考：

看一个小案例；

package com.ee.nimingnblei;public abstract class Person {
                public abstract void eat();}

然后有一个类继承了这个抽象类，如下：

package com.ee.nimingnblei;public class Child extends Person {
                @Override    public void eat() {
                    System.out.println("child eat something");    }}

运行这个实现类中的方法。

package com.ee.nimingnblei;public class Test {
                public static void main(String[] args) {
                    Person person=new Child();        person.eat();    }}

结果为：

这是一个很常见的处理手段，也就是当要实现一个抽象类的时候，我们就需要继承它，并且实现。

在这个时候，也就出现了匿名内部类。

package com.ee.nimingnblei;public class Test {
                public static void main(String[] args) {
            //        匿名内部类的基本使用        Person person=new Person(){
                        @Override            public void eat() {
                            System.out.println("匿名child eat something");            }        };        person.eat();    }}

运行如下：

除了抽象类，其接口也可以也能如此。

package com.ee.nimingnblei;public interface Animal {
                public void eat();}

同时，直接使用内部类实现这个方法，如下：

package com.ee.nimingnblei;public class Test {
                public static void main(String[] args) {
            //        匿名内部类的接口使用        Animal animal=new Animal() {
                        @Override            public void eat() {
                            System.out.println("匿名animal eat something");            }        };        animal.eat();    }}

运行结果为：

这两段匿名类的方法，在我自己的印象里面用的最多的就是在线程类Thread中了。这里就不讨论其写法了。

总结

参考：

通过上面的例子，我们可以得出以下结论：

1.匿名内部类适用某个接口或抽象类中的方法只使用一次，而多创建一个类的场景；简化了代码。

2.匿名内部类看似是使用了一个大括号{}来代替一个类。然鹅，从反编译中可以看到，实际上运行的时候java仍然会生成唯一的类名，并且仍然是一个内部类，因为仍然具有内部类的继承相同的做法。（内部类的继承总结）。

匿名内部类的理解

在这篇文章中有提到关于这个匿名内部类的使用问题。

请看一个案例，如下：

为什么不能调用匿名内部类中自己的方法呢？

其实匿名内部类连名字都没有，你咋实例对象去调用它的方法呢？但继承父类的方法和实现的方法是可以正常调用的。

因而言，这里就出现了两种解决方式。

2.直接在大括号后面使用点调用，也就是这样：

从上面解决调用匿名内部类方法的方式，我们能够知道作为一个匿名内部类其本身的类名都是匿名的，那么其对象更加是匿名的。所以每一次创建匿名内部类都只是创建了所继承的父类或者实现的接口对象，而不是匿名内部类本身的对象。

对于匿名内部类本身的对象，我们只是知道其存在，却不晓得其具体。诶，这就跟我们面向对象的思想不谋而合了，晓得其抽象不知具体。