flyable java_Java Lambda表达式

了解函数式编程

函数：在数学中，函数就是就输入量、输出量的一套计算方案，也就是“拿数据做操作”。

在面向对象编程中，强调通过面向对象的思想解决问题；

而函数式编程忽略了面向对象编程的复杂语法，屏蔽过程，强调“做什么”，忽略“怎么做”。

小栗子

需求：启动一个线程，在控制台打印一句话：“线程启动了”。

方式一

传统方式：创建一个类MyRunable实现Runable接口，通过这种实现类的方式实现需求。

package net.pjsk.demo;

/**

* @author liyan

* @date 2021.2.18

*/

public class MyRunable implements Runnable{

@Override

public void run() {

System.out.println("线程启动了");

}

}

package net.pjsk.demo;

/**

* @author liyan

* @date 2021.2.18

*/

public class LambdaDemo {

public static void main(String[] args) {

// 通过实现类的方式实现

MyRunable myRunable = new MyRunable();

new Thread(myRunable).start();

}

}

方式二

匿名内部类

package net.pjsk.demo;

/**

* @author liyan

* @date 2021.2.18

*/

public class LambdaDemo {

public static void main(String[] args) {

// 通过匿名内部类的方式实现

new Thread(new Runnable() {

@Override

public void run() {

System.out.println("线程启动了");

}

}).start();

}

}

方式三

Lambda表达式

package net.pjsk.demo;

/**

* @author liyan

* @date 2021.2.18

*/

public class LambdaDemo {

public static void main(String[] args) {

// 通过Lambda表达式实现

new Thread(() -> {

System.out.println("线程启动了");

}).start();

}

}

Lambda 表达式的格式

Lambda表达式由参数列表、箭头、代码块三部分构成。

new Thread(() -> {

System.out.println("线程启动了");

}).start();

Lambda 表达式使用前提

有一个接口

该接口有且只有一个抽象方法

这种接口也成为“函数式接口”。

练习一

定义一个接口(Eatable)，里面定义一个抽象方法， void eat()

定义一个测试类(EatableDemo)，里面提供两个方法：

void useEatable(Eatable e)

main()方法，用来调用useEatable()方法

package net.pjsk.test1;

// 方式一需要创建接口的实现类，并重写方法

public class EatableImpl implements Eatable{

@Override

public void eat() {

System.out.println("多吃蔬菜和水果");

}

}

package net.pjsk.test1;

/**

* @author liyan

* @date 2021.2.18

*/

public class EatableDemo {

public static void main(String[] args) {

// 方式一、先创建实现类重写eat()方法，再使用

Eatable eatable = new EatableImpl();

useEatable(eatable);

// 方式二、直接传入匿名内部类

useEatable(new Eatable() {

@Override

public void eat() {

System.out.println("多吃蔬菜和水果");

}

});

// 方式三、 使用Lambda 表达式

useEatable(() -> {

System.out.println("多吃蔬菜和水果");

});

}

public static void useEatable(Eatable e) {

e.eat();

}

}

练习二

定义一个接口(Flyable)，里面定义一个抽象方法， void fly(String s)

定义一个测试类(FlyableDemo)，里面提供两个方法：

void useEatable(Flyable f)

main()方法，用来调用useFlyable()方法

package net.pjsk.test2;

// 方式一，接口实现类

public class FlyableImpl implements Flyable {

@Override

public void fly(String s) {

System.out.println(s + "会飞");

}

}

package net.pjsk.test2;

/**

* @author liyan

* @date 2021.2.18

*/

public class FlyableDemo {

public static void main(String[] args) {

// 方式一、创建接口实现类

Flyable flyable = new FlyableImpl();

useFlyable(flyable);

// 方式二、匿名内部类

useFlyable(new Flyable() {

@Override

public void fly(String s) {

System.out.println(s + "会飞");

}

});

// Lambda 表达式

useFlyable((s -> {

System.out.println(s + "会飞");

}));

}

public static void useFlyable(Flyable f) {

f.fly("花花");

}

}

练习三

定义一个接口(Addable)，里面定义一个抽象方法， int add(int x,int y)

定义一个测试类(FlyableDemo)，里面提供两个方法：

void useAddable(Addable a)

main()方法，用来调用useAddable()方法

package net.pjsk.test3;

/**

* @author liyan

* @date 2021.1.18

*/

public class AddableDemo {

public static void main(String[] args) {

// 匿名内部类

useAddable(new Addable() {

@Override

public int add(int x, int y) {

return x + y;

}

});

// Lambda 表达式

useAddable((x, y) -> {

return x + y;

});

}

public static void useAddable(Addable a) {

int result = a.add(1, 2);

System.out.println(result);

}

}

Lambda 表达式简写

简写规则如下：

参数列表中参数的数据类型可以省略，多个参数时，参数的数据类型要么都省略，要么都不省略；

参数列表中只有一个参数时，小括号也可以省略；

代码块只有一行时，大括号和分号可以省略；当有return时，则return也要省略；省略大括号分号时，Lambda 表达式要写成一行。

Lambda表达式和匿名内部类的区别

所需类型不同：

匿名内部类：可以是接口、抽象类、具体类

Lambda表达式：只能是接口

使用限制不同：

如果接口中有且只有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类；

如果接口中有多个抽象方法，只能使用匿名内部类

实现原理不同：

使用匿名内部类的形式，在程序编译后，会产生一个单独的.class字节码文件

使用Lambda表达式，编译后不会产生单独的字节码文件，对应的字节码文件在程序运行时动态生成。