在Java中匿名类有什么用?我们可以说使用匿名类是Java的优点之一吗?


当前回答

匿名内部类实际上是闭包,所以它们可以用来模拟lambda表达式或“委托”。以这个接口为例:

public interface F<A, B> {
   B f(A a);
}

您可以匿名使用它在Java中创建一级函数。假设你有以下方法,返回给定列表中第一个比i大的数字,如果没有比i大的数字,则返回i:

public static int larger(final List<Integer> ns, final int i) {
  for (Integer n : ns)
     if (n > i)
        return n;
  return i;
}

然后你有另一个方法返回给定列表中第一个比i小的数字,如果没有比i小的数字,则返回i:

public static int smaller(final List<Integer> ns, final int i) {
   for (Integer n : ns)
      if (n < i)
         return n;
   return i;
}

这些方法几乎是相同的。使用一类函数类型F,我们可以将它们重写为一个方法,如下所示:

public static <T> T firstMatch(final List<T> ts, final F<T, Boolean> f, T z) {
   for (T t : ts)
      if (f.f(t))
         return t;
   return z;
}

你可以使用匿名类来使用firstMatch方法:

F<Integer, Boolean> greaterThanTen = new F<Integer, Boolean> {
   Boolean f(final Integer n) {
      return n > 10;
   }
};
int moreThanMyFingersCanCount = firstMatch(xs, greaterThanTen, x);

这是一个非常做作的例子,但是很容易看出,能够像传递值一样传递函数是一个非常有用的特性。请看Joel自己写的“你的编程语言能做到这一点吗?”

用这种风格编写Java的一个很好的库:函数式Java。

其他回答

似乎这里没有人提到,但你也可以使用匿名类来保存泛型类型参数(通常由于类型擦除而丢失):

public abstract class TypeHolder<T> {
    private final Type type;

    public TypeReference() {
        // you may do do additional sanity checks here
        final Type superClass = getClass().getGenericSuperclass();
        this.type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
    }

    public final Type getType() {
        return this.type;
    }
}

如果你用匿名的方式实例化这个类

TypeHolder<List<String>, Map<Ineger, Long>> holder = 
    new TypeHolder<List<String>, Map<Ineger, Long>>() {};

然后,这样的holder实例将包含传递类型的非擦除定义。

使用

这对于构建验证器/反序列化器非常方便。此外,您还可以使用反射实例化泛型类型(因此,如果您想在参数化类型中执行新的T()—欢迎您!)

不便/限制

您应该显式地传递泛型参数。如果不这样做,将导致类型参数丢失 每次实例化都会花费编译器生成额外的类,这会导致类路径污染/jar膨胀

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

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

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

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

还有一个好处: 正如你所知道的,Java不支持多重继承,所以如果你使用“线程”类作为匿名类,那么类仍然有一个空间留给任何其他类来扩展。

匿名类在类终结中的主要用法之一叫做终结器守护者。在Java世界中,应该避免使用finalize方法,除非你真的需要它们。你必须记住,当你重写子类的finalize方法时,你也应该总是调用super.finalize(),因为超类的finalize方法不会自动调用,你可能会遇到内存泄漏的问题。

所以考虑到上面提到的事实,你可以像这样使用匿名类:

public class HeavyClass{
    private final Object finalizerGuardian = new Object() {
        @Override
        protected void finalize() throws Throwable{
            //Finalize outer HeavyClass object
        }
    };
}

使用这种技术,您可以让自己和其他开发人员在需要finalize方法的重量级类的每个子类上调用super.finalize()。

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

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