最近学习神书《Java编程思想》，学习到第10章内部类的内容时，花了很久时间消化。现在基本搞懂了一些基本，用一份代码大致上总结了全章大部分内容。

解释说明全部在代码中用注释标识，以供理解。

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
package com.blackside.chapter_10;

interface Counter {
    int next();
}

public class TestForInnerClass {
    private String name = "OuterClass";
    private int testCount;

    private class InnerClass {
        private String name = "InnerClass";

        /**
         * 当内部类与外围类具有相同名的成员属性时，如何区分？
         * 内部类中，用this标识符指代内部类自己，用 外围类名.this 指代外围类
         * @return
         */
        // 操作内部类的成员属性
        public String returnInnerName() {
            return this.name;
        }

        // 操作外围类的成员属性
        public String returnOuterName() {
            return TestForInnerClass.this.name;
        }
    }

    /**
     * 局部内部类
     * 可以拥有构造器
     * 局部内部类对象，对其外围类来说可以拥有多个，即内部类可以复用
     * @param givenName
     * @return
     */
    public Counter[] getLocalInnerClass(final String givenName) {
        Counter[] counters = new Counter[2];

        class LocalInnerClass implements Counter {
            private String name = "LocalInner";
            private int number;

            // 局部内部类的构造器
            public LocalInnerClass(int number) {
                /**
                 * 这里形参不允许被修改，则说明局部内部类的形参需要被定义为final
                 */
                this.number = number;
//                givenName += "Testing";
                System.out.println("I am LocalInnerClass " + this.number + ".");
            }

            @Override
            public int next() {
                System.out.print(TestForInnerClass.this.name + name + " " + givenName + " " + this.number + " output ");
                return testCount++;
            }
        }
        // 这里，不匿名的局部内部类得到复用，可以创建多个该内部类的对象
        counters[0] = new LocalInnerClass(1);
        counters[1] = new LocalInnerClass(2);
        return counters;
    }

    /**
     * 匿名内部类
     * 无法拥有构造器，但可以使用实例初始化的方式
     * 匿名内部类对象对于其外围类，只能拥有一个，匿名内部类无法使用多次
     * @param givenName
     * @return
     */
    public Counter getAnonymousInner(final String givenName) {
        // 返回的匿名内部类对象一次性返回，且只产生一个对象，无法复用
        return new Counter() {
            private String name = "LocalAnonymousClass";

            // 匿名内部类无法拥有构造器，这里使用实例初始化的方式
            {
                /**
                 * 这里形参不允许被修改，则说明局部内部类的形参需要被定义为final
                 */
//                givenName += "Testing";
                System.out.println("I am LocalAnonymousInnerClass."); // 匿名内部类无法拥有构造器，可以使用实例初始化的方式
            }

            @Override
            public int next() {
                System.out.print(TestForInnerClass.this.name + " " + name + " " + givenName + " output ");
                return testCount++;
            }
        };
    }

    public InnerClass getInnerClass() {
        return new InnerClass();
    }

    public static void main(String[] args) {
        TestForInnerClass test = new TestForInnerClass();

        InnerClass innerClass = test.getInnerClass();
        System.out.println(innerClass.returnInnerName());
        System.out.println(innerClass.returnOuterName());

        Counter[] localInner = test.getLocalInnerClass("001");
        System.out.println(localInner[0].next());
        System.out.println(localInner[1].next());

        Counter anonymousInner = test.getAnonymousInner("002");
        System.out.println(anonymousInner.next());
    }
}