极客教程Java 内部类
在这一章中，我们将讨论Java的内部类。
嵌套类
在Java中，就像方法一样，类的变量也可以有另一个类作为其成员。在Java中允许在一个类内部编写另一个类。内部编写的类称为 嵌套类，持有内部类的类称为 外部类 。
语法
以下是编写嵌套类的语法。这里，类 Outer_Demo 是外部类，类 Inner_Demo 是嵌套类。
class Outer_Demo {
class Inner_Demo {
}
}
嵌套类分为两种类型 –
- 非静态嵌套类 - 这些是类的非静态成员。
-
静态嵌套类 - 这些是类的静态成员。
内部类（非静态嵌套类）
内部类是Java中的一种安全机制。我们知道一个类不能与访问修饰符private关联，但是如果我们将类作为另一个类的成员，那么内部类可以声明为private。并且这也用于访问类的私有成员。
内部类根据定义方式和位置分为三种类型。它们是：
- 内部类
- 方法局部内部类
- 匿名内部类
内部类
创建内部类非常简单。只需要在一个类中编写另一个类。与类不同，内部类可以是私有的，并且一旦您声明了一个内部类为私有的，就无法从类外部的对象访问它。
以下是创建内部类并访问它的程序。在给定的示例中，我们将内部类设为私有，并通过一个方法访问该类。
示例
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