interface Contents
{
         void go();
}

public class Test1 {
         public Contents con()
         {
                 return new Contents()
                 {
                         public void go()
                         {
                                 System.out.println("I got it");
                         }
                 };
         }
         
        public static void main(String [] args)
         {
                 Test1 t = new Test1();
                 Contents c = t.con();
                 c.go();
         }
代码中定义了一个接口在类Test1中并没有用关键字实现怎么可以创建接口对象并复写接口？
还在主函数中利用多态调用？

public Contents con() 方法返回了一个Contents对象，
所以“Contents c = t.con();”就是相当于“Contents c = new Contents();”是创建了Contents对象。这里的t.con()是调用Test1中的con()方法，不是多态。
所以变量c指向了一个Contents对象，可以进行go()方法的调用。

1. interface Contents
   
2. {
   
3.          void go();
   
4. }
   
5. 
   
6. public class Test1 {
   
7.          public Contents con()
   
8.          {
   
9.                  //楼主可以这样看，con()返回一个Contents型实例对象，并且这个实例对象实现了void go()方法所以它可以被调用
   
10.                  return new Contents() { public void go(){ System.out.println("I got it");}};
    
11.          }
    
12.             
    
13.                
    
14.          
    
15.          
    
16.         public static void main(String [] args)
    
17.          {
    
18.                  Test1 t = new Test1();  //创建Test1型的实例对象t
    
19.                  Contents c = t.con(); //对象t可以调用con()并返回一个非抽象的Contents型的对象
    
20.                  c.go();  //因为c 中的go方法是非抽象的，所以可以调用
    
21.          }
    
22. }

复制代码

1.匿名内部类你还不是很熟
new Contents()
                 {
                         public void go()
                         {
                                 System.out.println("I got it");
                         }
                 };
单拿出来分析：这部分代码是说创建了一个子类的实现类的对象重写接口中的方法，是多态的体现，只不过用匿名内部类这种写法看起来比较拧巴；

2.              Test1 t = new Test1();
                 Contents c = t.con();
                 c.go();
第一行是说声明一个引用并创建一个Test1对象
第二行就是很简单的调用，只不过返回值是Contents 类型的对象
第三行就是利用创建好的实现类对象调用他重写的方法

就是匿名内部类的问题。建议你再复习下。该说的。LS都说了

其实你这段代码
return new Contents()
                 {
                         public void go()
                         {
                                 System.out.println("I got it");
                         }
                 };
就等于是创建了一个新的对象实现了Contents接口，然后重写了接口里的方法
再到main方法里Contents c = t.con();就等于父类引用指向子类对象，多态的存在了
所以c.go()访问的就是上面返回的对象里重写的方法