匿名内部类能静态么？为什么？要怎么写，我知道匿名内部类的作用，我只是想知道，有没有这样的格式能这么写

可以，匿名内部类也算是成员，static可以修饰成员，通过两个例子来说明吧，一个是访问静态内部类的非静态方法，一个是访问非静态内部类的非静态方法

1. public class OuterClass {
   
2.         public static class InnerClass {
   
3.                 public void show(){
   
4.                         System.out.println("静态的内部类");
   
5.                 }
   
6.         }
   
7.         public class noStatic {
   
8.                 public void show(){
   
9.                         System.out.println("非静态内部类");
   
10.                 }
    
11.         }
    
12.         public static void main(String[] args) {
    
13.                 new OuterClass.InnerClass().show();
    
14.                 new OuterClass().new noStatic().show();
    
15.         }
    
16.        
    
17. }

复制代码

大哥，我说的是匿名内部类

你代码里没有匿名内部类啊

王雷1 发表于 2013-11-26 14:46
你代码里没有匿名内部类啊

匿名内部类不可能静态的，直接都是建立一个对象，都放在堆内存中。匿名都没有定义类型，更不用说加上修饰符了，每一次被调用都是一个新的对象，被静态修饰的成员能被共享，就这点也和匿名冲突了。

可以的。你可以下面的代码。看是否能帮住你吧！
abstract class AbsDemo{
abstract  void show();
}
class Outer{
   int x=3;
   public void function(){
   Abstract d=new Abstract(){
    int num=9;
    void show(){
    system.out.println("num=="+num);
      }
    void abc(){
    System.out.println("haha");
      }
    };
    d.show();
  }
}
   interface Inter
  {
      void method();
   }
   class Test
  {
     static Inter function()
       {
           renturn new Inter()
            {
                 public void methos()
                   {
                       System.out.println("method run");
                   }
             };
       }
  }
class InterClassTest
{
   public static void main(String[] args)
      {
          Test.function().method();
           //Outer.function().show();   
          // Out.function().abc();
       }
}

匿名内部类也就是没有名字的内部类，正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写，但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。
下面一个简单Demo：
abstract class Person {
    public abstract void eat();
}
  
public class Demo {
    public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
                System.out.println("eat something");
            }
        };
        p.eat();
    }
}

abstract class AbsDemo
{
        abstract  void show();
}
class Outer
{
        int x=3;
        public void function()
        {
        Abstract d=new Abstract()
        {
                int num=9;
                void show()
                {
                        system.out.println("num=="+num);
                }
                void abc()
                {
                        System.out.println("haha");
                }
    };
    d.show();
        }
}
   interface Inter从这开始下面我看的差不多了，你很有才，这样的静态内部类你都能想到。但是这个上面的代码是什么意思，特别是你new Abstract是什么意思求解
   {
      void method();
   }
   class Test
   {
     static Inter function()
       {
           return new Inter()
            {
                 public void methos()
                   {
                       System.out.println("method run");
                   }

                                @Override
                                public void method() {
                                        // TODO Auto-generated method stub
                                       
                                }
             };
       }
  }
class InterClassTest
{
   public static void main(String[] args)
      {
          Test.function().method();
           //Outer.function().show();   
          // Out.function().abc();
       }
}

匿名内部类也就是没有名字的内部类

正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写

但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。

1. abstract class Person {
   
2.     public abstract void eat();
   
3. }
   
4. 
   
5. class Child extends Person {
   
6.     public void eat() {
   
7.         System.out.println("eat something");
   
8.     }
   
9. }
   
10. 
    
11. public class Demo {
    
12.     public static void main(String[] args) {
    
13.         Person p = new Child();
    
14.         p.eat();
    
15.     }
    
16. }

复制代码

可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person类的引用

但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？

这个时候就引入了匿名内部类。