Java 简明教程

Java - Inner classes

Java Inner Class

Java inner class 是 class ，一个在另一个类中定义的类。内部类的概念配合使用嵌套 Java 类，其中使用外部类和内部类。定义内部类的主类称为外部类，外部类中的所有其他类被称为 Java inner classes 。

Nested Classes

在 Java 中，与 methods 一样， variables of a class 也可以具有另一个类作为其成员。允许在 Java 中编写一个类到另一个类中。编写在其中的类称为 nested class ，容纳内部类的类称为 outer class 。

Syntax

以下是要写一个嵌套类的语法。这里，类 Outer_Demo 是外部类，类 Inner_Demo 是嵌套类。

class Outer_Demo {
   class Inner_Demo {
   }
}

嵌套类分为两种 −

  1. Non-static nested classes − 这些是一个类的非静态成员。

  2. Static nested classes − 这些是一个类的静态成员。

inner classes

Inner Classes (Non-static Nested Classes)

内部类是 Java 中的安全机制。我们知道一个类不能与 access modifier private 关联，但如果我们将类作为其他类的成员，则内部类可以被设为私有的。这还用于访问一个类的私有成员。

Types of Java Inner Classes

根据定义它们的位置和方式，内部类有三种类型。它们是 −

  1. Inner Class

  2. Method-local Inner Class

  3. Anonymous Inner Class

Creating an Inner Class

创建内部类很简单。你只需要在一个类中写一个类。与类不同，内部类可以是私有的，一旦你将内部类声明为私有的，则无法通过该类外部的对象访问。

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

Example: Creating an inner class in 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 是内部类，我们在这个方法中实例化内部类，并且从 main 方法调用此方法。

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

This is an inner class.

Accessing the Private Members

如前所述，内部类还用来访问类的私有成员。假设一个类有要访问它们的私有成员。在其中写一个内部类，从内部类中的一个方法（例如 getValue()）中返回私有成员，最后从另一个类（你要从中访问私有成员的类）调用内部类的 getValue() 方法。

要实例化内部类，首先必须实例化外部类。此后，使用外部类的对象，以下是实例化内部类的方法。

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

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

Example: Accessing the Private Members Using Inner Class

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

Method-local Inner Class

在 Java 中，我们可以在一个方法中写一个类，它将成为一个局部类型。与局部变量一样，内部类的范围限制在方法内。

方法局部内部类只能在定义内部类的方法中实例化。以下程序演示如何使用方法局部内部类。

Example: Method-local Inner Class

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

Anonymous Inner Class

未声明类名的内部类称为 anonymous inner class。对于匿名内部类，我们同时声明和实例化它们。通常，每当你需要重写类或接口的方法时，它们就会被使用。匿名内部类的语法如下 −

Syntax: Anonymous Inner Class

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

以下程序演示如何使用匿名内部类重写类的类。

Example: Anonymous Inner Class

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

同样，你也可以使用匿名内部类重写具体类和接口的方法。

Anonymous Inner Class as Argument

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

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

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

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

Example

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

Static Nested Class

静态内部类是一个嵌套类，它是外部类的静态成员。可以使用其他静态成员在不实例化外部类的情况下访问它。与静态成员一样，静态嵌套类无权访问外部类的实例变量和方法。静态嵌套类的语法如下-

Syntax

class MyOuter {
   static class Nested_Demo {
   }
}

实例化一个静态嵌套类与实例化一个内部类略有不同。以下程序演示了如何使用静态嵌套类。

Example

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