Java 内部类
嵌套类
在 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