内部类分为以下四种：
- 静态内部类
- 成员内部类
- 局部内部类
- 匿名内部类
一、静态内部类
静态内部类： 在类中用static关键字声明的内部类。
静态内部类不依赖于外围类对象实例而独立存在
静态内部类的可以访问外围类中的所有静态成员，包括private的静态成员。
同时静态内部类可以说是所有内部类中独立性最高的内部类，其创建对象、继承（实现接口）、扩展子类等使用方式与外围类并没有多大的区别。
public class OuterClass {//外部类
public int aa; //普通成员变量
private static float f = 1.5f;//private的静态成员
static void myPrintln() {
System.out.println("静态方法");
}
protected static class StaticInnerClass{//protected的静态内部类
float a;
public StaticInnerClass() {
a = f;// 外围类的private静态变量
myPrintln();//外围类的静态方法
}
}
}
class OtherClass{
public static void main(String[] args) {
//创建静态内部类的对象
OuterClass.StaticInnerClass staticInnerClass = new OuterClass.StaticInnerClass();
}
}
二、成员内部类
成员内部类是最普通的内部类，它的定义为位于一个类的内部
成员内部类可以访问外部类的所有成员属性和成员方法（包括静态成员，可以拥有private访问权限、protected访问权限、public访问权限及包访问权限）
成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。
成员内部类是不可以声明静态成员（包括静态变量、静态方法、静态成员类、嵌套接口）,但有个例外：可以声明 static final的变量， 这是因为编译器对final类型的特殊处理，是直接将值写入字节码
成员内部类对象都隐式地保存了一个引用，指向创建它的外部类对象；或者说，成员内部类的入口是由外围类的对象保持着（静态内部类的入口，则直接由外围类保持着）
成员内部类中的 this关键字：
- 获取外部类对象：OuterClass.this
- 明确指定使用外部类的成员（当内部类与外部类的名字冲突时）：
OuterClass.this.成员名
成员内部类访问外部类成员
当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，默认情况下访问的是成员内部类的成员。
如果要访问外部类的同名成员，需要以下面的形式进行访问：
- 外部类.this.成员变量
- 外部类.this.成员方法
外部类访问成员内部类的成员
1.先创建一个成员内部类的对象
2.再通过指向这个对象的引用来访问。
创建成员内部类对象的一般方式：
在外部类的成员方法中创建成员内部类 （内部类名 对象名=new 内部类名();）与 在其他类中或静态方法中创建成员内部的方式是不一样的
public class Test {
public static void main(String[] args) {
//第一种方式：
Outter outter = new Outter();
Outter.Inner inner = outter.new Inner(); //必须通过Outter对象来创建
//第二种方式：
Outter.Inner inner1 = outter.getInnerInstance();
}
}
///////////////////////////////////////////////////////////////////////////////
class Outter {
private Inner inner = null;
public Outter() {
}
public Inner getInnerInstance() {
if(inner == null)
inner = new Inner();
return inner;
}
class Inner {
public Inner() {
}
}
}
上面的例子，如果成员内部类Inner用private修饰，则只能在外部类的内部访问，如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。这一点和外部类有一点不一样，外部类只能被public和包访问两种权限修饰。我个人是这么理解的，由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰。
成员内部类被继承
在内部类的访问权限允许的情况下，成员内部类也是可以被继承的。由于成员内部类的对象依赖于外围类的对象。因此，继承了成员内部类的子类必须要与一个外围类对象关联起来。同时，子类的构造器是必须要调用父类的构造器方法，所以也只能通过父类的外围类对象来调用父类构造器。
class ChildClass extends OuterClass.InnerClass{
//成员内部类的子类的构造器的格式
public ChildClass(OuterClass outerClass) {
outerClass.super();//通过外围类的对象调用父类的构造方法
}
}
三、局部内部类
局部内部类： 就是在方法、构造器、初始化块中声明的类，在结构上类似于一个局部变量。
局部内部类的访问仅限于方法内或者该作用域内,局部内部类是不能使用访问修饰符。
局部内部类只能访问final的局部变量
局部内部类定义在实例环境中（构造器、对象成员方法、实例初始化块），则可以访问外围类的所有成员；但如果内部类定义在静态环境中（静态初始化块、静态方法），则只能访问外围类的静态成员
public class OuterClass {
private int a = 21;
static {//静态域中的局部内部类
class LocalClass1{
// int z = a; //错误，在静态的作用域中无法访问对象成员
}
}
{//实例初始化块中的局部内部类
class localClass2{
}
}
public OuterClass(){
int x = 2;
final int y = 3;
// x = 3;//若放开此行注释，编译无法通过，因为局部变量x已经是final类型
//构造器中的局部内部类
class localClass3{
int z = y; //可以访问final的局部变量
int b = a;//可以访问类的所有成员
//访问没有用final修饰的局部变量
int c = x;
}
}
public void createRunnable() {
final int x = 4;
//方法中的局部内部类
class LocalClass4 implements Runnable {//
@Override
public void run() {
System.out.println("局部final变量："+x);
System.out.println("对象成员变量："+a);
}
}
}
}
四、匿名内部类
匿名内部类也是不能有访问修饰符和static修饰符的。
匿名内部类是唯一一种没有构造器的类。正因为其没有构造器，所以匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调。匿名内部类在编译的时候由系统自动起名为Outter$1.class、Outter$2.class。一般来说，匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。
在创建这个匿名内部类后，便会立即用来创建并返回此内部类的一个对象引用。
作用：
匿名内部类用于隐式继承某个类（重写里面的方法或实现抽象方法）或者实现某个接口。
匿名内部类的访问限制：
在实例环境中（构造器、对象成员方法、实例初始化块），则可以访问外围类的所有成员；但如果内部类定义在静态环境中（静态初始化块、静态方法），则只能访问外围类的静态成员
匿名内部类的优缺点：
优点：
编码方便快捷；缺点：
只能继承一个类或实现一个接口，不能再继承其他类或其他接口。
只能用于创建一次对象实例；
一个例子：
class MyOuterClass {
private int x = 5;
void createThread() {
final int a = 10;
int b = 189;
// 匿名内部类继承Thread类，并重写Run方法
Thread thread = new Thread("thread-1") {
int c = x; //访问成员变量
int d = a; //final的局部变量
int e = b; //访问没有用final修饰的局部变量
@Override
public void run() {
System.out.println("这是线程thread-1");
}
};
// 匿名内部类实现Runnable接口
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("线程运行中");
}
};
}
}
内部类嵌套内部类
- 成员内部类可以继续包含成员内部类，而且不管一个内部类被嵌套了多少层，它都能透明地访问它的所有外部类所有成员；
- 成员内部类可以继续嵌套多层的成员内部类，但无法嵌套静态内部类；
- 静态内部类则都可以继续嵌套这两种内部类。
下面的例子是基于上面的例子进行改造：
class InnerClass{//成员内部类
private double aa; //与围类的变量aa的名字重复
public InnerClass(){
this.aa = OuterClass.this.aa + f;//明确指定两个aa的所属
initInnerClass();
}
public class InnerInnerCalss2{//成员内部类中的成员内部类
protected double aa = OuterClass.this.aa;//最外层的外围类的成员变量
}//InnerInnerCalss2
}//InnerClass
总结
| 类 型 | 访问修饰符 | 声明静态成员 | 绑定外围类 |
|---|---|---|---|
| 静态内部类 | 四种访问修饰符 | 可以声明 | 不绑定 |
| 成员内部类 | 四种访问修饰符 | 除 final static 的变量外，其余静态成员都不行 | 绑定 |
| 局部内部类 | 不可以声明 | 不可以声明 | 取决于此内部类的声明环境 |
| 局部内部类 | 不可以声明 | 不可以声明 | 取决于此内部类的声明环境 |
为什么在Java中需要内部类
1. 每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整，
2. 方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。
3. 方便编写事件驱动程序
4. 方便编写线程代码