匿名內部類實際上是閉包，因此可以用來模擬lambda表達式或“委托”。例如，以這個接口為例：

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

您可以使用此匿名創建一級函數在爪哇。假設您有以下方法，它返回比給定列表中的我大的第一個數字，或者如果沒有更大的數字，則返回我：

public?static?int?larger(final?List<Integer>?ns,?final?int?i)?{
??for?(Integer?n?:?ns)
?????if?(n?>?i)
????????return?n;
??return?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);

這是一個精心設計的例子，但很容易看出，能夠像傳遞值一樣傳遞函數是一個非常有用的特性。

匿名內部類用于以下場景：

1.)用于重寫(子類)，當類定義除當前情況外不可用時：

class A{
   public void methodA() {
      System.out.println("methodA");
    }}class B{
    A a = new A() {
     public void methodA() {
        System.out.println("anonymous methodA");
     }
   };}

2.為實現接口，如果只需要在當前情況下實現接口：

interface interfaceA{
   public void methodA();}class B{
   interfaceA a = new interfaceA() {
     public void methodA() {
        System.out.println("anonymous methodA implementer");
     }
   };}

3.定義匿名內部類的參數：

 interface Foo {
   void methodFoo();
 }
 class B{
  void do(Foo f) { }}class A{
   void methodA() {
     B b = new B();
     b.do(new Foo() {
       public void methodFoo() {
         System.out.println("methodFoo");
       } 
     });
   } 
 }

我有時將它們用作Map實例化的語法黑客：

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

VS

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

它在執行大量PUT語句時節省了一些冗余。但是，當外部類需要通過遠程處理序列化時，我也遇到了一些問題。