匿名类是不能有名称的类，所以没办法引用它们。必须在创建时，作为new语句的一部分来声明它们。 这就要采用另一种形式的new语句，如下所示： new <类或接口> <类的主体> 这种形式的new语句声明一个新的匿名类，它对一个给定的类进行扩展，或者实现一个给定的接口。

        它还创建那个类的一个新实例，并把它作为语句的结果而返回。要扩展的类和要实现的接口是new语句的操作数，后跟匿名类的主体。 如果匿名类对另一个类进行扩展，它的主体可以访问类的成员、覆盖它的方法等等，这和其他任何标准的类都是一样的。如果匿名类实现了一个接口，它的主体必须实现接口的方法

 
  
  1. interface pr      
  2. {      
  3. void print1();      
  4. }      
  5.      
  6. public class noNameClass       
  7. {      
  8. public pr dest()      
  9. {      
  10.     return new pr(){      
  11.      public void print1()      
  12.      {      
  13.       System.out.println("Hello world!!");      
  14.      }      
  15.     };      
  16. }      
  17.      
  18. public static void main(String args[])      
  19. {      
  20.     noNameClass c=new     noNameClass();      
  21.     pr hw=c.dest();      
  22.     hw.print1();      
  23. }      
  24. }      
 
  
        pr也可以是一个类 但是你外部调用的方法必须在你的这个类或接口中声明 外部不能调用匿名类内部的方法
 
  
       Java中内部匿名类用的最多的地方也许就是在Frame中加入Listner了吧。如下：
 
  
 
  
  1. import java.awt.*;      
  2. import java.awt.event.*;      
  3.      
  4. public class QFrame extends Frame {      
  5.     public QFrame() {      
  6.            this.setTitle(\"my application\");      
  7.      
  8.            addWindowListener(new WindowAdapter() {      
  9.                    public void windowClosing(WindowEvent e) {      
  10.                    dispose();      
  11.                    System.exit(0);      
  12. }      
  13.             });        
  14.      
  15.           this.setBounds(10,10,200,200);      
  16.      }      
  17. }    
 
  
另外，可以参见这里，下面是其中部分的说明：
 
  
        当一个内部类的类声名只是在创建此类对象时用了一次，而且要产生的新类需继承于一个已有的父类或实现一个接口，才能考虑用匿名类，由于匿名类本身无名，因此它也就不存在构造方法，它需要显示地调用一个无参的父类的构造方法，并且重写父类的方法。所谓的匿名就是该类连名字都没有，只是显示地调用一个无参的父类的构造方法。
  
 
  
另外，可以参见这里：
 
  
匿名内部类的示例介绍 
 1.方法中的内部类
 public class InnerClass {
 public void LocalOne() {
    class DeepInside {
     DeepInside() {
      System.out.println("方法中的内部类");
     }
    }
    new DeepInside();
 }
 
  
// new DeepInside();外部无法调用
 public static void main(String[] args) {
    InnerClass A = new InnerClass();
    A.LocalOne();
 }
 }
 
  
2.匿名内部类
 public class InnerClass {
 public static void main(String[] args) {
    // 匿名内部类
    new InnerCall("hello") {
     public void shuChu() {
      System.out.println(" baby!");
     }
    }.shuChu();
   // 输出：hello baby!
 }
 }
 
  
class InnerCall {
 private String name;
 
  
InnerCall(String s) {
    name = s;
    System.out.print(name);
 }
 }
 
  
3.类中内部类,有名字的
 interface Contents {
 int value();
 }
 
  
public class InnerClass {
 // 内部类,有名字的
 class MyContents implements Contents {
    public int value() {
     return 0;
    }
 }
 
  
public Contents getContents() {
    return new MyContents();
 }
 
  
public static void main(String[] args) {
    InnerClass p = new InnerClass();
    Contents c = p.getContents();
    System.out.println(c.value());
 }
 }
 
  
4.该例是例3个匿名内部内写法
 interface Contents {
 int value();
 }
 
  
public class InnerClass {
 public Contents getContents() {
    return new Contents() {// 这段大括号中代码就是匿名内部类
     public int value() {
      return 0;
     }
    };
 }
 
  
public static void main(String[] args) {
    InnerClass p = new InnerClass();
    Contents c = p.getContents();
    System.out.println(c.value());
 }
 }
 
  
注：例2的用法很常见,官方说明如下：
 简单的解释说明：
 In general, the syntax is
 new SuperType(construction parameters)
 {
    inner class methods and data
 }
 Here, SuperType can be an interface, such as ActionListener; then, the inner class implements
 that interface. Or SuperType can be a class; then, the inner class extends that class.An anonymous
 inner class cannot have constructors because the name of a constructor must be the same as the name
 of a class, and the class has no name. Instead, the construction parameters are given to the superclass 
 constructor. In particular, whenever an inner class implements an interface, it cannot have any 
 construction parameters. Nevertheless,you must supply a set of parentheses as in
 new InterfaceType()
 {
 methods and data
 }
 
  
存在它的原因是:
 　1.一个内部类的对象能够访问创建它的对象的实现，包括私有数据。即内部类实例对包含它的哪个类的实例来说，是特权的。
 　2.对于同一个包中的其他类来说,内部类能够隐藏起来,换句话说，内部类不管方法的可见性如何，那怕是public，除了包容类，其他类都无法使用它。
 　3.匿名内部类可以很方便的定义回调。
 　4.使用内部类可以非常方便的编写事件驱动程序。
 其实它真正的目的仅仅为了定义回调－－进一步就是事件驱动。
 
  
在使用匿名内部类时，要记住以下几个原则： 
 　·匿名内部类不能有构造方法。   
 　·匿名内部类不能定义任何静态成员、方法和类。   
 　·匿名内部类不能是public,protected,private,static。   
 　·只能创建匿名内部类的一个实例。 
 ·一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。   
 　·因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。
 
  
·内部类只能访问外部类的静态变量或静态方法。
 
  
 
 
  
匿名类和内部类中的中的this :
有时候，我们会用到一些内部类和匿名类。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名