Java中的匿名内部类-yiteyi-C++库

Java中的嵌套类是掌握匿名内部类的前提。它是一个没有名称的内部类，只为其创建了一个对象。匿名内部类在生成具有某些“附加”的对象实例时非常有用，例如重写类或接口的方法，而不必实际为类创建子类。

null

提示： 匿名内部类在为图形编程中的侦听器接口编写实现类时很有用。

匿名类表达式的语法类似于构造函数的调用，只是代码块中包含一个类定义。

语法：

// Test can be interface,abstract/concrete classTest t = new Test() {   // data members and methods   public void test_method()    {      ........      ........    }   };

现在让我们来讨论常规类（普通类）和匿名内部类之间的区别

普通类可以实现任意数量的接口，但匿名内部类一次只能实现一个接口。
常规类可以扩展一个类并同时实现任意数量的接口。但匿名内部类可以扩展一个类，也可以实现一个接口，但不能同时实现两者。
对于常规/普通类，我们可以编写任意数量的构造函数，但不能为匿名内部类编写任何构造函数，因为匿名类没有任何名称，并且在定义构造函数类名时，构造函数名称必须相同。

访问封闭范围的局部变量，并声明和访问匿名类的成员

和本地类一样，匿名类可以捕获变量；它们对封闭范围内的局部变量具有相同的访问权限：

匿名类可以访问其封闭类的成员。
匿名类无法访问其封闭作用域中未声明为final或实际上为final的局部变量。
与嵌套类一样，匿名类中的类型声明（如变量）会隐藏封闭范围中具有相同名称的任何其他声明。

匿名类对其成员也有与本地类相同的限制：

我们不能在匿名类中声明静态初始值设定项或成员接口。
匿名类可以有静态成员，前提是它们是常量变量。

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

领域

额外的方法（即使它们没有实现任何超类型的方法）

实例初始值设定项

本地班

方法：

匿名内部类是通过以下两种方式创建的，如下所示：

类（可以是抽象的或具体的）
界面

现在让我们举一个例子来理解匿名内部类，让我们举一个简单的程序

实例

JAVA

                           // Java program to demonstrate Need for                         
                           // Anonymous Inner class                         
            
                           // Interface                         
                           interface                                        Age {                         
            
                                                     // Defining variables and methods                         
                                                     int                                        x =                                        21                                        ;                         
                                                     void                                        getAge();                         
                           }                         
            
                           // Class 1                         
                           // Helper class implementing methods of Age Interface                         
                           class                                        MyClass                                        implements                                        Age {                         
            
                                                     // Overriding getAge() method                         
                                                     @Override                                        public                                        void                                        getAge()                         
                                                     {                         
                                                     // Print statement                         
                                                     System.out.print(                                        "Age is "                                        + x);                         
                                                     }                         
                           }                         
            
                           // Class 2                         
                           // Main class                         
                           // AnonymousDemo                         
                           class                                        GFG {                         
                                                     // Main driver method                         
                                                     public                                        static                                        void                                        main(String[] args)                         
                                                     {                         
                                                     // Class 1 is implementation class of Age interface                         
                                                     MyClass obj =                                        new                                        MyClass();                         
            
                                                     // calling getage() method implemented at Class1                         
                                                     // inside main() method                         
                                                     obj.getAge();                         
                                                     }                         
                           }                         

输出：

图片[1]-Java中的匿名内部类-yiteyi-C++库

输出说明：

在上面的程序中，使用getAge（）方法和x=21创建接口Age。Myclass是作为Age接口的一个实现类编写的。正如在程序中所做的那样，不需要编写单独的类Myclass。而是直接将Myclass的代码复制到这个参数中，如下所示：

Age oj1 = new Age() {    @Override    public void getAge()     {        System.out.print("Age is " + x);    }};

在这里，不会创建一个老化对象，但会在整个类代码中创建并复制Myclass的对象，如上所示。这只有在匿名内部类中才能实现。这样的类被称为“匿名内部类”，所以这里我们称“Myclass”为匿名内部类。

例子：

JAVA

                         // Java Program to Demonstrate Anonymous inner class                       
           
                         // Interface                       
                         interface                                     Age {                       
                                                 int                                     x =                                     21                                     ;                       
                                                 void                                     getAge();                       
                         }                       
           
                         // Main class                       
                         class                                     AnonymousDemo {                       
                                   
                                                 // Main driver method                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
           
                                                 // Myclass is hidden inner class of Age interface                       
                                                 // whose name is not written but an object to it                       
                                                 // is created.                       
                                                 Age oj1 =                                     new                                     Age() {                       
                                   
                                                 @Override                                     public                                     void                                     getAge()                       
                                                 {                       
                                                 // printing  age                       
                                                 System.out.print(                                     "Age is "                                     + x);                       
                                                 }                       
                                                 };                       
                                   
                                                 oj1.getAge();                       
                                                 }                       
                         }                       

输出

Age is 21

匿名内部类的类型

根据声明和行为，有三种类型的匿名内部类：

扩展类的匿名内部类
实现接口的匿名内部类
定义内部方法/构造函数参数的匿名内部类

类型1： 扩展类的匿名内部类

我们可以有一个匿名的内部类来扩展一个类。例如，我们知道可以通过扩展thread类来创建线程。假设我们需要一个即时线程，但不想创建一个扩展的类线程类总是在这种匿名内部类的帮助下，我们可以定义一个就绪线程。

实例

JAVA

                         // Java program to illustrate creating an immediate thread                       
                         // Using Anonymous Inner class that extends a Class                       
           
                         // Main class                       
                         class                                     MyThread {                       
                                   
                                                 // Main driver method                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 // Using Anonymous Inner class that extends a class                       
                                                 // Here a Thread class                       
                                                 Thread t =                                     new                                     Thread() {                       
                                   
                                                 // run() method for the thread                       
                                                 public                                     void                                     run()                       
                                                 {                       
                                                 // Print statement for child thread                       
                                                 // execution                       
                                                 System.out.println(                                     "Child Thread"                                     );                       
                                                 }                       
                                                 };                       
           
                                                 // Starting the thread                       
                                                 t.start();                       
           
                                                 // Displaying main thread only for readability                       
                                                 System.out.println(                                     "Main Thread"                                     );                       
                                                 }                       
                         }                       

输出

Main ThreadChild Thread

类型2： 实现接口的匿名内部类

我们还可以有一个实现接口的匿名内部类。例如，我们还知道，通过实现Runnable接口，我们可以创建一个线程。这里我们使用一个实现接口的匿名内部类。

实例

JAVA

                         // Java program to illustrate defining a thread                       
                         // Using Anonymous Inner class that implements an interface                       
           
                         // Main class                       
                         class                                     MyThread {                       
                                   
                                                 // Main driver method                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 // Here we are using Anonymous Inner class                       
                                                 // that implements a interface i.e. Here Runnable                       
                                                 // interface                       
                                                 Runnable r =                                     new                                     Runnable() {                       
                                   
                                                 // run() method for the thread                       
                                                 public                                     void                                     run()                       
                                                 {                       
                                                 // Print statement when run() is invoked                       
                                                 System.out.println(                                     "Child Thread"                                     );                       
                                                 }                       
                                                 };                       
           
                                                 // Creating thread in main() using Thread class                       
                                                 Thread t =                                     new                                     Thread(r);                       
           
                                                 // Starting the thread using start() method                       
                                                 // which invokes run() method automatically                       
                                                 t.start();                       
           
                                                 // Print statement only                       
                                                 System.out.println(                                     "Main Thread"                                     );                       
                                                 }                       
                         }                       

输出

Main ThreadChild Thread

类型3： 定义内部方法/构造函数参数的匿名内部类

方法/构造函数参数中的匿名内部类通常用于图形用户界面（GUI）应用程序。为了让您熟悉语法，让我们看看下面的程序，它使用这种类型的匿名内部类创建线程

实例

JAVA

                         // Java program to illustrate defining a thread                       
                         // Using Anonymous Inner class that define inside argument                       
           
                         // Main class                       
                         class                                     MyThread {                       
                                                 // Main driver method                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 // Using Anonymous Inner class that define inside                       
                                                 // argument                       
                                                 // Here constructor argument                       
                                                 Thread t =                                     new                                     Thread(                                     new                                     Runnable() {                       
                                   
                                                 public                                     void                                     run()                       
                                                 {                       
                                                 System.out.println(                                     "Child Thread"                                     );                       
                                                 }                       
                                                 });                       
           
                                                 t.start();                       
           
                                                 System.out.println(                                     "Main Thread"                                     );                       
                                                 }                       
                         }                       

输出

Main ThreadChild Thread

但是，构造函数不能在匿名类中声明。本文由 尼森特·夏尔马 和 比沙尔·库马尔·杜比 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织 .查看你在GeekSforgeks主页上的文章，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java