在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("This is an内部类");
}
}
// Accessing he内部类 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[]) {
//实例化外部类
Outer_Demo outer = new Outer_Demo();
//访问display_Inner()方法。
outer.display_Inner();
}
}在这里，您可以观察到Outer_Demo是外部类，Inner_Demo是内部类，display_Inner()是在其中实例化内部类的方法，并且该方法是从main方法调用的。
如果编译并执行上述程序，您将得到以下结果。
输出结果
This is an内部类.
如前 ，内部类也用于访问类的私有成员。假设某个类有私有成员可以访问它们。在其中编写一个内部类，从内部类中的方法（如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("This is the getnum method of the内部类");
return num;
}
}
}
public class My_class2 {
public static void main(String args[]) {
//实例化外部类
Outer_Demo outer = new Outer_Demo();
// Instantiating the内部类
Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
System.out.println(inner.getNum());
}
}如果编译并执行上述程序，您将得到以下结果。
输出结果
This is the getnum method of the内部类: 175
在Java中，我们可以在方法中编写类，而这将是局部类型。与局部变量一样，内部类的范围也受方法限制。
只能在定义内部类的方法内实例化方法本地内部类。以下程序显示了如何使用方法本地的内部类。
例
public class Outerclass {
//外部类的实例方法
void my_Method() {
int num = 23;
// method-local内部类
class MethodInner_Demo {
public void print() {
System.out.println("This is method内部类 "+num);
}
} // end of内部类
// Accessing the内部类
MethodInner_Demo inner = new MethodInner_Demo();
inner.print();
}
public static void main(String args[]) {
Outerclass outer = new Outerclass();
outer.my_Method();
}
}如果编译并执行上述程序，您将得到以下结果。
输出结果
This is method内部类 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.mymethod();
}
}如果编译并执行上述程序，您将得到以下结果。
输出结果
This is an example of anonymous内部类
以相同的方式，您可以使用匿名内部类覆盖具体类的方法以及接口。
通常，如果方法接受接口，抽象类或具体类的对象，则我们可以实现接口，扩展抽象类并将对象传递给方法。如果它是一个类，那么我们可以直接将其传递给方法。
但是在这三种情况下，都可以将匿名内部类传递给该方法。这是将匿名内部类作为方法参数传递的语法。
obj.my_Method(new My_Class() {
public void Do() {
.....
.....
}
});以下程序显示了如何将匿名内部类作为方法参数传递。
// interface
interface Message {
String greet();
}
public class My_class {
//对象的方法
public void displayMessage(Message m) {
System.out.println(m.greet() + ", This is an example of anonymous内部类 as an argument");
}
public static void main(String args[]) {
//实例化类
My_class obj = new My_class();
// Passing an anonymous内部类 as an argument
obj.displayMessage(new Message() {
public String greet() {
return "Hello";
}
});
}
}如果编译并执行上述程序，它将为您提供以下结果。
输出结果
Hello, This is an example of anonymous内部类 as an argument