Java 内部类 是一个 class 在另一个类中定义。内部类的概念适用于使用外部类和内部类的嵌套 Java 类。定义内部类的主类称为外部类，外部类内的所有其他类称为 Java 内部类。
嵌套类
在Java中，就像方法，一个类的变量也可以有另一个类作为其成员。 Java 允许在另一个类中编写一个类。其中编写的类称为嵌套类，保存内部类的类称为外部类。
语法
以下是编写嵌套类的语法。这里，类Outer_Demo是外部类，类Inner_Demo是嵌套类。
class Outer_Demo {
class Inner_Demo {
}
} - 1
- 2
- 3
嵌套类分为两种类型
非静态嵌套类 - 这些是类的非静态成员。
静态嵌套类 - 这些是类的静态成员。
内部类（非静态嵌套类）
内部类是Java中的一种安全机制。我们知道一个类不能与 访问修饰符 private 关联，但是如果我们将该类作为是其他类的成员，那么内部类可以设为私有。这也用于访问类的私有成员。
Java 内部类的类型
内部类分为三种类型，具体取决于定义它们的方式和位置。它们是 -
- 内部类
- 方法本地内部类
- 匿名内部类
创建内部类
创建内部类非常简单。您只需要在类中编写一个类即可。与类不同，内部类可以是私有的，一旦将内部类声明为私有，就无法从类外部的对象访问它。
以下是创建内部类并访问它的程序。在给定的示例中，我们将内部类设为私有并通过方法访问该类。
示例:在 Java 中创建内部类
class Outer_Demo {
int num;
//内部类
private class Inner_Demo {
public void print() {
System.out.println("This is an inner class");
}
}
// 从内部类中的方法访问内部类
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();
}
} - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
在这里您可以观察到 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(); - 1
以下程序演示如何使用内部类访问类的私有成员。
class Outer_Demo {
//外部类的私有变量
private int num = 175;
//内部类
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[]) {
//实例化外部类
Outer_Demo outer = new Outer_Demo();
//实例化内部类
Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
System.out.println(inner.getNum());
}
} - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
以下程序演示如何使用内部类访问类的私有成员。 p>
示例:使用内部类访问私有成员
This is the getnum method of the inner class: 175 如果编译并执行上述程序，您将得到以下结果 -
输出
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();
}
} - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
方法本地内部类
在Java中，我们可以在方法中编写一个类，这将是一个本地类型。与局部变量一样，内部类的作用域也限制在方法内。
方法局部内部类只能在定义该内部类的方法内实例化。下面的程序展示了如何使用方法局部内部类。
示例:方法局部内部类
This is method inner class 23 如果编译并执行上述程序，您将得到以下结果结果 -
输出
AnonymousInner an_inner = new AnonymousInner() {
public void my_method() {
........
........
}
}; - 1
- 2
- 3
- 4
- 5
匿名内部类
没有类名声明的内部类称为匿名内部类 。对于匿名内部类，我们同时声明和实例化它们。通常，每当您需要重写类或接口的方法时，就会使用它们。匿名内部类的语法如下 -
语法:匿名内部类
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();
}
} - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
下面的程序演示如何使用匿名内部类重写类的方法。
示例:匿名内部类
This is an example of anonymous inner class 如果编译并执行上述程序，您将得到以下结果 -
输出
obj.my_Method(new My_Class() {
public void Do() {
.....
.....
}
}); - 1
- 2
- 3
- 4
- 5
以同样的方式，您可以使用匿名内部类重写具体类的方法以及接口。
匿名内部类作为参数
通常，如果方法接受接口、抽象类或具体类的对象，那么我们可以实现接口，扩展抽象类，并将对象传递给方法。如果它是一个类，那么我们可以直接将它传递给方法。
但是在所有三种情况下，您都可以将匿名内部类传递给方法。以下是将匿名内部类作为方法参数传递的语法 -
//接口
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";
}
});
}
} - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
以下程序演示如何将匿名内部类作为方法参数传递。
示例
Hello, This is an example of anonymous inner class as an argument 如果编译并执行上面的程序，它会给出以下结果 -
输出
class MyOuter {
static class Nested_Demo {
}
} - 1
- 2
- 3
静态嵌套类
静态内部类class 是嵌套类，它是外部类的静态成员。可以使用其他静态成员来访问它，而无需实例化外部类。就像静态成员一样，静态嵌套类无法访问外部类的实例变量和方法。静态嵌套类的语法如下 -
语法
实例化静态嵌套类与实例化内部类有点不同。下面的程序展示了如何使用静态嵌套类。
示例
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();
}
} - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
如果编译并执行上述程序，您将得到以下结果 -
输出
This is my nested class