那为什么会有new FilenameFilter(){}}这种匿名内部类语句呢？
还是实例化的是某个实现该接口的类的实例？

这种匿名内部类实际相当于创建一个接口的匿名实现类。。。

匿名内部类 其实就是匿名的子类对象

没有名字，引用父类名的子类对象？

看视频中讲匿名类，如果内部类  class  子类  extends 父类 （）{}
则匿名内部类   new  父类（）{}   即这个匿名内部类是父类的实现类

匿名子类对象

匿名内部类 用的很少  只做了解

路过~~~~~

这是创建了一个接口的实现类，匿名内部类常用

{}内必须要重写接口中的抽象方法,匿名内部类,也是多态的一种体现,父类引用指向子类对象

学习了。。。。

首先得知道内部类是干什么的，
内部类就是在一个类中嵌套了一个类，内部的类可以访问外部类的成员（属性，方法），外部类想要访问内部类，就必须要创建内部类的对象。就像如下：

1. class Outer{//外部类
   
2.         int num = 4;//外部类成员
   
3.         class  Inner {//内部类
   
4.                 void show(){//内部类方法
   
5.                         System.out.println("inner show run "+num);//访问了外部类成员                       
   
6.                 }
   
7.         }
   
8.         public void method(){//外部类方法要访问内部类
   
9.                 Inner in = new Inner();//必须创建内部类的对象。
   
10.                 in.show();//调用内部类的方法。
    
11.         }
    
12. }
    
13. class InnerClassTest
    
14. {
    
15.         public static void main(String[] args)
    
16.         {
    
17.                 Outer out = new Outer();
    
18.                 out.method();//inner show run + 4
    
19.         }
    
20. }

复制代码

匿名内部类呢？就是内部类的一种简写方式。一般只用一次，前面说的很对，其实就是一个匿名子类对象。但是用的时候有前提，必须继承一个类或者实现一个接口。代码如下匿名内部类

1. interface Inner
   
2. {
   
3.         void show();
   
4. }
   
5. class Outer
   
6. {
   
7.         int num = 4;
   
8.         public Inner method()
   
9.         {
   
10.                 return new Inner()
    
11.                 {
    
12.                         public void show()
    
13.                         {
    
14.                                 System.out.println("inner show run "+num);
    
15.                         }
    
16.                 };
    
17.         }
    
18. }
    
19. class InnerClassTest
    
20. {
    
21.         public static void main(String[] args)
    
22.         {
    
23.                 Outer out = new Outer();
    
24.                 out.method().show();//inner show run + 4
    
25.         }
    
26. }

复制代码

至于为什么要用它呢？new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }
我想一个方面是简化内部类，另一方面打破继承的局限性，也是一种多态的体现，父类引用子类对象。以前不是创建对象并操作对象么，现在直接操作共性类型做事情即可。

我想这也就是为什么，当函数的参数是接口类型引用时，如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递。

1. interface Inner
   
2. {
   
3.         void show();
   
4. }
   
5. class InnerClassTest
   
6. {
   
7.         public static void main(String[] args)
   
8.         {
   
9.                 final int num = 4;
   
10.                 show(new Inner()//这里用匿名内部类，把父类重写。
    
11.                 {
    
12.                         public void show()
    
13.                         {
    
14.                                 System.out.println("inner show run"+num);
    
15.                         }
    
16.                 });
    
17.         }
    
18.         public static void show(Inner in)//函数的参数是接口类型的引用，此中方法不超过三个，
    
19.         {
    
20.                 in.show();
    
21.         }
    
22. }

复制代码

此上只是个人看法，如有错误请指出，共同进步，共同发展。

花花公子的见解挺好:handshake

可以给加分么:#

创建的是子类

这个不叫实例化
相当是多态的一种形式

父类 对象名 = new 子类；

这里写为

接口 对象名 = new 子类；

只不过这个子类没有名字

你要想给它起个对象名

便于理解，可以

FilenameFileter fn = new FilenameFilter(){};

相当于implements

这样写的好处是可以调用匿名内部类里的多个方法

fn.f1();

fn.f2();

若不这样写

只能调用一个方法

new FilenameFilter(){}.f1();

这又不是实例化接口