Java 中内部类指的是声明在一个类内部的类，它可以访问外部类的私有变量和方法，而外部类不能直接访问内部类的成员。内部类的主要作用是为外部类提供一种封装和组织代码的方式。
内部类可以解决Java类单继承的问题，因为内部类和外部类可以相互访问。
类型： 内部类分为四种类型：
- 成员内部类（Member Inner Class）： 定义在外部类内部的非静态类。它可以访问外部类的成员。
- 静态内部类（Static Inner Class）： 定义在外部类内部的静态类。它不依赖于外部类的实例，可以直接通过外部类名访问。
- 局部内部类（Local Inner Class）： 定义在方法内部的类。它只在方法的作用域内可见。
- 匿名内部类（Anonymous Inner Class）： 没有显式类名的内部类，通常用于创建实现接口或继承类的匿名对象。
访问修饰符public仅适用于顶级类和成员类 ，不适用于本地类或匿名类。访问修饰符 protected和 private 仅适用于成员类。
static 修饰的类仅适用于成员类和本地类。
访问方式： 访问内部类的方式取决于内部类的型。类成员内部类通过外部类的实例访问，而静态内部类通过外部类名访问。成员类属于类的成员，所以可以调用外部类的 private 成员。外部类可以访问成员类的 private 成员
在外部类中创建成员内部类的实例：
java
public class OuterClass {
private int x = 10;
// 成员类
public class InnerClass {
public void print() {
System.out.println("x is " + x);
}
}
public static void main(String[] args) {
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.new InnerClass();
inner.print(); // 输出：x is 10
}
}局部内部类的定义方式如下：
java
class Outer {
void print() {
final int b = 5;
// 局部内部类
class Inner {
void print() {
System.out.println("b = " + b);
}
}
Inner inner = new Inner();
inner.print();
}
}匿名内部类的 定义方式如下：
匿名类不能使用修饰符，在方法的内部，对外隐藏。不能是 static ，隐式 final 类。匿
名类没有类名，没有构造方法。
java
interface A {
void print();
}
class Outer {
void print() {
// 匿名内部类
A a = new A() {
public void print() {
System.out.println("匿名内部类输出");
}
};
a.print();
}
}静态内部类的定义方式如下：
java
class Outer {
private static int c;
// 静态内部类
static class Inner {
void print() {
System.out.println("c = " + c);
}
}
}内部类的代码演示：
java
package com.member;
/**
* 成员类【内部类】
*/
public class Demo {
static int a;
static int B = 2;
static {
System.out.println("demo static{}");
}
static class DemoInner{
int c = 0;
static int a;
static int B = 4;
static {
System.out.println("Inner static{}");
}
public static void t(){
System.out.println(123);
}
public void test(){
System.out.println(Demo.B); // 调用外部类的静态变量
System.out.println(B); // 调用当前内部类的静态变量
System.out.println(this.B); // 调用当前内部类的静态变量
new Demo().new Demo3().test(); // 调用另一个非静态内部类的非静态方法
Demo.test(); // 调用外部类的静态方法
}
}
class Demo3{
static int B = 6;
static int a;
int c =12;
static {
System.out.println("demo3 static{}");
}
public void test(){
System.out.println(this.B); // 调用当前非静态类的静态变量
System.out.println(Demo.B); // 调用外部类的静态变量
// 在实例成员类中可以使用 外部类.this 表示外部类对象 (实例成员类是由外部类对象创建的)成员类中的 this 表示的是成员类
System.out.println(Demo.this.B); // 调用外部类的静态变量
}
}
public static void test(){
System.out.println(DemoInner.a);
System.out.println(Demo3.a);
new DemoInner().test(); // 调用静态内部类的非静态方法
}
}
class Test{
public static void main(String[] args) {
Demo.DemoInner i = new Demo.DemoInner();
System.out.println(i.c); // 调用内部类的实例变量
Demo.DemoInner.t(); //调用内部类的静态方法
int a = Demo.DemoInner.a; // 调用内部类的静态变量
int c = new Demo().new Demo3().c; // 调用非静态类的实例变量
int a1 = Demo.Demo3.a; // 调用非静态类的静态变量
Demo.Demo3 demo3 = new Demo().new Demo3();
Demo.test(); // 调用外部类的静态方法
}
}总结：内部类和外部类区别**?**
访问修饰符：
外部类只能有两种访问权限： public 以及 package - access
内部类可以有四种访问权限： public / protected / package - access / private
也就是说：访问修饰符public仅适用于顶级类和成员类，不适用于本地类或匿名类。访问修饰符 protected和 private 仅适用于成员类。
static 修饰： 外部类不可以使用 static 修饰类，内部类可以
使用：外部类可以直接被使用，内部类的使用则依赖于外部类