Java基础教程：内部类

Java基础教程：内部类

内部类

　　内部类，是指在一个类的内部定义的类。就像下面这样：

public class EnclosingClass {
  . . .
  public class NestedClass {
  . . .
 
  }
}

　　内部类拥有访问外部类所有元素（包括private、static）的访问权。当某个外部类的对象创建了一个内部类对象时，此内部类对象必定会秘密地捕获一个指向那个外围类对象的引用。然后，在你访问此外围类的成员时，就是用那个引用来选择外围类的成员。

　　内部类是个编译时的概念，一旦编译成功后，它就与外围类属于两个完全不同的类（当然他们之间还是有联系的）。对于一个名为OuterClass的外围类和一个名为InnerClass的内部类，在编译成功后，会出现这样两个class文件：OuterClass.class和OuterClass$InnerClass.class。

　　

使用.this和.new

　　如果你需要在内部类中生成对外部类对象的引用，可以在外部类的名字后面紧跟圆点和this。

public class EnclosingClass {

    public class NestedClass {
        EnclosingClass getOuterClass(){
            return EnclosingClass.this;
        }
    }

}

　　如果我们需要创建某个内部类对象，必须要利用外部类的对象通过.new来创建内部类

public class EnclosingClass {

    public class NestedClass {
        EnclosingClass getOuterClass(){
            return EnclosingClass.this;
        }
    }

    public static void main(String[] args) {
        EnclosingClass outerClass = new EnclosingClass();
        EnclosingClass.NestedClass innerClass = outerClass.new NestedClass();
    }
}

局部内部类

　　局部内部类指的是在方法、构造器、初始化块中声明的类，在结构上类似一个局部变量。因此局部内部类时不能使用访问修饰符的。

public class OuterClass {
    static int a = 10;
    int b =10;
    //静态域中的局部内部类
    static {
        class LocalClass1{
            int val = a; //定义在静态环境中的内部类，只能访问外部类的静态成员
        }
    }
    //实例初始化块中的局部内部类
    {
        class LocalClass2{
            int val = a; //定义在实例环境中的内部类，可以访问外部类的所有成员
            int num = b;
        }
    }
    //构造器中的局部内部类
    public OuterClass(){
        class LocalClass3{ }
    }
    //方法中的局部内部类
    public void test(){
        class LocalClass4{}
    }
}

匿名内部类

　　匿名内部类与局部内部类很相似，只不过匿名内部类是一个没有给定名字的内部类，在创建这个匿名内部类后，便会立即用来创建并返回此内部类的一个对象引用。

　　匿名内部类只能继承一个类或实现一个接口，不能再继承其他类或其他接口。只能用于创建一次对象实例。

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("线程运行中");
            }
        };
    }
}

嵌套类

　　如果不需要内部类对象与其外围类对象之间有联系，可以将内部类声明为static。这通常称为嵌套类。普通的内部类对象隐式地保存了一个引用，指向创建它的外围类对象。嵌套类因为是static，所以不依赖于外围类对象实例而独立存在，嵌套类的可以访问外围类中的所有静态成员，包括private的静态成员，但是它不能使用任何外围类的非static成员变量和方法。

public class EnclosingClass {
    private static Integer num = 10;
    private Integer num1 = 20;

    static class staticClass{
        public void test(){
            System.out.println(num); //OK
            System.out.println(num1); //ERROR
        }
    }
　　public static void main(String[] args) {
   　　EnclosingClass.StaticClass staticClass = new EnclosingClass.StaticClass();
　　}
}

　　同时，嵌套类是所有内部类中独立性最高的，其创建对象、继承（实现接口）、扩展子类等方式与外部类没有多大区别。

参考链接

• https://www.jishuwen.com/d/2Ea2#tuit
• http://wuzhangyang.com/2019/02/27/java-innerclass/