1. <p> </p><p>class Demo8
   
2. {
   
3.          public static void main(String[] args)
   
4.         {
   
5.                  new Thread( new Runnable()        //我的疑问在这里，接口也可以直接new了 ？
   
6.                                  {
   
7.                                         public void run(){
   
8.                                               System.out.println("Runable run()");
   
9.                                         }
   
10.                  
    
11.                                   } )
    
12.                   {
    
13.                           public void run(){
    
14.                                  System.out.println("Thread run()");
    
15.                           }
    
16.                  
    
17.                    }.start();
    
18.                    System.out.println("Hello World!");
    
19.          }
    
20. }</p>

复制代码

昨天在论坛里转，一个同学问匿名内部类的问题，本来想解答一下，但是看来看去吧我自己整蒙了。所以借那位仁兄的例子用一下
我的疑问是在内部类中接口是如何实现的，通常不都是需要用implements来实现接口吗，为什么在上面的例子中的Runnable接口可以直接new。而且还带()。

要不怎么叫内部类呢，就是在类的内部包含一个类
注意是一个类！
new的不是接口，而是实现了接口的一个类，
只不过这个类没有名字而已

首先，内部类可以用implements实现接口，既然是类，那么它就可以继承父类或实现接口，继承时用extends,实现类时就是用implements,这是没有什么疑问的。
至于上面说的第二个问题，那个是匿名内部类，它直接面向接口编程，并且在自己内部实现接口内的方法。
你要去理解什么是内部类，内部类的作用，java的多态，什么是回调函数。
匿名内部类是当做函数的参数传递给方法的，在这个方法中，会用接口类型接受传入的匿名类，然后调用其方法，这是多态。原理其实是实现了回调。
因为他会调用你匿名内部类中的方法。
给你举个例子：
interface InterfaceA{
          String go();
}
class Test(){
         public void prtGo(InterfaceA ia){
                  System.out.println(ia.o());
         }
        public static void main(String []args){
                  Test t = new Test();
                  t.prtGo(new InterfaceA(){
                           public String go(){
                                    return "go";
                           }
                  });
         }
}

接口类为什么不能new对象 其实就是因为内部有抽象方法 创建对象没有意义
如果你想建立接口对象,其实也没问题,只要你把它的抽象方法全部实现了就OK了.但再怎么样你建立的也是接口的子类对象,因为你必须实现接口的抽象方法
就像你例子中的这个内部类,其实建立的也不是Runnable接口对象,而是Runnable接口的子类对象,就因为是匿名内部类 没有名字 所以只好借用父类的名字了.

此种现象：这是一个实现了Runnable接口匿名类
写法就是这样的，方便。

• class Demo8
• {
•          public static void main(String[] args)
•         {
•                  new Thread( new Runnable()        //我的疑问在这里，接口也可以直接new了 ？
•                                  {
•                                         public void run(){
•                                               System.out.println("Runable run()");
•                                         }               
•                                   } )
•                   {
•                           public void run(){
•                                  System.out.println("Thread run()");
•                           }
•                    }.start();
•                    System.out.println("Hello World!");
•          }
• }
• 以上红色的整个部分是实现了Runnable接口的子类对象，而子类覆盖了Runnable接口的run方法而已
• 这里就是一个简单的匿名内部类的格式，一般应用于只调用这个对象一次就不再用的情况，这样比较简便