Java - 内部类

在本章中，我们将讨论Java的内部类.

嵌套类

在Java中，就像方法一样，类的变量也可以有另一个类作为其成员.在Java中允许在另一个类中编写类.在其中编写的类称为嵌套类，保存内部类的类称为外部类.

语法

以下是编写嵌套类的语法.这里，类 Outer_Demo 是外部类，类 Inner_Demo 是嵌套类.

class Outer_Demo {   class Inner_Demo {   }}

嵌套类分为两种类型 :

• 非静态嵌套类 : 这些是类的非静态成员.

• 静态嵌套类 : 这些是类的静态成员.

内部类(非静态嵌套类)

内部类是Java中的安全机制.我们知道一个类不能与访问修饰符 private 相关联，但是如果我们将该类作为其他类的成员，则可以将内部类设为私有.这也用于访问类的私有成员.

内部类有三种类型，具体取决于您定义它们的方式和位置.它们是 :

• 内部类

• 方法本地内部类

• 匿名内部类

内部类

创建内部类非常简单.你只需要在一个类中编写一个类.与类不同，内部类可以是私有的，一旦您将内部类声明为私有，就无法从类外部的对象访问它.

以下是创建内部类的程序并访问它.在给定的示例中，我们将内部类设为私有，并通过方法访问该类.

示例

class Outer_Demo {   int num;      // inner class   private class Inner_Demo {      public void print() {         System.out.println("This is an inner class");      }   }      // Accessing he inner class from the method within   void display_Inner() {      Inner_Demo inner = new Inner_Demo();      inner.print();   }}   public class My_class {   public static void main(String args[]) {      // Instantiating the outer class       Outer_Demo outer = new Outer_Demo();            // Accessing the display_Inner() method.      outer.display_Inner();   }}

在这里你可以观察到 Outer_Demo 是外层类， Inner_Demo 是内部类， display_Inner()是我们在其中实例化内部类的方法，并且从 main 方法调用此方法.

如果您编译并执行上述程序，您将得到以下结果 :

输出

This is an inner class.

访问私有成员

如前所述，内部类也用于访问类的私有成员.假设，一个类正在让私有成员访问它们.在其中编写一个内部类，从内部类中的方法返回私有成员，比如， getValue()，最后从另一个类(从中想要访问私有成员)调用内部类的getValue()方法.

要实例化内部类，最初必须实例化外部类.此后，使用外部类的对象，以下是您可以实例化内部类的方法.

Outer_Demo outer = new Outer_Demo();Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();

以下程序显示了如何使用内部类访问类的私有成员.

示例

class Outer_Demo {   // private variable of the outer class   private int num = 175;        // inner class   public class Inner_Demo {      public int getNum() {         System.out.println("This is the getnum method of the inner class");         return num;      }   }}public class My_class2 {   public static void main(String args[]) {      // Instantiating the outer class      Outer_Demo outer = new Outer_Demo();            // Instantiating the inner class      Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();      System.out.println(inner.getNum());   }}

如果您编译并执行上述程序，您将得到以下结果 :

输出

This is the getnum method of the inner class: 175

方法本地内部类

在Java中，我们可以在方法中编写一个类，这将是一个本地类型.与局部变量一样，内部类的范围在方法中受到限制.

方法本地内部类只能在定义内部类的方法中实例化.以下程序显示了如何使用方法本地内部类.

示例

public class Outerclass {   // instance method of the outer class    void my_Method() {      int num = 23;      // method-local inner class      class MethodInner_Demo {         public void print() {            System.out.println("This is method inner class "+num);            }         } // end of inner class         // Accessing the inner class      MethodInner_Demo inner = new MethodInner_Demo();      inner.print();   }      public static void main(String args[]) {      Outerclass outer = new Outerclass();      outer.my_Method();         }}

如果您编译并执行上述程序，您将得到以下结果 :

输出

This is method inner class 23

匿名内部类

声明没有类名的内部类称为匿名内部类.在匿名内部类的情况下，我们同时声明并实例化它们.通常，只要您需要覆盖类或接口的方法，就会使用它们.匿名内部类的语法如下 :

语法

AnonymousInner an_inner = new AnonymousInner() {   public void my_method() {      ........      ........   }   };

以下程序显示如何使用匿名内部类覆盖类的方法.

示例

abstract class AnonymousInner {   public abstract void mymethod();}public class Outer_class {   public static void main(String args[]) {      AnonymousInner inner = new AnonymousInner() {         public void mymethod() {            System.out.println("This is an example of anonymous inner class");         }      };      inner.mymethod();   }}

如果您编译并执行上述程序，您将得到以下结果 :

输出

This is an example of anonymous inner class

以同样的方式，您可以使用匿名内部类覆盖具体类的方法以及接口.
匿名内部类as Argument
通常，如果方法接受接口，抽象类或具体类的对象，那么我们可以实现接口，扩展抽象类，并传递对象方法.如果它是一个类，那么我们可以直接将它传递给方法.
但在所有这三种情况下，你都可以将一个匿名内部类传递给该方法.以下是将匿名内部类作为方法参数传递并减去的语法;
obj.my_Method(new My_Class() {   public void Do() {      .....      .....   }});
 
以下程序显示如何将匿名内部类作为方法参数传递.
示例 
// interfaceinterface Message {   String greet();}public class My_class {   // method which accepts the object of interface Message   public void displayMessage(Message m) {      System.out.println(m.greet() +         ", This is an example of anonymous inner class as an argument");     }   public static void main(String args[]) {      // Instantiating the class      My_class obj = new My_class();      // Passing an anonymous inner class as an argument      obj.displayMessage(new Message() {         public String greet() {            return "Hello";         }      });   }}
 
如果编译并执行上述程序，它会给你以下结果 :
输出 
 Hello, This is an example of anonymous inner class as an argument
 
静态嵌套类
静态内部类是嵌套类，它是外部类的静态成员.可以使用其他静态成员在不实例化外部类的情况下访问它.就像静态成员一样，静态嵌套类无法访问外部类的实例变量和方法.静态嵌套类的语法如下 :
语法 
class MyOuter {   static class Nested_Demo {   }}
 
实例化静态嵌套类与实例化内部类.以下程序显示了如何使用静态嵌套类.
示例  
public class Outer {   static class Nested_Demo {      public void my_method() {         System.out.println("This is my nested class");      }   }      public static void main(String args[]) {      Outer.Nested_Demo nested = new Outer.Nested_Demo();       nested.my_method();   }}
 
如果您编译并执行上述程序，您将得到以下结果 :
输出 
 This is my nested class