关闭钩子。这允许注册一个线程，该线程将立即创建，但仅在JVM结束时启动!因此，它是某种“全局jvm终结器”，您可以在这个线程中做一些有用的事情(例如关闭java资源，如嵌入式hsqldb服务器)。这适用于System.exit()，或CTRL-C / kill -15(当然，在unix上不适用kill -9)。

此外，它很容易设置。

            Runtime.getRuntime().addShutdownHook(new Thread() {
                  public void run() {
                      endApp();
                  }
            });;

Joshua Bloch的新书《Effective Java》是一个很好的资源。

局部类。 从包含类的外部实例化Java内部类。

真正让我吃惊的是自定义序列化机制。

而这些方法是私有的!!，它们会在对象序列化期间被JVM“神秘地”调用。

private void writeObject(ObjectOutputStream out) throws IOException;
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException;

通过这种方式，您可以创建自己的自定义序列化，使其更加“随便”(安全、快速、罕见、简单等)。

如果大量信息必须通过节点传递，这是真正应该考虑的事情。序列化机制可以更改为发送数据的一半。很多时候，瓶颈并不在平台上，而是在通过线路发送的数量上，这可能会为您节省数千个硬件dll。

这是一篇文章。 http://java.sun.com/developer/technicalArticles/Programming/serialization/

当人们意识到可以使用反射调用私有方法并访问/更改私有字段时，他们有时会有点惊讶……

考虑下面的类:

public class Foo {
    private int bar;

    public Foo() {
        setBar(17);
    }

    private void setBar(int bar) {
        this.bar=bar;
    }

    public int getBar() {
        return bar;
    }

    public String toString() {
        return "Foo[bar="+bar+"]";
    }
}

执行这个程序…

import java.lang.reflect.*;

public class AccessibleExample {
    public static void main(String[] args)
        throws NoSuchMethodException,IllegalAccessException, InvocationTargetException, NoSuchFieldException {
        Foo foo=new Foo();
        System.out.println(foo);

        Method method=Foo.class.getDeclaredMethod("setBar", int.class);
        method.setAccessible(true);
        method.invoke(foo, 42);

        System.out.println(foo);
        Field field=Foo.class.getDeclaredField("bar");
        field.setAccessible(true);
        field.set(foo, 23);
        System.out.println(foo);
    }
}

.．.将产生以下输出:

Foo[bar=17]
Foo[bar=42]
Foo[bar=23]

Self-bound泛型:

class SelfBounded<T extends SelfBounded<T>> {
}

http://www.artima.com/weblogs/viewpost.jsp?thread=136394