lambda

lambda 概述

函数式编程思想

面向对象思想在乎的是，一切的动作通过对象的形式去完成

而函数式编程思想，更在乎做什么，而不是通过什么形式去做

demo: 简单的应用 - 使用lambda实现线程

定义一个MyThread类 - 继承Thread类

/**
 * @Classname : MyThread
 * @Description : TODO
 * @Author : lin_refuel@qq.com
 */
public class MyThread extends Thread{
   // 重写run方法
    @Override
    public void run() {
        System.out.println("通过继承Thread类实现线程");
    }
}

定义一个MyRunable的接口作为Runnable接口的实现类

/**
 * @Classname : MyRunnable
 * @Description : TODO
 * @Author : lin_refuel@qq.com
 */
public class MyRunnable implements Runnable {
    @Override
    //重新run方法
    public void run() {
        System.out.println("通过Runnable接口方式实现线程");
    }
}

demo01测试类

/**
 * @Classname : demo01
 * @Description : TODO Lambda - 简单应用
 * @Author : lin_refuel@qq.com
 */
public class demo01 {
    public static void main(String[] args) {
          // 实现线程的几种方式
        // 1. 通过继承Thread类实现线程
        MyThread mt = new MyThread();
        mt.start();
        // 通过Runnable接口方式实现线程
        MyRunnable myRunnable = new MyRunnable();
        new Thread(myRunnable).start();
        // 通过匿名内部类实现线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类实现多线程");
            }
        }).start();
        // TODO*****************************************
        // 通过Lambda方式实现线程
        // 直接告诉线程需要做那些事情
        new Thread(()->{
            System.out.println("通过Lambda方式实现多线程");
        }).start();

    }
}

运行结果：

lambda的演变过程

lambda 表达式的基本格式

• 啦么大 表达式使用的前提

  • 有一个接口

  • 并且接口中有且仅有一个抽象方法

==========================================

• ()：形参列表 - 要实现的接口中唯一的抽象方法所对应的形参列表

• ->：要做的事情 - 固定格式

• {}：方法体 - 被重写的方法体的固定格式

案例：调用接口里面的方法几种方式

demo:

定义一个名字为eat的接口

package com.itxs.demo02;

/**
 * @Classname : eat
 * @Description : TODO 吃 - 接口
 * @Author : lin_refuel@qq.com
 */
public interface eat {
    // 吃的抽象方法, food：吃的食物
    void eats(String food);
}

创建一个eat接口的实现类eatTest

package com.itxs.demo02;

/**
 * @Classname : eatTest
 * @Description : TODO
 * @Author : lin_refuel@qq.com
 */
public class eatTest implements eat{
    // 对接口eat里面的抽象方法eats进行重写
    @Override
    public void eats(String food) {
        System.out.println("我中午想吃" + food);
    }
}

测试类demo01

package com.itxs.demo02;

/**
 * @Classname : demo01
 * @Description : TODO 测试类
 * @Author : lin_refuel@qq.com
 */
public class demo01 {
    public static void main(String[] args) {
        // 第一种方式：接口存储实现类的方式
        eats(new eatTest());
        // 第二种方式：匿名内部类的方式进行调用
        eats(new eat() {
            @Override
            public void eats(String food) {
                System.out.println("小肆中午想吃" + food);
            }
        });
        // 第三种lambda方式
        eats((String food)->{
            System.out.println("哥们中午吃啥？吃"+food);
        });
        System.out.println("================================");
        // 第四种方式，lambda的实现过程
       eat s = (String food)->{
            System.out.println("哥们中午吃啥？吃"+food);
        };
       s.eats("烤鸡");
    }

    /**
     * 接口测试方法，调用接口里面的抽象放法eats
     * @param e 不同方式创建的eat类型的空间
     */
    private static void eats(eat e){
        e.eats("烧鹅");
    }
}

运行结果：

lambda省略写法

• 参数的类型可以省略

• 如果参数有且仅有一个，小括号可以省略不写

• 如果代码块的语句只有一条，可以省略大括号和分号（如果有 return 则 return 需要一同删掉）

案例一：抽象方法一个参数

demo:

创建一个eat接口

package com.itxs.demo03;

/**
 * @Classname : eat
 * @Description : TODO 吃的接口
 * @Author : lin_refuel@qq.com
 */
public interface eat {
    // 吃饭的抽象方法
    // food：食物
    void dine(String food);
}

demo01:调用上面接口，测试lambda写法

package com.itxs.demo03;

/**
 * @Classname : demo01
 * @Description : TODO
 * @Author : lin_refuel@qq.com
 */
public class demo01 {
    public static void main(String[] args) {
          // 3种方式实现接口
          // 通过匿名内部类方式实现
          eatTest(new eat() {
              @Override
              public void dine(String food) {
                  System.out.println("小三中午吃的是" + food);
              }
          });
          // 3. 完整的lambda
        eatTest((String food)->{
            System.out.println("小六中午吃的的是" + food);
        });
          // 4. lambda简写
        eatTest(food -> System.out.println("小八中午吃的是" + food));
    }
    private static void eatTest(eat e){
        e.dine("苹果");
    }
}

运行结果：

抽象方法两个参数

创建一个名字为ADD的接口

package com.itxs.demo03;

/**
 * @Classname : ADD
 * @Description : TODO 计算两个数相加的接口
 * @Author : lin_refuel@qq.com
 */
public interface ADD {
    Integer addition(Integer a,Integer b);
}

demo02:测试类,调用上面的接口

package com.itxs.demo03;

/**
 * @Classname : demo02
 * @Description : TODO
 * @Author : lin_refuel@qq.com
 */
public class demo02 {
    public static void main(String[] args) {
        // 3种方式调用接口ADD里面的方法
        // 通过匿名内部类
        red(new ADD() {
            @Override
            public Integer addition(Integer a, Integer b) {
                return a + b;
            }
        });
        //通过lambda方式进行实现
        red((Integer a, Integer b) -> {
            return a - b;
        });
        //lambda简写
        //省去形参的类型 里面只有一行代码省去大括号，
        red((a, b) -> a * b);
    }

    private static void red(ADD a) {
        Integer res = a.addition(7, 8);
        System.out.println("res = "+ res);
    }
}

运行结果：

啦么大 使用的注意事项

• 要实现的接口中保证：有且仅有一个抽象方法 （叫做函数式接口）

• 必须有类型指向，才能确定 啦么大 对应的接口（传参 或者 多态）

啦么大 与 匿名内部类

• 内部类 - 万能，接口、抽象类、普通的类均可

• 啦么大 - 接口！只能针对于接口，其他类则不可以，而且接口中要求有且仅有一个抽象方法

• 匿名内部类在编译运行的时候会生成可见的 字节码文件（.class），啦么大 则不会