内部类-局部内部类-匿名内部类

贺祥 | 发表于 | 分类于
内部类（常规内部类，静态内部类），局部内部类，匿名内部类。

下面的述语中，成员内部类是指常规内部类与静态内部类。

getDeclaringClass():Class<?>
获取成员内部类在定义时所在的类。

getEnclosingClass():Class<?>
获取内部类在定义时所在的类。

getEnclosingConstructor():Constructor
获取局部或匿名内部类在定义时所在的构造器。

getEnclosingMethod():Method
获取局部或匿名内部类在定义时所在的方法。

isMemberClass():boolean
查看是否成员内部类。

isLocalClass():boolean
查看是否局部内部类。

isAnonymousClass():boolean
查看是否匿名内部类。

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
public class Test {
    public static void main(String[] params) {
        new Test().test();
    }
    //常规内部类
    public class InnerClass {
        //常规内部类
        public class InnerClass2 {

        }
    }
    //常规内部类
    public static class StaticInnerClass {
        //静态内部内
        public static class StaticInnerClass2 {

        }
    }
    //常规内部类
    class LocalInnerClass2 { }
    Object obj2 = new Object(){ };
    public void test(){
        //局部内部内，在方法如局部变量一样内的，
        class LocalInnerClass { }

        printInnerClass("常规内部类Test.InnerClass", Test.InnerClass.class);
        printInnerClass("常规内部类Test.InnerClass.InnerClass2", Test.InnerClass.InnerClass2.class);
        printInnerClass("常规内部类StaticInnerClass", StaticInnerClass.class);
        printInnerClass("静态内部类StaticInnerClass.StaticInnerClass2", StaticInnerClass.StaticInnerClass2.class);
        printInnerClass("局部内部类LocalInnerClass.class", LocalInnerClass.class);
        printInnerClass("常规内部类LocalInnerClass2", LocalInnerClass2.class);
        Object obj = new Object(){ };
        printInnerClass("匿名内部类obj", obj.getClass());
        printInnerClass("匿名内部类obj2", obj2.getClass());
    }

    public static void printInnerClass(String name, Class<?> clazz){
        System.out.println(name + " -> DeclaringClass=\t" + clazz.getDeclaringClass());
        System.out.println(name + " -> EnclosingClass=\t" + clazz.getEnclosingClass());
        System.out.println(name + " -> EnclosingConstructor=" + clazz.getEnclosingConstructor());
        System.out.println(name + " -> EnclosingMethod=\t" + clazz.getEnclosingMethod());
        System.out.println(name + " -> 是否成员内部类=\t" + clazz.isMemberClass());
        System.out.println(name + " -> 是否局部内部类=\t" + clazz.isLocalClass());
        System.out.println(name + " -> 是否匿名内部类=\t" + clazz.isAnonymousClass());
        printLine();
    }

    public static void printLine() {
        System.out.println("-------------------------------------");
    }


}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
常规内部类Test.InnerClass -> DeclaringClass=	class Test
常规内部类Test.InnerClass -> EnclosingClass=	class Test
常规内部类Test.InnerClass -> EnclosingConstructor=null
常规内部类Test.InnerClass -> EnclosingMethod=	null
常规内部类Test.InnerClass -> 是否成员内部类=	true
常规内部类Test.InnerClass -> 是否局部内部类=	false
常规内部类Test.InnerClass -> 是否匿名内部类=	false
-------------------------------------
常规内部类Test.InnerClass.InnerClass2 -> DeclaringClass=	class Test$InnerClass
常规内部类Test.InnerClass.InnerClass2 -> EnclosingClass=	class Test$InnerClass
常规内部类Test.InnerClass.InnerClass2 -> EnclosingConstructor=null
常规内部类Test.InnerClass.InnerClass2 -> EnclosingMethod=	null
常规内部类Test.InnerClass.InnerClass2 -> 是否成员内部类=	true
常规内部类Test.InnerClass.InnerClass2 -> 是否局部内部类=	false
常规内部类Test.InnerClass.InnerClass2 -> 是否匿名内部类=	false
-------------------------------------
常规内部类StaticInnerClass -> DeclaringClass=	class Test
常规内部类StaticInnerClass -> EnclosingClass=	class Test
常规内部类StaticInnerClass -> EnclosingConstructor=null
常规内部类StaticInnerClass -> EnclosingMethod=	null
常规内部类StaticInnerClass -> 是否成员内部类=	true
常规内部类StaticInnerClass -> 是否局部内部类=	false
常规内部类StaticInnerClass -> 是否匿名内部类=	false
-------------------------------------
静态内部类StaticInnerClass.StaticInnerClass2 -> DeclaringClass=	class Test$StaticInnerClass
静态内部类StaticInnerClass.StaticInnerClass2 -> EnclosingClass=	class Test$StaticInnerClass
静态内部类StaticInnerClass.StaticInnerClass2 -> EnclosingConstructor=null
静态内部类StaticInnerClass.StaticInnerClass2 -> EnclosingMethod=	null
静态内部类StaticInnerClass.StaticInnerClass2 -> 是否成员内部类=	true
静态内部类StaticInnerClass.StaticInnerClass2 -> 是否局部内部类=	false
静态内部类StaticInnerClass.StaticInnerClass2 -> 是否匿名内部类=	false
-------------------------------------
局部内部类LocalInnerClass.class -> DeclaringClass=	null
局部内部类LocalInnerClass.class -> EnclosingClass=	class Test
局部内部类LocalInnerClass.class -> EnclosingConstructor=null
局部内部类LocalInnerClass.class -> EnclosingMethod=	public void Test.test()
局部内部类LocalInnerClass.class -> 是否成员内部类=	false
局部内部类LocalInnerClass.class -> 是否局部内部类=	true
局部内部类LocalInnerClass.class -> 是否匿名内部类=	false
-------------------------------------
常规内部类LocalInnerClass2 -> DeclaringClass=	class Test
常规内部类LocalInnerClass2 -> EnclosingClass=	class Test
常规内部类LocalInnerClass2 -> EnclosingConstructor=null
常规内部类LocalInnerClass2 -> EnclosingMethod=	null
常规内部类LocalInnerClass2 -> 是否成员内部类=	true
常规内部类LocalInnerClass2 -> 是否局部内部类=	false
常规内部类LocalInnerClass2 -> 是否匿名内部类=	false
-------------------------------------
匿名内部类obj -> DeclaringClass=	null
匿名内部类obj -> EnclosingClass=	class Test
匿名内部类obj -> EnclosingConstructor=null
匿名内部类obj -> EnclosingMethod=	public void Test.test()
匿名内部类obj -> 是否成员内部类=	false
匿名内部类obj -> 是否局部内部类=	false
匿名内部类obj -> 是否匿名内部类=	true
-------------------------------------
匿名内部类obj2 -> DeclaringClass=	null
匿名内部类obj2 -> EnclosingClass=	class Test
匿名内部类obj2 -> EnclosingConstructor=null
匿名内部类obj2 -> EnclosingMethod=	null
匿名内部类obj2 -> 是否成员内部类=	false
匿名内部类obj2 -> 是否局部内部类=	false
匿名内部类obj2 -> 是否匿名内部类=	true
-------------------------------------