Java基础——Lambda表达式

1.匿名内部类

• 本质上是一个没有名字的局部内部类，定义在方法中，代码块中，等。
• 作用：方便创建子类对象，最终目的为了简化代码编写。
• 特点：是一个没有名字的内部类；写出来就会产生一个匿名内部类的对象；对象类型相当于是当前new的那个的类型的子类类型。

 格式：

new 类|抽象类名|或者接口名() {

        重写方法;

};

eg:

Employee a = new Employee() {

        public void work() {

        }

};

a.work();

public class Demo01 {
    public static void main(String[] args) {
        //2.定义匿名抽象类
        Animal a = new Animal() {
            @Override
            public void run() {
                System.out.println("乌龟跑的慢");
            }
        };
        a.run();

    }
}

//1.定义一个抽象类
abstract class Animal{
    public abstract void run();
}

2.Lambda表达式

（1）简化匿名内部类的代码写法。

• 注意：Lambda表达式只能简化函数接口的匿名内部类的写法形式。（函数式接口：首先必须是接口，其次接口中有且仅有一个抽像方法的形式）

Lambda表达式的简化格式：

(匿名内部类被重写方法的形参列表) -> {

        被重写方法的方法体代码。

}

注：-> 是语法形式，无实际含义  

/**
 * Lambda的标准格式简化匿名内部类
 * 注意：Lammbda只能简化接口中只有一个抽象方法的匿名内部类形式
 */
public class LambdaDemo01 {
    public static void main(String[] args) {
//        //2.匿名内部类
//        Swimming s1 = new Swimming() {
//            @Override
//            public void swim() {
//                System.out.println("乌龟不会游泳-----");
//            }
//        };
//        go(s1);

        //3.Lambda简化匿名内部类(简化含有抽样方法的形式)
        Swimming s1 = () -> {
            System.out.println("乌龟不会游泳-----");
        };
        go(s1);

        System.out.println("-----------------------------");
        //4.继续简化
//        go(new Swimming() {
//            @Override
//            public void swim() {
//                System.out.println("鱼会游泳----------");
//            }
//        });
        go(() -> {
            System.out.println("鱼会游泳----------");
        });
    }

    public static void go(Swimming s){
        System.out.println("开始-----");
        s.swim();
        System.out.println("结束-----");
    }
}

//1.定义接口
@FunctionalInterface //一旦加上这个注释必须是函数式的接口，里面只能有一个抽象类方法 是我们可以简化的标志
interface Swimming{
    void swim();
}

（2）Lambda表达式简化Comparator接口的匿名形式

/**
 * Lambda表达式简化Comparator接口的匿名形式
 */

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.util.Arrays;
//import java.util.Comparator;

public class LambdaDemo02 {
    public static void main(String[] args) {
        Integer[] ages1 = {34,12,42,23};
        /*
        参数一：被排序的数组，必须是引用类型的元素
        参数二：匿名内部类对象，代表一个比较器对象
         */
//        Arrays.sort(ages1, new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
                return o1-o2;//默认升序
//                return o2-o1;//默认降序-(o1-o2)
//            }
//        });

        //简化后结果
        Arrays.sort(ages1, (Integer o1, Integer o2) -> {
                return o2-o1;//默认降序-(o1-o2)
        });
        System.out.println(Arrays.toString(ages1));

        System.out.println("-------------------------");
        JFrame win = new JFrame("登录界面");
        JButton btn = new JButton("我是一个很大的按钮");

//        btn.addActionListener(new AbstractAction() {
//            @Override
//            public void actionPerformed(ActionEvent e) {
//                System.out.println("有人点我，点我，点我");
//            }
//        });
        //lambda简化
        btn.addActionListener((ActionEvent e) -> {
                System.out.println("有人点我，点我，点我");
        });
        
        win.add(btn);
        win.setSize(400,300);
        win.setVisible(true);

    }
}

（3）Lambda表达式的省略写法

•  参数类型可以省略不写。
• 如果只有一个参数，参数类型可以省略，同时()也可以省略。
• 如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写，同时要省略分号！
• 如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。此时，如果这行代码是return语句，必须省略return不写，同时也必须省略“;”不写。