看了视频后，弄不太明白为什么要用内部类的问题，既然一般来说内部类继承自某个类或实现某个接口。
那为什么不直接在外部类直接引用接口。内部类实现一个接口与外围类实现这个接口有什么区别。

每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。内部类使得多重继承的解决方案变得完整，接口解决了部分问题，而内部类有效地实现了“多重继承”。

如果直接在外部类引用接口能满足需求时，那么就应该这样做。两者区别在于：后者不是总能享用
到接口带来的方便。
内部类最吸引人的地方在于：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了
某个（接口的）实现，对于内部类都没有影响。

内部类使得多重继承的解决方案更加完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。也就是说，
内部类允许继承多个非接口类型（类或抽象类）。
一个实现多重继承类的例子代码如下：

1. // 举个例子：
   
2. // 有两个这样类D和E
   
3. class D {
   
4. }
   
5. 
   
6. abstract class E {
   
7. }
   
8. 
   
9. // 我要建一个类Z实现多重继承类D和类E
   
10. // 只有采用内部类的方式：
    
11. // 如：
    
12. class Z extends D {
    
13.         E makeE() {
    
14.                 return new E() {
    
15.                 };
    
16.         }
    
17. }
    
18. 
    
19. // 调用内部类
    
20. public class Test {
    
21.         static void takesD(D d){}
    
22.         static void takesE(E e){}
    
23.         public static void main(String[] args) {
    
24.                 Z z=new Z();
    
25.                 takesD(z);
    
26.                 takesE(z.makeE());               
    
27.         }
    
28. }

复制代码

内部类还有一些其它特性:
1.内部类可以有多个实例,每个实例都有自己的状态信息,并且与外围类对象的信息相互独立.
2.在外围类中,可以让多个内部类以不同方式实现同一个接口.
3.创建内部类对象的时刻并不依赖于外围类对象的创建.
4.内部类并没有令人迷惑的“is-a”关系；它就是一个独立的尸体。

以上解释参考于Bruce Eckel著的《java编程思想》（thinking in java）的说法。

希望这些对你有所帮助。{:soso_e104:}

内部类实现一个接口与外围类实现这个接口有什么区别如下：

后者不是总能享用到接口带来的方便，有时需要用到接口的实现。



   所以，使用内部类最吸引人的原因是：每个内部类都能独立地继承自一个(接口的)实现，所以无论外围类是否已经继承了某个(接口的)实现，对于内部类都没有影响。



   如果没有内部类提供的、可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。





   从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。


   也就是说，内部类允许继承多个非接口类型(译注：类或抽象类)。


   为了看到更多的细节，让我们考虑这样一种情形：即必须在一个类中以某种方式实现两个接口。



   由于接口的灵活性，您有两种选择：使用单一类，或者使用内部类：


   //: innerclasses/MultiInterfaces.java
   // Two ways that a class can implement multiple interfaces


   package innerclasses;



   interface A {}
   interface B {}

   class X implements A, B {}
   class Y implements A {
      B makeB() {
         // Anonymous inner class:
         return new B() {};
      }
   }



   public class MultiInterfaces {
      static void takesA(A a) {}
      static void takesB(B b) {}
      public static void main(string[] args) {
         X x = new x();
         Y y = new Y();
         takesA(x);
         takesA(y);
         takesB(x);
         takesB(y.makeB());
      }
   }



   当然，这里假设在两种方式下的代码结构都确实有逻辑意义。



   然而遇到问题的时候，通常问题本身就能给出某些指引，告诉您是应该使用单一类，还是使用内部类。



   但如果没有任何其他限制，从实现的观点来看，前面的例子并没有什么区别，它们都能正常运作。



   如果拥有的是抽象的类或具体的类，而不是接口，那就只能使用内部类才能实现多重继承。


   //: innerclasses/MultiImplementation.java
   // With concrete or abstract classes.inner
   // classes are the only way to produce the effect
   // of "multiple implementation inheritance."



   package innerclasses;


   class D {}
   abstract class E {}
   class Z extends D {
      E maKeE() {return new E() {};}
   }

   public class MultiImplementation {
      static void takesD(D d) {}
      static void takesE(E e) {}
      public static void main(String[] args) {
         Z z = new Z();
         takesD(z);
         takesE(z.makeE());
      }
   }


   如果不需要解决“多重继承”的问题。那么自然可以用别的方式编码，而不需要使用内部类。



   但如果使用内部类，还可以获得其他一些特性：



   一、内部类可以有多个实例，每个实例都有自己的状态信息，并且与其外围类对象的信息相互独立。



   二、在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或继承同一个类。



   三、创建内部类对象的时刻并不依赖于外围类对象的创建。



   四、内部类并没有令人迷惑的“is-a”关系；它就是一个独立的实体。



   举个例子，如果Sequence.java不使用内部类，就必须声明“Sequence是一个Selector”，对于某个特定的Sequence只能有一个Selector。


   然而使用内部类很容易就能拥有另一个方法reverseSelector()，用它来生成一个反方向遍历序列的Selector。只有内部类才有这种灵活性。

说一下内部类的用途啊
1、可以封装类型：顶层类的话只能处于public和默认访问级别，而内部类的话4种访问级别都可以。封装是面向对象的核心思想之一，这个不用解释。
2、内部类可以直接访问外部类的成员，如果放在外面的话，你访问其他类中的成员就得先实例化对象，这需要内存开销。
3、内部类可以回调外部类的方法。
就知道这么多。不够的楼下兄弟补充。

内部类是基于这个类出现在的。如果类不存，那么内部类存在就没有什么意义。例如，主板是一个类，那么内部封装一个类，这个类就是内部类，它的功能是用天边接鼠标的。
如果主板这个类都不存在，那么这个内部单独存在也就没有什么意义了。   这个例子不是太恰当。希望都有明白。