博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
Lambda表达式_hehe.employment.7.3
阅读量:389 次
发布时间:2019-03-05

本文共 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/

你可能感兴趣的文章