Java - 内部类

---

---

Java 内部类

Java 内部类是在另一个类内部定义的类。内部类的概念与嵌套 Java 类一起使用，其中使用外部类和内部类。定义内部类的主要类称为外部类，而外部类内部的所有其他类都称为Java 内部类。

嵌套类

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

语法

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

class Outer_Demo {
   class Inner_Demo {
   }
}

嵌套类分为两种类型 -

• 非静态嵌套类 - 这些是类的非静态成员。

• 静态嵌套类 - 这些是类的静态成员。

内部类（非静态嵌套类）

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

Java 内部类的类型

内部类根据您定义它们的方式和位置分为三种类型。它们是 -

• 内部类
• 方法局部内部类
• 匿名内部类

创建内部类

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

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

示例：在 Java 中创建内部类

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

以相同的方式，您可以使用匿名内部类覆盖具体类和接口的方法。

匿名内部类作为参数

通常，如果一个方法接受接口、抽象类或具体类的对象，那么我们可以实现接口、扩展抽象类并将对象传递给方法。如果是类，我们可以直接将其传递给方法。

但在所有三种情况下，您都可以将匿名内部类作为参数传递给方法。以下是将匿名内部类作为方法参数传递的语法 -

obj.my_Method(new My_Class() {
   public void Do() {
      .....
      .....
   }
});

以下程序展示了如何将匿名内部类作为方法参数传递。

示例

// interface
interface 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