在Java中,就像方法一样,类的变量也可以将另一个类作为它的成员。 在Java中允许在一个类中编写另一个类。 在其中编写的类称为嵌套类,而保存内部类的类称为外部类。
语法
以下是编写嵌套类的语法。 这里,类OuterDemo
是外部类,而类InnerDemo
是嵌套类。
class OuterDemo {
class InnerDemo {
}
}
嵌套类分为两种类型 -
- 非静态嵌套类 - 这些是类的非静态成员。
- 静态嵌套类 - 这些是类的静态成员。
1. 内部类(非静态嵌套类)
内部类是Java中的安全机制。 我们知道一个类不能与private
访问修饰符关联,但如果将该类作为其他类的成员,那么内部类可以变为private
。 这也用于访问类的私有成员。
内部类有三种类型,具体取决于定义它们的方式和位置。它们分别是 -
- 内部类
- 方法-局部内部类
- 匿名内部类
1.1. 内部类
创建内部类非常简单,只需要在一个类中编写一个类。 与类不同,内部类可以是私有的,当将内部类声明为private
,就无法从类外部的对象访问它。
以下是创建内部类并访问它的程序。 在示例中,将内部类设为private
,并通过方法访问类。
示例
class OuterDemo {
int num;
// 内部类
private class InnerDemo {
public void print() {
System.out.println("This is an inner class");
}
}
// 从内部方法访问他的内部类
void display_Inner() {
InnerDemo inner = new InnerDemo();
inner.print();
}
}
public class Myclass {
public static void main(String args[]) {
// 实例化外部类
OuterDemo outer = new OuterDemo();
// 访问 display_Inner()方法。
outer.display_Inner();
}
}
在示例中OuterDemo
是外部类,InnerDemo
是内部类,display_Inner()
是在其中实例化内部类的方法,并且这个方法是从main
方法调用的。
编译并执行上述程序,将得到以下结果 -
This is an inner class.
访问私有成员
如前所述,内部类也用于访问类的私有成员。 假设,一个类想要让私有成员访问,可从内部类中的方法返回私有成员。
要实例化内部类,最初必须实例化外部类。 此后,使用外部类的对象访问内部类,以下是实例化内部类的方法。
OuterDemo outer = new OuterDemo();
OuterDemo.InnerDemo inner = outer.new InnerDemo();
以下程序显示如何使用内部类访问类的私有成员。
class OuterDemo {
// 外部类的私有变量
private int num = 175;
// 内部类
public class InnerDemo {
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[]) {
// 实例化外部类
OuterDemo outer = new OuterDemo();
// 实例化内部类
OuterDemo.InnerDemo inner = outer.new InnerDemo();
System.out.println(inner.getNum());
}
}
编译并执行上述程序,将得到以下结果 -
This is the getnum method of the inner class: 175
1.2. 方法-局部内部类
在Java中,可以在方法中编写一个类,这将是一个局部类型。与局部变量一样,内部类的范围在方法中受到限制。
方法局部内部类只能在定义内部类的方法中实例化。 以下程序显示了如何使用方法局部内部类。
示例
public class Outerclass {
// 外部类的实例方法
void my_Method() {
int num = 23;
// 方法局部内部类
class MethodInnerDemo {
public void print() {
System.out.println("This is method inner class "+num);
}
} // end of inner class
// 访问内部类
MethodInnerDemo inner = new MethodInnerDemo();
inner.print();
}
public static void main(String args[]) {
Outerclass outer = new Outerclass();
outer.my_Method();
}
}
编译并执行上述程序,将得到以下结果 -
This is method inner class 23
1.3. 匿名内部类
声明没有类名的内部类称为匿名内部类。 在匿名内部类中,同时声明并实例化内部类。 通常,只要需要覆盖类或接口的方法,就会使用它们。 匿名内部类的语法如下 -
语法
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
以同样的方式,可以使用匿名内部类覆盖具体类的方法以及接口。
2. 匿名内部类作为参数
通常,如果方法接受接口,抽象类或具体类的对象,那么可以实现接口,扩展抽象类,并将对象传递给方法。如果它是一个类,那么可以直接将它传递给方法。
在这三种情况下,都可以将匿名内部类传递给方法。 以下是将匿名内部类作为方法参数传递的语法 -
obj.my_Method(new My_Class() {
public void Do() {
.....
.....
}
});
以下程序演示如何将匿名内部类作为方法参数传递。
// 定义接口
interface Message {
String greet();
}
public class Myclass {
// 接受接口 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[]) {
// 实例化类
Myclass obj = new Myclass();
// 传递匿名内部类作为参数
obj.displayMessage(new Message() {
public String greet() {
return "Hello";
}
});
}
}
编译并执行上述程序,将得到以下结果 -
Hello, This is an example of anonymous inner class as an argument
3. 静态嵌套类
静态内部类是嵌套类,它是外部类的静态成员。 可以使用其他静态成员在不实例化外部类的情况下访问它。 就像静态成员一样,静态嵌套类无法访问外部类的实例变量和方法。 静态嵌套类的语法如下 -
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