Java内部类（匿名类，匿名对象，静态内部类）详解及实例

Java内部类是一个嵌套在其他类中的类，内部类可以访问外部类的所有成员（包括私有成员），并且可以用来实现一些特殊的功能。Java内部类通常分为四种类型：成员内部类、局部内部类、匿名内部类和静态内部类。

成员内部类

成员内部类是定义在外部类的内部，并且不是 static 的内部类。成员内部类可以访问外部类的所有成员（包括私有成员），并且可以用来实现一些特殊的功能。例如，我们可以使用成员内部类来实现一个迭代器：

public class MyArrayList<T> {
    private T[] array;
    private int size;

    public MyArrayList() {
        this.array = (T[]) new Object[10];
        this.size = 0;
    }

    public void add(T value) {
        if (size >= array.length) {
            resize();
        }
        array[size] = value;
        size++;
    }

    public T get(int index) {
        return array[index];
    }

    public int size() {
        return size;
    }

    public void remove(int index) {
        for (int i = index; i < size - 1; i++) {
            array[i] = array[i+1];
        }
        size--;
    }

    public Iterator<T> iterator() {
        return new MyIterator();
    }

    private void resize() {
        T[] newArray = (T[]) new Object[array.length * 2];
        for (int i = 0; i < size; i++) {
            newArray[i] = array[i];
        }
        array = newArray;
    }

    private class MyIterator implements Iterator<T> {
        private int index;

        public MyIterator() {
            index = 0;
        }

        @Override
        public boolean hasNext() {
            return index < size;
        }

        @Override
        public T next() {
            T value = array[index];
            index++;
            return value;
        }

        @Override
        public void remove() {
            MyArrayList.this.remove(index-1);
            index--;
        }
    }
}

在上面的代码中，MyArrayList 类中包含了一个名为 MyIterator 的成员内部类，这个内部类实现了一个简单的迭代器，用于遍历 MyArrayList 中的元素。注意到在 MyIterator 中，可以直接访问外部类中的 array 和 size 等成员变量。

局部内部类

局部内部类是定义在方法内部的类。局部内部类只可以在定义类的方法中使用，其作用范围被限定在该方法内部，对外部是不可见的。局部内部类可以访问该方法的所有参数和方法变量，但要求这些变量必须是 final 类型的。例如，我们可以使用局部内部类来实现一个简单的计数器：

public class Counter {
    public static void main(String[] args) {
        System.out.println(count(10));
    }

    public static int count(int n) {
        class Counter {
            private int value;

            public Counter() {
                value = 0;
            }

            public void increment() {
                value++;
            }

            public int getValue() {
                return value;
            }
        }

        Counter counter = new Counter();

        for (int i = 0; i < n; i++) {
            counter.increment();
        }

        return counter.getValue();
    }
}

在上面的代码中，count 方法中定义了一个名为 Counter 的局部内部类，这个内部类实现了一个计数器，用于对参数 n 进行计数。在 count 方法中，我们可以创建一个 Counter 对象，并调用 increment 和 getValue 方法进行计数。

匿名内部类

匿名内部类是一种特殊的局部内部类，它在定义时没有完整的类名，通常只是使用一个接口或抽象类作为参数，然后在定义时直接实现其抽象方法。匿名内部类可以用来快速实现某些功能，例如实现一个简单的 OnClickListener：

public class Main {
    public static void main(String[] args) {
        Button button = new Button();
        button.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick() {
                System.out.println("Button clicked!");
            }
        });
        button.click();
    }
}

interface OnClickListener {
    void onClick();
}

class Button {
    private OnClickListener onClickListener;

    public void setOnClickListener(OnClickListener onClickListener) {
        this.onClickListener = onClickListener;
    }

    public void click() {
        if (onClickListener != null) {
            onClickListener.onClick();
        }
    }
}

在上面的代码中，我们定义了一个名为 Main 的类，其包含了一个点击按钮的示例。在 main 方法中，我们创建了一个 Button 对象，并使用匿名内部类实现了一个 OnClickListener 接口，用于当按钮被点击时输出一条信息。

静态内部类

静态内部类是定义在外部类内部，并且被声明为 static 的内部类。静态内部类可以访问外部类的所有静态成员，但是不能直接访问外部类的非静态成员（可以通过创建外部类对象来访问）。例如，我们使用静态内部类来实现一个简单的日志记录器：

public class Logger {
    private static List<String> logs = new ArrayList<>();

    public static void log(String message) {
        logs.add(message);
    }

    public static List<String> getLogs() {
        return logs;
    }

    public static class LoggerThread extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Logger.getLogs());
            }
        }
    }
}

在上面的代码中，我们定义了一个名为 Logger 的类，其包含了一个静态内部类 LoggerThread，用于定时输出日志信息。在 LoggerThread 类中，我们可以直接调用 Logger.getLogs 方法来获取日志信息，并在 run 方法中输出日志信息。

总结

Java 内部类是一种用于实现某些特殊功能的嵌套类。Java 内部类通常分为成员内部类、局部内部类、匿名内部类和静态内部类。以上面几个示例为例，它们分别使用了各种类型的 Java 内部类来实现一个迭代器、一个计数器、一个 OnClickListener 和一个日志记录器。使用内部类时需要考虑访问权限、变量的作用域和生命周期等问题，建议根据实际需要决定使用哪种类型的内部类。