interface Inter
{
        public void method();
}
class Test
{
        static class Inner implements Inter
        {
                public void method()
                {
                        System.out.println("mwgg");
                }
        }
        static Inter function()//这一句为什么是静态的啊 function函数的运算结果是一个对象返回给Inter，为什么function是静态的
        {
                return new Inner();
        }
}
class  InterDemo
{
        public static void main(String[] args)
        {
                Test.function().method();
        }
}

当内部类被静态修饰后，只有静态方法才能访问

你主函数里面的Test.function.method();
就注定了function要静态，因为，类名调用方法只能调用静态方法。

静态是随类的加载而加载，优先于对象而存在的，也就是说，静态只能调用静态，而function方法又要调用Inner，所以你的Inner类也要是静态，如果不加Static，运行时虚拟机就会报异常
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
Cannot make a static reference to the non-static method function() from the type Test
意思就是：不能让一个静态引用非静态方法函数()
如果你不想function方法加static的话，那就把代码这样写也可以

1. interface Inter
   
2. {
   
3.         public void method();
   
4. }
   
5. class Test
   
6. {
   
7.         class Inner implements Inter
   
8.         {
   
9.                 public void method()
   
10.                 {
    
11.                         System.out.println("mwgg");
    
12.                 }
    
13.         }
    
14.         Inter function()
    
15.         {
    
16.                 return new Inner();
    
17.         }
    
18. }
    
19. class  InterDemo
    
20. {
    
21.         public static void main(String[] args)
    
22.         {
    
23.         [code]interface Inter
    
24. {
    
25.         public void method();
    
26. }
    
27. class Test
    
28. {
    
29.         class Inner implements Inter
    
30.         {
    
31.                 public void method()
    
32.                 {
    
33.                         System.out.println("mwgg");
    
34.                 }
    
35.         }
    
36.         Inter function()
    
37.         {
    
38.                 return new Inner();
    
39.         }
    
40. }
    
41. class  InterDemo
    
42. {
    
43.         public static void main(String[] args)
    
44.         {
    
45.                 Test t = new Test();
    
46.                 t.function().method();
    
47.         }
    
48. }
    
49. 
    

复制代码

或者用匿名内部类的方法

1. package cn.da;
   
2. 
   
3. public class QuestionOne {
   
4.               public static void main(String[] args)
   
5.               {
   
6.               Test.function().method();
   
7.               }
   
8. }
   
9. 
   
10. interface Inter
    
11. {
    
12.                public void method();
    
13. }
    
14. 
    
15. class Test
    
16. {
    
17.                 static public Inter function()
    
18.                 {
    
19.                           return new Inter()
    
20.                          {
    
21.                                   public void method()
    
22.                                  {
    
23.                                        System.out.println("mwgg");
    
24.                                  }
    
25.                        };
    
26.               }
    
27. }
    
28. 
    
29. 
    
30. 
    

复制代码

耶稣说wō乖 发表于 2013-8-22 15:25
你主函数里面的Test.function.method();
就注定了function要静态，因为，类名调用方法只能调用静态方法。

{:soso_e113:} 谢了 真详细，其实该给分的，但是俺现在是初级需要分，只能谢谢了

Jiewin 发表于 2013-8-22 14:48
当内部类被静态修饰后，只有静态方法才能访问

{:soso_e113:}恩 懂了，结合版主和下边的哥们的讲解 明白啦。继续学习...

楼上的是正解，但是一般初学者对这些话看不太懂，当时我也研究了好久，我是这么想通的，因为主函数是静态的，所以类已加载之后就在内存当中了，而非静态的成员呢，只有new一个对象才能在对内存中产生，也就是说，静态因为先存在不能访问还未存在的变量或方法，那么就只能访问跟静态一样存在于内存中的静态了

张聪珉 发表于 2013-8-22 18:56
楼上的是正解，但是一般初学者对这些话看不太懂，当时我也研究了好久，我是这么想通的，因为主函数是静态的 ...

  谢了 。恩 各有各的方法 哈哈{:soso_e113:}