java 内部类——迹忆客-ag捕鱼王app官网

嵌套类

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

语法

以下是编写嵌套类的语法。 这里，outer_demo 类是外部类，inner_demo 类是嵌套类。

class outer_demo {
   class inner_demo {
   }
}

嵌套类分为两种类型

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

内部类（非静态嵌套类）

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

内部类分为三种类型，具体取决于定义它们的方式和位置。 他们是

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

内部类

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

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

class outer_demo {
   int num;
   
   // 内部类
   private class inner_demo {
      public void print() {
         system.out.println("这是一个内部类！");
      }
   }
   
   // 从内部的方法访问他的内部类
   void display_inner() {
      inner_demo inner = new inner_demo();
      inner.print();
   }
}
   
public class my_class {
   public static void main(string args[]) {
      // 实例化外部类
      outer_demo outer = new outer_demo();
      
      // 访问 display_inner() 方法。
      outer.display_inner();
   }
}

这里可以观察到outer_demo是外部类，inner_demo是内部类，display_inner()是我们在里面实例化内部类的方法，这个方法是从 main 方法调用的。

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

这是一个内部类！

访问私有成员

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

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

outer_demo outer = new outer_demo();
outer_demo.inner_demo inner = outer.new inner_demo();

下面的程序展示了如何使用内部类访问类的私有成员。

class outer_demo {
   // 外部类的私有变量
   private int num = 175;  
   
   // 内部类
   public class inner_demo {
      public int getnum() {
         system.out.println("这是内部类的getnum方法");
         return num;
      }
   }
}
public class my_class2 {
   public static void main(string args[]) {
      // 实例化外部类
      outer_demo outer = new outer_demo();
      
      // 实例化内部类
      outer_demo.inner_demo inner = outer.new inner_demo();
      system.out.println(inner.getnum());
   }
}

如果你编译并执行上面的程序，你会得到如下结果

这是内部类的getnum方法: 
175

方法局部内部类

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

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

public class outerclass {
   // 外部类的实例方法
   void my_method() {
      int num = 23;
      // 方法局部内部类
      class methodinner_demo {
         public void print() {
            system.out.println("this is method inner class " num);       
         }   
      }
       
      // 访问内部类
      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 message {
   string greet();
}
public class my_class {
   // 接受接口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[]) {
      my_class obj = new my_class();
      // 将匿名内部类作为参数传递
      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 main {
   static class nested_demo {
      public void my_method() {
         system.out.println("this is my nested class");
      }
   }
   
   public static void main(string args[]) {
      main.nested_demo nested = new main.nested_demo();     
      nested.my_method();
   }
}

如果你编译并执行上面的程序，你会得到如下结果

this is my nested class