Java中的匿名内部类使用说明

1、 什么是匿名内部类

在Java中，一个内部类可以被定义在另一个类中， 也可以被定义在一个方法或者代码块中。当内部类没有被命名时， 我们称之为匿名内部类。

匿名内部类是一种简化代码的方式，将一个类的实现和类的创建结合在一起，使得代码更加简洁。

    interface Study {
        void study();
    }

    public class Main {
        public static void main(String[] args) {
            // 声明和实例化一个Study接口类型的变量
            Study love = new Study() {
                public void study() {
                    System.out.println("I love Java.");
                }
            };
            // 调用study方法
            love.study();
        }
    }

上面的代码就是一个典型的匿名内部类的使用例子，其中Study接口没有被实现类实现，而是通过匿名内部类的方式来实现的。

2、 匿名内部类的使用场景

匿名内部类适合在以下场景使用：

2.1 需要创建一个实例，但又不想定义一个具体类的情况。

2.2 需要实现某个接口或抽象类的情况，并且该实现只需用一次。

    // 创建一个Thread实例
    Thread t = new Thread(new Runnable() {
        public void run() {
            System.out.println("Thread is running.");
        }
    });

2.3 需要动态实现某个接口或抽象类的情况。

    // 获取一个接口的代理实例
    Study proxy = (Study) Proxy.newProxyInstance(
            Study.class.getClassLoader(),
            new Class[] { Study.class },
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    if ("study".equals(method.getName())) {
                        System.out.println("I'm studying now.");
                    }
                    return null;
                }
            });

3、 匿名内部类的语法

匿名内部类的语法：new 父类构造器或接口名称() { //类体 }

其中父类构造器或接口名称()表示匿名内部类要么继承自一个父类(用extends关键字)，要么实现了一个接口(用implements关键字)。

    // 创建一个继承自父类的匿名内部类对象
    Father father = new Father() {
        @Override
        public void say() {
            System.out.println("I'm your father.");
        }
    };

    // 创建一个实现接口的匿名内部类对象
    Study study = new Study() {
        @Override
        public void study() {
            System.out.println("I'm studying Java.");
        }
    };

4、 匿名内部类与Lambda表达式的区别

匿名内部类与Lambda表达式都能实现类的定义和实例化的组合，且代码量更少。Lambda表达式比匿名内部类更加简洁。

Lambda表达式是Java 8中新增的一种特殊的语法结构，它可以用来替代匿名内部类的大部分语法，放大了函数式编程在Java语言中的应用。

两者的使用具体需按需选择：

4.1 如果只是创建一个简单的实例，Lambda表达式更加简洁。

    Study study1 = () -> System.out.println("I'm studying.");

    Father father1 = () -> System.out.println("I'm your father");

4.2 如果需要对接口方法进行复杂实现，或者需要访问类的成员变量，或者需要用到一些复杂的控制流语法，使用匿名内部类会更加方便。

    Study study2 = new Study() {
        private int count;
        @Override
        public void study() {
            count++;
            System.out.println("I'm studying Java " + count + " times.");
        }
    };

    Father father2 = new Father() {
        private String name = "Tom";
        @Override
        public void say() {
            System.out.println("I'm your father, " + name + ".");
        }
    };

5、 总结

匿名内部类是Java中比较实用的一个特性，它可以简化我们的代码，使我们能够在一定程度上提高代码的可读性和可维护性。但是，它并不一定是在所有情况下都适用，要灵活选择使用。

在使用匿名内部类时，应当遵守一定的规范，比如尽量避免过度的嵌套，及时释放不必要的资源等。