Java匿名内部类详解

介绍

Java匿名内部类是一种嵌套类。它没有名字，只是被创建并实例化了一次。通常用于在某处需要一个类但不想使用更严格的抽象类。

匿名内部类可以作为一个类的成员变量、方法参数、返回值等。它的语法比较简洁易懂，但使用时需要注意一些细节。

正文

1、定义及使用方式

匿名内部类可以实现一个接口或继承一个类，并且可以直接定义并实例化，使用方式如下：

interface InterfaceA {
    void print();
}

class Test {
    public static void main(String[] args) {
        InterfaceA a = new InterfaceA() {
            @Override
            public void print() {
                System.out.println("I am A");
            }
        };
        a.print();
    }
}

在这个例子中，定义了一个InterfaceA接口，并在Test类中使用一个匿名内部类来实现这个接口，并在实现的print()方法中输出”I am A”。在使用时，直接定义了一个InterfaceA类型的变量，并将其实例化为一个匿名内部类。

2、限制

匿名内部类虽然使用比较方便，但有以下几个限制：

（1）不能显式定义构造函数

匿名内部类没有构造函数，因为它没有名字。因此，如果需要传递参数等，可以在定义内部类时使用实例初始化块来替代构造函数的功能。如下：

interface InterfaceB {
    void print();
}

class Test {
    public static void main(String[] args) {
        InterfaceB b = new InterfaceB() {
            private String name;

            {
                this.name = "B";
            }

            @Override
            public void print() {
                System.out.println("I am " + name);
            }
        };
        b.print();
    }
}

在这个例子中，我们需要在内部类中定义一个String类型的name，并在print()方法中使用。由于匿名内部类不能显式定义构造函数，我们可以使用实例初始化块的方式来完成这个功能。

（2）不能定义静态成员或方法

由于匿名内部类没有名字，因此无法定义静态成员或方法。如下代码将无法通过编译：

interface InterfaceC {
    static void print() { // 编译错误
        System.out.println("I am C");
    }
}

3、多重嵌套

匿名内部类也可以在其他类的内部类或方法中使用，实现多重嵌套的效果。如下：

interface InterfaceA {
    void print();
}

class Test1 {
    private static class TestInner {
        public void test() {
            InterfaceA a = new InterfaceA() {
                {
                    System.out.println("inner");
                }

                @Override
                public void print() {
                    System.out.println("I am A");
                }
            };
            a.print();
        }
    }

    public static void main(String[] args) {
        TestInner testInner = new TestInner();
        testInner.test();
    }
}

在这个例子中，内部类TestInner中的test()方法使用了一个匿名内部类实现了InterfaceA接口，并在实现的print()方法中输出”I am A”。在Test1类的main()方法中，我们实例化了TestInner并调用test()方法，从而触发了匿名内部类的实例化与使用。

4、Lambda表达式与匿名内部类的关系

Java 8引入了Lambda表达式，使得代码更加简洁和易读。Lambda表达式本质上是一个函数式接口的实例，与匿名内部类类似。

但是，Lambda表达式与匿名内部类确实有所不同。特别是在定义与使用时，Lambda表达式比匿名内部类更加容易理解和使用。如果您使用的是Java 8及以上版本，建议使用Lambda表达式而不是匿名内部类。

代码部分

以下是上述讨论过的例子的完整代码：

interface InterfaceA {
    void print();
}

class Test {
    public static void main(String[] args) {
        InterfaceA a = new InterfaceA() {
            @Override
            public void print() {
                System.out.println("I am A");
            }
        };
        a.print();
    }
}

interface InterfaceB {
    void print();
}

class Test {
    public static void main(String[] args) {
        InterfaceB b = new InterfaceB() {
            private String name;

            {
                this.name = "B";
            }

            @Override
            public void print() {
                System.out.println("I am " + name);
            }
        };
        b.print();
    }
}

interface InterfaceC {
    static void print() { // 编译错误
        System.out.println("I am C");
    }
}

interface InterfaceA {
    void print();
}

class Test1 {
    private static class TestInner {
        public void test() {
            InterfaceA a = new InterfaceA() {
                {
                    System.out.println("inner");
                }

                @Override
                public void print() {
                    System.out.println("I am A");
                }
            };
            a.print();
        }
    }

    public static void main(String[] args) {
        TestInner testInner = new TestInner();
        testInner.test();
    }
}