我使用匿名对象来调用新线程。

new Thread(new Runnable() {
    public void run() {
        // you code
    }
}).start();

我有时使用它们作为Map实例化的语法hack:

Map map = new HashMap() {{
   put("key", "value");
}};

vs

Map map = new HashMap();
map.put("key", "value");

它在执行大量put语句时节省了一些冗余。然而，当外部类需要通过远程序列化时，我也遇到了这样做的问题。

您可以在需要在另一个函数中为特定目的创建类的情况下使用它，例如，作为侦听器，作为可运行对象(生成线程)等。

其思想是，从函数代码内部调用它们，因此永远不会在其他地方引用它们，因此不需要命名它们。编译器只是枚举它们。

它们本质上是语法糖，当它们变大时通常应该转移到其他地方。

我不确定这是否是Java的优点之一，但如果您确实使用它们(不幸的是，我们都经常使用它们)，那么您可能会认为它们是优点之一。

所谓的“匿名类”，我想你是指匿名的内部类。

匿名内部类在创建具有某些“额外”(如重写方法)的对象实例时非常有用，而不必实际继承一个类。

我倾向于使用它作为附加事件监听器的快捷方式:

button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        // do something
    }
});

使用这个方法可以使编码更快一点，因为我不需要创建一个额外的实现ActionListener的类——我可以实例化一个匿名的内部类，而不需要实际创建一个单独的类。

我只在“快速而肮脏”的任务中使用这种技巧，让整个类感觉没有必要。拥有多个做完全相同事情的匿名内部类应该被重构为一个实际的类，无论是内部类还是单独的类。

您可以这样使用匿名类

TreeSet treeSetObj = new TreeSet(new Comparator()
{
    public int compare(String i1,String i2)
    {
        return i2.compareTo(i1);
    }
});

优化代码的最佳方法。也可以用于类或接口的重写方法。

import java.util.Scanner;
abstract class AnonymousInner {
    abstract void sum();
}

class AnonymousInnerMain {
    public static void main(String []k){
        Scanner sn = new Scanner(System.in);
        System.out.println("Enter two vlaues");
            int a= Integer.parseInt(sn.nextLine());
            int b= Integer.parseInt(sn.nextLine()); 
        AnonymousInner ac = new AnonymousInner(){
            void sum(){
                int c= a+b;
                System.out.println("Sum of two number is: "+c);
            }
        };
        ac.sum();
    }

}