有人可以向我解释这个Java语法吗？这些括号在外括号内做了什么？
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
我想知道为什么以下代码显然不会垃圾收集那些应该不再引用的匿名模块（未扩展/包含，未命名，包含设置为nil的数组）。
如果有人能用相对简单/通用的编程语言来澄清幕后的状况，我将不胜感激。是否有一种特殊的红宝石方法可以实现这一目标？匿名模块/类不能被垃圾回收吗？还是我只是被我得到的内存统计数据误导了？
注意：我使用的是Ruby 1.9.3；不知道ruby 2.x是否会改变任何东西...注2：无论模块是否定义foo方法，结果都是相同的
提前致谢。
puts("INITIAL OBJECT SPACE OBJECTS : #{ObjectSpace.count_objects}")
i = 100000
ms = []
i.times do
ms << Module.new do
def foo()
puts('foo method called')
end
end
end
puts("#{i} MODULES CREATED")
puts("OBJECT SPACE OBJECTS : #{ObjectSpace.count_objects}")
ms = nil
ObjectSpace.garbage_collect
puts("#{i} MODULES GARBAGE COLLECTED")
puts("WAITING TO END PROGRAM")
stop = gets
puts("FINAL OBJECT SPACE OBJECTS : #{ObjectSpace.count_objects}")
我说“显然不会进行垃圾回收”，因为我的OS任务管理器没有显示进程中内存使用的任何减少，并且调用ObjectSpace.count_objects会产生以下内容，我读错了（是吗？）为：没有内存您模块使用的模块尚未释放。
初始对象空间对象：{：TOTAL => 14730，：FREE => 251，：T_OBJECT => 8，：T_CLASS => 542，：T_MODULE => 21，：T_FLOAT => 7，：T_STRING => 6349，：T_REGEXP => 24，：T_ARRAY => …
我一直对这个例子有问题。显示它试图展示的概念似乎是一种不必要的复杂方式：
http://docs.oracle.com/javase/tutorial/essential/concurrency/deadlock.html
所以我的问题与同步或锁定无关；它可能与匿名类有关：
只是如何访问在 bow 方法中调用的 bowBack 中的代码？实现 runnable 的匿名类被传递给 bow() 方法。
也许这是一个不好的问题。但是，使用匿名类来说明死锁会在不需要的示例中引入复杂性，我对吗？
我有这样的代码:
package x.y.z;
public class Test
{
private static class MyRunnable implements Runnable
{
@Override
public void run()
{
System.out.println("World");
}
}
public static void main(String[] args)
{
final Runnable r1 = new Runnable() {
@Override
public void run()
{
System.out.println("Hello");
}
};
final Runnable r2 = new MyRunnable();
r1.run();
r2.run();
}
}
我正在研究一些代码分析模块,我想证明这r1是一个匿名类实例而r2不是.它们都是具有相同基类或接口的有效对象.我怎样才能做到这一点？
细化:正在加载所有类,因此我不需要分析文本.
package demo;
class Child{
private static int a=50;
public void fin() {
System.out.println("hello");
}
private void fly() {
System.out.println("lol");
}
}
public class Hello {
public static void main(String[] args)
{
Child c=new Child() {
public void f() {
System.out.println("sorry"+a);
}
public void fin() {
System.out.println("hello");
}
};
c.fin();
}}
上面是java的代码，我的观点是为什么不能在匿名类中调用私有方法和变量，因为我在某处读到匿名类可以访问封闭类的所有成员。
https://www.baeldung.com/java-anonymous-classes
go checkout 指定匿名类的每个成员都可以访问封闭类的所有成员。
class Human {
void eat() {
System.out.println("human eat!");
}
}
public class Demo {
public static void main(String[] args) {
Human human = new Human() {
int x = 10;
public void test() {
System.out.println("test - anonymous");
}
@Override
void eat() {
System.out.println("customer eat!");
}
};
human.eat();
human.x = 10; //Illegal
human.test(); //Illegal
}
}
这段代码为什么会human.x=10;出现human.test(0);编译错误？
每次调用其封闭方法时，是否会创建一个匿名类（未实例化，但实际上已定义/加载了该类）？还是重用了它们？例如：
public MyInterface getAnonymousMyInterface() {
return new MyInterface(){
public void doStuff(){
System.out.println("did stuff");
}
}
}
调用会getAnonymousMyInterface()创建两个不同的类吗？
在查看 lambda 表达式时，我发现了匿名内部类和 lambda 表达式的以下行为。这背后的原因可能是什么？
Human h = new Human() {
int a = 2;
@Override
public void sing() {
System.out.println(++a);
}
};
h.sing();
h.sing();
输出/输出
3
4
而对于 lambda，我得到以下结果：
Human h = () -> {
int a = 2;
System.out.println(++a);
};
h.sing();
h.sing();
}
输出/输出
3
3