1.Lambda表达式

1.1 体验lambda表达式【理解】

  • 案例需求

启动一个线程，在控制台输出一句话：多线程程序启动了

  • 实现方式一
    • 实现步骤
      • 定义一个类MyRunnable实现Runnable接口，重写run()方法
      • 创建MyRunnable类的对象
      • 创建Thread类的对象，把MyRunnable的对象作为构造参数传递
      • 启动线程 ```java public class LambdaDemo { public static void main(String[] args) { //创建一个Thread类对象，把MyRunnable的对象作为构造参数
        Thread thread = new Thread(new MyRunable()); //启动线程 thread.run(); } }

//定义一个类实现Runnable接口，重写Run方法 class MyRunable implements Runnable{ @Override public void run() { System.out.println(“线程启动了”); } }

  2. - 实现方式二
  3.    - 匿名内部类的方式改进
  4. ```java
  5. public class LambdaDemo {
  6.     public static void main(String[] args) {
  7.         Thread thread = new Thread(new Runnable() {
  8.             @Override
  9.             public void run() {
  10.                 System.out.println("线程启动了");
  11.             }
  12.         });
  13.         //启动线程
  14.         thread.run();
  15.     }
  17. }
  • 实现方式三
    • lambda表达式的方式改进 ```java public class LambdaDemo { public static void main(String[] args) { Thread thread = new Thread(() -> System.out.println(“线程启动了”)); //启动线程 thread.run(); }

}

  2. - 函数式编程的思想概述
  4. 函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”
  6. 而我们要学习的Lambda表达式就是函数式编程的体现
  9. <a name="f9Cmx"></a>
  10. ### 1.2 lambda表达式的标准格式【理解】
  12. - 格式：
  14.   (形式参数) -> {代码块}
  16.    - 形式参数：如果有多个参数，参数用都逗号隔开；如果没有参数留空即可
  17.    - ->：由英文中划线和大于符号组成，固定写法。代表指向动作
  18.    - 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容
  19. - 组成lambda表达式的三要素：
  20.    - 形式参数，箭头，代码块
  23. <a name="o8tKG"></a>
  24. ### 1.3 lambda表达式练习1 （无参无返回值）【应用】
  26. - lambda表达式使用的前提
  27.    - 有一个接口
  28.    - 接口中有且仅有一个抽象方法
  29. - 练习描述
  31. 无参无返回值抽象方法的练习
  33. - 操作步骤
  34.    - 定义一个接口（interfase），接口定义一个抽象方法void method();
  35.    - 定义一个测试类（interfaseDemo），在测试类中提供两个方法
  36.       - 一个方法是：useinterfase(interfase i)
  37.       - 一个方法是主方法，在主方法中调用useInterfase方法
  38. - 代码示例
  39. ```java
  40. public class LambdaDemo01 {
  41.     public static void main(String[] args) {
  42.         useInterfase(()-> System.out.println("hello,world"));
  43.     }
  45.     static void useInterfase(interfase i){
  46.         i.method();
  47.     }
  48. }
  49. @FunctionalInterface
  50. interface interfase{
  51.     void method();
  52. }

1.4 lambda表达式练习2 （有参无返回值）【应用】

  • 练习描述
    • 有参无返回值的抽象方法练习
  • 操作步骤
    • 定义一个接口（Interfase），里面定义一个抽象方法 void method(String s)
    • 定义一个测试类（InterfaseDemo），在测试类中提供两个方法：
      • 一个方法是useInterfase(Interfase i)
      • 一个方法是主方法，在主方法中调用useInterfase方法

  • 代码示例 ```java public class LambdaDemo02 { public static void main(String[] args) {

    1.   useInterfase1(s-> System.out.println(s));

    }

    private static void useInterfase1(interfase1 i) {

    1.   i.method1("这是method1的参数");

    } }

@FunctionalInterface interface interfase1 { void method1(String s);

}

  2. <a name="JHnFd"></a>
  3. ### 1.5 lambda表达式练习3 （有参有返回值） 【应用】
  5. - 练习描述<br />有参有返回值抽象方法的练习
  6. - 操作步骤
  7.    - 定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y);
  8.    - 定义一个测试类(AddableDemo)，在测试类中提供两个方法
  9.       - 一个方法是：useAddable(Addable a)
  10.       - 一个方法是主方法，在主方法中调用useAddable方法
  11. - 示例代码
  12. ```java
  13. public class AddDemo {
  14.     public static void main(String[] args) {
  15.         System.out.println(useAddAble((int a, int b) -> a + b));
  16.     }
  17.     static int useAddAble(addAble a){
  18.         return a.add(10, 20);
  19.     }
  20. }
  21. @FunctionalInterface
  22. interface addAble{
  23.     int add(int a,int b);
  24. }

1.6 lambda表达式的省略模式 【应用】

  • 省略的规则
    • 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
    • 如果参数有且仅有一个，那么小括号可以省略
    • 如果代码块的语句只有一条，可以省略大括号和分号，和return关键字
  • 代码演示