标签: anonymous-class

在阅读这个问题的答案时出现了这个问题 - 如何在java中加入两个列表.这个答案给出了解决方案

List<String> newList = new ArrayList<String>() { { addAll(listOne); addAll(listTwo); } };

阅读评论,用户说它是邪恶和丑陋的,不应该用于生产.

我想知道使用它有什么害处？为什么在生产中使用它是丑陋的,邪恶的还是坏的？

注意:被问到这是一个问题因为,引用的帖子太旧了(2008年),回答者几个月后就离开了.

它看起来像匿名类提供了关闭的基本功能,是真的吗？

我在这里看到了很多关于Java lambdas性能的问题,但是大多数问题都像"Lambdas稍快一点,但在使用闭包时变慢"或"预热与执行时间不同"或其他类似的东西.

但是,我在这里遇到了一件相当奇怪的事情.考虑这个LeetCode问题:

给定一组非重叠间隔,在间隔中插入新间隔(必要时合并).

您可以假设间隔最初是根据其开始时间排序的.

问题被标记为难,所以我认为线性方法不是他们想要的.所以我决定想出一种聪明的方法将二进制搜索与修改结合到输入列表中.现在问题在修改输入列表时并不是很清楚 - 它表示"插入",即使签名需要返回对列表的引用,但现在也不用担心.这是完整的代码,但只有前几行与此问题相关.我在这里保留其余部分,以便任何人都可以尝试:

public List<Interval> insert(List<Interval> intervals, Interval newInterval) {
    int start = Collections.binarySearch(intervals, newInterval,
                                         (i1, i2) -> Integer.compare(i1.start, i2.start));
    int skip = start >= 0 ? start : -start - 1;
    int end = Collections.binarySearch(intervals.subList(skip, intervals.size()),
                                       new Interval(newInterval.end, 0),
                                       (i1, i2) -> Integer.compare(i1.start, i2.start));
    if (end >= 0) {
        end += skip; // back to original indexes
    } else {
        end -= skip; // ditto
    }
    int newStart = newInterval.start;
    int headEnd; …

package com.test;

public class OuterClass {
    public class InnerClass {
        public class InnerInnerClass {

        }
    }

    public class InnerClass2 {

    }

    //this class should not exist in OuterClass after dummifying
    private class PrivateInnerClass {
        private String getString() {
            return "hello PrivateInnerClass";
        }
    }

    public String getStringFromPrivateInner() {
        return new PrivateInnerClass().getString();
    }
}

当javac在命令行上运行时Sun JVM 1.6.0_20,此代码生成6个.class文件:

OuterClass.class
在OuterClass $ 1.class
在OuterClass $ InnerClass.class
在OuterClass $ InnerClass2.class
在OuterClass $ $将InnerClass InnerInnerClass.class
在OuterClass $ PrivateInnerClass.class

在eclipse中运行JDT时,它只生成5个类.

OuterClass.class
$在OuterClass 1.class …

在Swift中是否有与Anonymous类相同的语法或技术？仅用于澄清Java示例中的Anonymous类 - http://docs.oracle.com/javase/tutorial/java/javaOO/anonymousclasses.html

谢谢!

interface TestA {
    String toString();
}

public class Test {
    public static void main(String[] args) {
        System.out.println(new TestA() {
            public String toString() {
                return "test";
            }
        });
    }
}

结果是什么？

A.测试
B. null
C.在运行时抛出异常.
D.由于第1行中的错误,
编译失败.E.由于第4行中的错误,
编译失败.F.由于第5行中的错误,编译失败.

这个问题的答案是什么？为什么？关于这个问题我还有一个问题.在第4行中,我们创建了A的对象.是否可以创建接口的对象？

我正在研究一个在java 7中实现的项目,现在我想迁移到java 8.我使用Intellij Idea并找到所有"新内部类发生"的whit regex查找("new.(.)\ s*{[. |\s]*"),但那些数量非常多!如何强制Intellij替换所有这些内部类？

为什么第一种方式是正确的,但第二种方式不是？

第一种方式:

new Object() {
    public void a() {
        /*code*/
    }
}.a();

第二种方式:

Object object = new Object() {
    public void a() {
        /*code*/
    }
};

object.a();

我在哪里可以找到更多相关信息？

我正在处理一些代码,其中一个对象"foo"正在创建另一个对象"bar",并将其传递给它Callable.在此foo之后将返回bar,然后我希望foo变得无法访问(即:可用于垃圾收集).

我最初的想法是Callable匿名创建.例如:

class Foo {
  ...

  public Bar createBar() {
    final int arg1 = ...
    final int arg2 = ...
    final int arg3 = ...
    return new Callable<Baz>() {
      @Override
      public Baz call() {
        return new Baz(arg1, arg2, arg3);
      }
    };
  }
}

在我看来,这可能实际上并不按预期工作,因为内部类通常会保持对其封闭对象的引用.我不希望在这里引用封闭类,因为我希望在Callable仍然可以访问时收集封闭对象.

另一方面,检测到实际上从未引用封闭实例应该是非常简单的,因此Java编译器可能足够聪明,在这种情况下不包括引用.

那么......一个匿名内部类的实例是否会持有对其封闭实例的引用,即使它实际上从未使用封闭的实例引用？

这两种做事方式之间的效率(例如执行时间,代码大小等)是否有任何差异？

下面是创建对象并且什么也不做的人为设想的示例,但我的实际场景可能是创建新的线程,监听器等.假设以下代码片段在循环中发生,以便它可能有所作为.

使用匿名对象:

void doSomething() {
    for (/* Assume some loop */) {
        final Object obj1, obj2; // some free variables

        IWorker anonymousWorker = new IWorker() {
            doWork() {
                // do things that refer to obj1 and obj2
            }
        };
    }
}

首先定义一个类:

void doSomething() {
    for (/* Assume some loop */) {
        Object obj1, obj2;
        IWorker worker = new Worker(obj1, obj2);
    }
}

static class Worker implements IWorker {
    private Object obj1, obj2;
    public CustomObject(Object obj1, Object obj2) {/* …