Java内部类

什么是内部类

在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。
语法格式：

public class OutClass {
 class InnerClass{
 }
}

OutClass为外部类,InnerClass为内部类。
注意

1. 定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类

public class A{
 
}
class B{
 
}
// A 和 B是两个独立的类，彼此之前没有关系

2. 内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

内部类的分类

根据内部类定义的位置不同，可将内部类分为以下形式：
1.成员内部类
2.局部内部类，匿名内部类

成员内部类

在外部类中，内部类定义位置与外部类成员所处的位置相同，因此称为成员内部类。根据是否被ststic修饰，又可以分为普通内部类和静态内部类。

普通内部类

即未被static修饰的成员内部类。
例：

public class OutClass {
    private int a;
    static int b;
    int c;
    public void methodA(){
        a = 10;
        System.out.println(a);
    }
    public static void methodB(){
        System.out.println(b);
    }
    class InnerClass{
        int c;
        public void methodInner(){
            a=10;
            b=20;//可直接访问外部成员
            c=2;//内部类变量名与外部类变量名相同，优先访问内部类
            methodA();
            methodB();
            //访问外部的c
            OutClass.this.c=30;
            System.out.println(OutClass.this.c);
        }
    }

    public static void main(String[] args) {
        OutClass outClass=new OutClass();
        InnerClass innerClass=outClass.new InnerClass();//要创建内部类对象，要先创建外部类对象。
        innerClass.methodInner();
    }
}

注意

1. 外部类中的任何成员都可以被在普通内部类方法中直接访问
2. 普通内部类所处的成员与外部类成员位置相同，因此也受public、private等访问限定符的约束
   如：

protected class InnerClass{
        int c;
        public void methodInner(){
            a=10;
            b=20;//可直接访问外部成员
            c=2;//内部类变量名与外部类变量名相同，优先访问内部类
            methodA();
            methodB();
            //访问外部的c
            OutClass.this.c=30;
            System.out.println(OutClass.this.c);
        }
    }
//-------------------------------
//下面的类与上述类来自同一包的不同类，编译成功
    public class TestInner {
    public static void main(String[] args) {
        OutClass outClass=new OutClass();
        OutClass.InnerClass innerClass=outClass.new InnerClass();
    }
//---------------------------------
//下面的类与开头的类不同包
public class TestInner {
    public static void main(String[] args) {
        OutClass outClass=new OutClass();
        OutClass.InnerClass innerClass=outClass.new InnerClass();
    }
}
//编译失败java: day20210915.InnerClass.OutClass.InnerClass 
//在 day20210915.InnerClass.OutClass 中是 protected 
//访问控制

3. 在内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员 来访问.
4. 普通内部类对象必须在先有外部类对象前提下才能创建.
5. 普通内部类的非静态方法中包含了一个指向外部类对象的引用,用字节码证明
   
6. 外部类中，不能直接访问内部类中的成员，如果要访问必须先要创建外部类的对象.

静态内部类

被static修饰的内部成员类称为静态内部类。

public class OutClass {
 private int a;
 static int b;
 public void methodA(){
 a = 10;
 System.out.println(a);
 }
 public static void methodB(){
 System.out.println(b);
 }
 // 静态内部类：被static修饰的成员内部类
 static class InnerClass{
 public void methodInner(){
 // 在内部类中只能访问外部类的静态成员
 // a = 100; // 编译失败，因为a不是类成员变量
 b =200;
 // methodA(); // 编译失败，因为methodB()不是类成员方法
 methodB();
 }
 }
 public static void main(String[] args) {
 // 静态内部类对象创建 & 成员访问
 OutClass.InnerClass innerClass = new OutClass.InnerClass();
 innerClass.methodInner();
 }
 }

注意

1. 在内部类中只能访问外部类中的静态成员
2. 创建内部类对象时，不需要先创建外部类对象
3. 成员内部类，经过编译之后会生成独立的字节码文件，命名格式为：外部类名称$内部类名称

局部内部类

定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用，一般使用的非常少，此处简单了解下语法
格式。

public class OutClass {
 int a = 10;
 public void method(){
 int b = 10;
 // 局部内部类：定义在方法体内部
 // 不能被public、static等访问限定符修饰
 class InnerClass{
 public void methodInnerClass(){
 System.out.println(a);
 System.out.println(b);
 }
 }
 // 只能在该方法体内部使用，其他位置都不能用
 InnerClass innerClass = new InnerClass();
 innerClass.methodInnerClass();
 }
 public static void main(String[] args) {
 // OutClass.InnerClass innerClass = null; 编译失败
 }
}

注意

1. 局部内部类只能在所定义的方法体内部使用
2. 不能被public、static等修饰符修饰
3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$x内部类名字.class，x是一个整数。
4. 几乎不会使用
5. 不能在局部内部类中定义静态成员

匿名内部类

略(学了接口后写)