Lamda表达式和匿名内部类

---

前言

`匿名内部类和抽象类总是往，现在来写一篇文章

一、匿名内部类是什么？

匿名内部类是一种在 Java 中用于创建临时、一次性对象的特殊语法。允许你在需要一个类的实例的地方，直接通过类的实例化来创建一个对象。匿名内部类通常用于实现接口或继承抽象类的情况。

1.实现接口和抽象类(普通类也可以）

InterfaceName obj = new InterfaceName() {
    // 匿名内部类的实现
    // 可以包含字段、方法的实现等
};

AbstractClassName obj = new AbstractClassName() {
    // 匿名内部类的实现
    // 可以包含字段、方法的实现等
};

特点和注意事项：一次性使用： 匿名内部类通常用于一次性的情况，不需要为其定义具体的类名，只需提供实现。

public class AnonymousClassExample {
    public static void main(String[] args) {
        // 第一次使用匿名内部类
        Task task1 = new Task() {
            @Override
            public void execute() {
                System.out.println("Task 1 executed");
            }
        };
        task1.execute();

        // 第二次使用匿名内部类
        Task task2 = new Task() {
            @Override
            public void execute() {
                System.out.println("Task 2 executed");
            }
        };
        task2.execute();
    }
}

在上述例子中，每次需要执行一个任务时，都要创建一个新的匿名内部类的实例。这两个任务的逻辑虽然相似，但它们是两个不同的匿名内部类实例。

如果要复用逻辑，可以考虑使用具名内部类或独立的类。例如：

public class NamedInnerClassExample {
    static class MyTask implements Task {
        @Override
        public void execute() {
            System.out.println("Task executed");
        }
    }

    public static void main(String[] args) {
        Task task1 = new MyTask();
        task1.execute();

        Task task2 = new MyTask();
        task2.execute();
    }
}

2.可实现接口或继承抽象类：

可以通过匿名内部类实现接口或继承抽象类，并在其中提供具体的实现。

3. 访问外部变量：

匿名内部类可以访问外部的 final 变量，但如果要修改外部变量，该变量必须是 final 的。

public class AnonymousClassExample {
    public static void main(String[] args) {
        final int externalVariable = 10; // 外部方法的局部变量，必须是 final 或事实上 final

        // 匿名内部类访问外部变量
        Runnable myRunnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("External variable: " + externalVariable);
            }
        };

        // 执行匿名内部类的 run 方法
        myRunnable.run();
    }
}

不过从Java 8开始，引入了"effectively final"的概念，即如果一个局部变量在初始化后没有再次赋值，它被视为final，即使没有显式使用final关键字。这样，你可以在匿名内部类中访问这些局部变量，而无需显式将它们声明为final。

1.PriorityQueue<int[]> pq： 创建一个泛型为整数数组的优先队列。

2.new Comparator<int[]>() {…}： 创建一个匿名内部类，实现了 Comparator 接口，用于定义数组元素之间的比较规则。

3.public int compare(int[] a, int[] b) {return a[0] - b[0];}： 在匿名内部类中，实现了 compare 方法，该方法定义了两个整数数组 a 和 b 之间的比较规则。这里使用 a[0] - b[0] 表示比较两个数组的第一个元素

二、Lambda表达式

它允许在更简洁、更便捷的方式下创建匿名函数。Lambda 表达式的主要目的是为了提供一种更紧凑的语法来表示函数式接口

1.语法

(parameters) -> expression

(parameters) -> { statements; }

实例
无参数实例

() -> System.out.println("Hello, Lambda!");

  有参数实例;

(int x, int y) -> x + y

(int x, int y) -> {
    int sum = x + y;
    System.out.println("Sum: " + sum);
    return sum;
}

三.区别：

Lambda 表达式和匿名内部类都可以用于创建函数式接口的实例，但有一些语法上的差异，主要在于语法的简洁性。

比如，对比使用匿名内部类和 Lambda 表达式实现 Runnable 接口：

// 使用匿名内部类
Runnable runnable1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello, Anonymous Inner Class!");
    }
};

// 使用 Lambda 表达式
Runnable runnable2 = () -> System.out.println("Hello, Lambda!");

总结

好了，blog到此为止了，不要再忘记了😢😢😢😢