本文共 5665 字，大约阅读时间需要 18 分钟。

7.6 函数式编程思想概述

• 在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。
• 相对而言，面向对象 过分强调“必须通过对象的形式来做事情”，
• 而 函数式思想 则尽量忽略面向对象的复杂语法——强调做什么，而不是以 什么形式做。
• 面向对象的思想:
  • 做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.
• 函数式编程思想:
  • 只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程.

7.7 冗余的Runnable代码

• 示例：

package com.itheima.demo03.Lambda;/*    使用实现Runnable接口的方式实现多线程程序 */public class Demo01Runnable {
       public static void main(String[] args) {
           //创建Runnable接口的实现类对象        RunnableImpl run = new RunnableImpl();        //创建Thread类对象,构造方法中传递Runnable接口的实现类        Thread t = new Thread(run);        //调用start方法开启新线程,执行run方法        t.start();        //简化代码,使用匿名内部类,实现多线程程序        Runnable r = new Runnable(){
               @Override            public void run() {
                   System.out.println(Thread.currentThread().getName()+" 新线程创建了");            }        };        new Thread(r).start();    }}

• 代码分析：
  • Thread 类需要 Runnable 接口作为参数，其中的抽象 run 方法是用来指定线程任务内容的核心；
  • 为了指定 run 的方法体，不得不需要 Runnable 接口的实现类；
  • 为了省去定义一个 RunnableImpl 实现类的麻烦，不得不使用匿名内部类；
  • 必须覆盖重写抽象 run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错；
  • 而实际上，似乎只有方法体才是关键所在。

7.8 编程思想转换

• 做什么，而不是怎么做

  • 将 run 方法体内的代码传递给 Thread 类知晓。
  • 传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。那，有没有更加简单的办法？如果我们将关注点从“怎么做”回归到“做什么”的本质上，就会发现只要能够更好地达 到目的，过程与形式其实并不重要。

• 生活举例：

  • 当我们需要从北京到上海时，可以选择高铁、汽车、骑行或是徒步。我们的真正目的是到达上海，而如何才能到达上海的形式并不重要，所以我们一直在探索有没有比高铁更好的方式——搭乘飞机。
  • 而现在这种飞机（甚至是飞船）已经诞生：2014年3月Oracle所发布的Java 8（JDK 1.8）中，加入了Lambda表达式的重量级新特性，为我们打开了新世界的大门。

7.9 体验Lambda的更优写法

• 示例：

package com.xww.demo03;/*    使用实现Runnable接口的方式实现多线程程序 */public class demoRunnable {
       public static void main(String[] args) {
           //创建Runnable接口的实现类对象        RunnableImpl run = new RunnableImpl();        //创建Thread类对象,构造方法中传递Runnable接口的实现类        Thread t = new Thread(run);        //调用start方法开启新线程,执行run方法        t.start();//Thread-0 新线程创建了        //Lambda优化        new Thread( ()->{
                   System.out.println(Thread.currentThread().getName()+" 新线程创建了");        }).start();//Thread-1 新线程创建了    }}

7.10 回顾匿名内部类

• 匿名内部类的好处与弊端
  • 一方面，匿名内部类可以帮我们省去实现类的定义；
  • 另一方面，匿名内部类的语法——确实太复杂了！
• 语义分析
  • 仔细分析该代码中的语义， Runnable 接口只有一个 run 方法的定义：
    • public abstract void run();
  • 即制定了一种做事情的方案（其实就是一个函数）：
    • 无参数：不需要任何条件即可执行该方案；
    • 无返回值：该方案不产生任何结果；
    • 代码块（方法体） ：该方案的具体执行步骤。
• 同样的语义体现在 Lambda 语法中，要更加简单：
  • () ‐> System.out.println("多线程任务执行！")
    • 前面的一对小括号即 run 方法的参数（无），代表不需要任何条件；
    • 中间的一个箭头代表将前面的参数传递给后面的代码；
    • 后面的输出语句即业务逻辑代码。

7.11 Lambda标准格式

• Lambda表达式的标准格式:
  • 一些参数
  • 一个箭头
  • 一段代码
• 格式:
  • (参数列表) -> {一些重写方法的代码};
• 解释说明格式:
  • (): 接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔 ;
  • ->: 传递的意思,把参数传递给方法体{};
  • {}: 重写接口的抽象方法的方法体.

7.12 Lambda表达式_无参无返回值_练习

• 需求:
  • 给定一个厨子Cook接口，内含唯一的抽象方法makeFood，且无参数、无返回值；
  • 使用Lambda的标准格式调用invokeCook方法，打印输出“吃饭啦！”字样。
• 示例：

package com.xww.demo04;/*    定一个厨子Cook接口，内含唯一的抽象方法makeFood */public interface Cook {
       //定义无参数无返回值的方法makeFood    public abstract void makeFood();}

package com.xww.demo04;public class demoCook {
       public static void main(String[] args) {
           //调用invokeCook方法,参数是Cook接口,传递Cook接口的匿名内部类对象        invokeCook(new Cook() {
               @Override            public void makeFood() {
                   System.out.println("吃饭了");            }        });        //使用Lambda表达式,简化匿名内部类的书写        invokeCook(()->{
               System.out.println("吃饭了");        });    }    //定义一个方法,参数传递Cook接口,方法内部调用Cook接口中的方法makeFood    public static void invokeCook(Cook cook){
           cook.makeFood();    }}

7.13 Lambda表达式_有参有返回值_练习

• 需求:

  • 使用数组存储多个Person对象；
  • 对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序。

• 示例：

package com.xww.demo05;import java.util.Arrays;public class demoPerson {
       public static void main(String[] args) {
           //使用数组存储多个Person对象        Person[] arr = {
                   new Person("a",3),                new Person("b",1),                new Person("c",1)        };        //对数组中的Person对象使用Arrays的sort方法通过年龄进行升序(前边-后边)排序        /*Arrays.sort(arr, new Comparator
   
    () {            @Override            public int compare(Person o1, Person o2) {                return o1.getAge()-o2.getAge();            }        });*/        //使用Lambda表达式,简化匿名内部类        Arrays.sort(arr,(Person o1, Person o2)->{
               return o1.getAge()-o2.getAge();        });        //遍历数组        for (Person p : arr) {
               System.out.println(p);        }    }}//Person{name='b', age=1}//Person{name='c', age=1}//Person{name='a', age=3}
   

7.14 Lambda表达式_有参有返回值_自定义接口_练习

• 需求:
  • 给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值；
  • 使用Lambda的标准格式调用invokeCalc方法，完成10和30的相加计算。
• 示例：

package com.xww.demo06;public class demoCalculator {
       public static void main(String[] args) {
           //调用invokeCalc方法,方法的参数是一个接口,可以使用匿名内部类//        invokeCalc(10, 30, new Calculator() {
   //            @Override//            public int calc(int a, int b) {
   //                return a+b;//40//            }//        });        //使用Lambda表达式简化匿名内部类的书写        invokeCalc(10,30,(int a,int b)->{
               return a + b;//40        });    }    /*        定义一个方法        参数传递两个int类型的整数        参数传递Calculator接口        方法内部调用Calculator中的方法calc计算两个整数的和     */    public static void invokeCalc(int a,int b,Calculator c){
           int sum = c.calc(a,b);        System.out.println(sum);    }}

7.15 Lambda 省略格式与使用前提

• Lambda表达式 : 是可推导,可以省略。
• 凡是根据上下文推导出来的内容,都可以省略书写。
• 可以省略的内容:
  • (参数列表): 括号中参数列表的数据类型,可以省略不写 ；
  • (参数列表): 括号中的参数如果只有一个,那么类型和() 都可以省略
  • {一些代码}: 如果{}中的代码只有一行,无论是否有返回值,都可以省略({},return,分号)。
  • note: 要省略 {},return,分号必须一起省略。
    示例：

//使用Lambda表达式,简化匿名内部类的书写        invokeCook(()->{
               System.out.println("吃饭了");        });        //优化省略Lambda        invokeCook(()-> System.out.println("吃饭了"));

//使用Lambda表达式简化匿名内部类的书写        invokeCalc(120,130,(int a,int b)->{
               return a + b;        });        //优化省略Lambda        invokeCalc(120,130,(a,b)-> a + b);

转载地址：http://xgrwz.baihongyu.com/