匿名类使我们可以编写小代码，并同时声明和实例化类。
这些类没有名称，仅在一次使用任何类时使用。
这是Java编程的重要方面。

声明匿名类

通常我们创建一个类，例如：我们声明类，但是匿名类是表达式，这意味着我们在另一个表达式中定义了匿名类。
用简单的话说，匿名内部类是一个没有名称的类，并且只创建一个对象。

当我们必须使用类或者接口的重载方法创建对象的实例而不创建类的子类时，匿名类很有用。

匿名可以通过两种方式创建：

• 类(也可以是Abstract)

• 接口

在匿名类中，我们可以声明以下内容：

• 字段

• 额外的方法

• 实例初始化器

• 本地类

Java匿名类的语法

匿名类的语法类似于构造函数，除了在块中有一个类定义，如下面的代码片段所示：

//AnonymousClass = interface,abstract/concrete class.
AnonymousClass t = new AnonymousClass()
{
  //methods and fields
  public void someMethod()
  {
     //code goes here
   }  
}

让我们看一下以下示例：

下面的例子， HelloAnonymousClass，在局部变量的初始化语句中使用匿名类 greetSomeone但是，使用本地类来初始化变量 greetWorld：

public class HelloAnonymousClass {
interface HelloWorld {
public void sayHello();
public void sayHelloTo(String someone);
}
public void sayHello() {
class GreetWorld implements HelloWorld {
String name = "world";
public void sayHello() {
sayHelloTo("world");
}
public void sayHelloTo(String someone) {
name = someone;
System.out.println("Hello " + name);
}
}
HelloWorld greetWorld = new GreetWorld();
HelloWorld greetSomeone = new HelloWorld() {
String name = "jon";
public void sayHello() {
sayHelloTo("Jon");
}
public void sayHelloTo(String someone) {
name = someone;
System.out.println("hola " + name);
}
};
greetWorld.sayHello();
greetSomeone.sayHelloTo("Doe");
}
public static void main(String... args) {
HelloAnonymousClass myApp = new HelloAnonymousClass();
myApp.sayHello();
}
}

正如我们已经看到的，匿名类是一个表达式，其语法就像构造函数一样，只是在块中有一个类定义。
考虑greetSomeone对象的实例化：

HelloWorld greetSomeone = new HelloWorld() {
String name = "jon";
public void sayHello() {
sayHelloTo("Jon");
}
public void sayHelloTo(String someone) {
name = someone;
System.out.println("hola " + name);
}
}

匿名类由以下组成：

• 新的运营商。

• 它可以实现接口或者扩展类。如上例所示，它正在实现接口。

• 它像普通类一样包含括号，以便将参数传递给构造函数。

• 包含包含方法声明的主体。不允许声明。

匿名类应该是语句的一部分。

在上面的示例中，匿名类表达式是该语句的一部分，该语句由 greetSomeone。

用Java创建匿名类的方法

有3种方法可以用Java创建内部类

• 通过扩展类

我们可以通过扩展其他类来创建匿名内部类，假设我们必须使用Thread类创建线程，我们可以创建匿名内部类而不是创建单独的类。

//Program to illustrate Anonymous Inner class by extending other class
class AnonymousThreadClass {
public static void main(String[] args) {
//Anonymous Inner class that extends Thread class
Thread t = new Thread() {
public void run() {
System.out.println("Child!");
}
};
t.start();
System.out.println("Parent!");
}
}

Parent!Child!- 通过实现接口

我们还可以通过实现接口来创建匿名内部类。
现在，当我们通过类似地扩展类来创建内部类时，我们可以创建一个实现接口的类。

//Program to illustrate Anonymous Inner class by implementing interface
class AnonymousThreadClass
{
public static void main(String[] args)
{
//Anonymous Inner class that implements interface
Runnable r = new Runnable()
{
public void run()
{
System.out.println("Child!");
}
};
Thread t = new Thread(r);
t.start();
System.out.println("Parent!");
}
}

Parent!Child!- 作为方法/构造函数的参数

要了解语法，请看下面的示例：

//Program to illustrate Anonymous Inner class by argument
class AnonymousThreadClass {
public static void main(String[] args) {
//Anonymous class with constructor argument
Thread t = new Thread(new Runnable() {
public void run() {
System.out.println("Child!");
}
});
t.start();
System.out.println("Parent!");
}
}

Parent!Child!

常规和匿名内部类之间的区别

• 我们可以使用普通类来实现多个接口，但是，使用匿名内部类，我们只能实现一个接口。

• 使用常规类，我们可以扩展一个类并实现多个接口，但是使用匿名内部类，我们可以扩展一个类或者实现一个接口，但不能同时扩展两者。

• 使用匿名，我们无法编写构造函数，因为匿名内部类没有名称，构造函数的名称应与类名称相同。

在本文中，我们看到了什么是匿名内部类以及如何创建一个内部类。
我们介绍了匿名内部类的语法，以及如何以3种方式创建匿名类。