Lambda表达式
函数式编程思想概述
在数学中,函数就是有输入量,输出量的一套计算方案,也就是"拿数据做操作"
面向对象思想强调"必须通过对象的形式来做事情"
函数式思想则尽量忽略面向对象的复杂语法 : “强调做什么,而不是以什么形式去做”
而我们要学习的Lambda表达式就是函数式思想的体现
体验Lambda表达式
需求: 启动一个线程,在控制台输出一句话,多线程程序启动了
方式1:
- 定义一个myrunable类实现Runnable接口,重写run()方法
- 创建myrunnable类的对象
- 创建thread类的对象,把myrunnable的对象作为构造参数传递
- 启动线程
方式2:
- 匿名内部类的方式改进
方式3
- Lambda表达式的方式改进
Lambda表达式的标准格式
匿名内部类中重新run()方法的代码分析
- 方法形式参数为空,说明调用方法时不需要传递参数
- 方法返回值类型为void ,说明方法执行没有结果返回
- 方法体中的内容,是我们具体要做的事情
Lambda表达式的代码分析
- (): 里面没有内容,可以看成是方法形式参数为空
- ->:用箭头指向后面要做的事情
- { } :包含一段代码,我们称之为代码块,可以看成是方法体中的内容
组成Lambda表达式的三要素: 形式参数,箭头,代码块
Lambda表达式的标准格式
Lambda表达式的格式
- 格式: (形式参数)->{代码块}
- 形式参数: 如果有多个参数,参数之间用逗号隔开,如果没有参数,留空即可
- -> : 由英文中画线和大于符号组成,固定写法,代表指向动作
- 代码块: 是我们具体要做的事情,也就是以前我们写的方法体内容
Lambda表达式的练习
Lambda表达式的使用前提
- 有一个接口
- 接口中有且仅有一个抽象方法
练习1:
- 定义一个接口(Eatable),里面定义一个抽象方法: void eat();
- 定义一个测试类(EatableDemo),在测试类中提供两个方法
一个方法是: useEatable(Eatable e)
一个方法是主方法, 在主方法中调用useEatable方法
package com.itdemo_29;
public class EatableDemo {
public static void main(String[] args) {
//在主方法中调用useEatable方法
Eatable e = new EatableImpl();
useEatable(e);
//匿名内部类
useEatable(new Eatable() {
@Override
public void eat() {
System.out.println("一天一苹果");
}
});
//Lambda表达式
useEatable(()->{
System.out.println("医生远离我");
});
}
private static void useEatable(Eatable e) {
e.eat();
}
}
练习2
- 定义一个接口(Flyable),里面定义一个抽象方法: void fly(String s);
- 定义一个测试类(FlyableDemo),在测试类中提供两个方法
一个方法是useFlyable(Flyable f)
一个方法是主方法: 在主方法中调用useFlyable方法
public interface Flyable {
void fly(String s);
}
package com.itdemo_29;
public class FlyableDemo {
public static void main(String[] args) {
//在主方法中调用useFlyable方法
Flyable f = new FlyableImpl();
useFlyable(f);
//匿名内部类
useFlyable(new Flyable() {
@Override
public void fly(String s) {
System.out.println(s);
System.out.println("自驾游");
}
});
System.out.println("-------");
//Lambda
useFlyable((String s)->{
System.out.println(s);
System.out.println("日韩游");
});
}
private static void useFlyable(Flyable f){
f.fly("风和日丽");
}
}
class FlyableImpl implements Flyable{
@Override
public void fly(String s) {
System.out.println("郊游");
}
}
练习3:
- 定义一个接口,(Addable) ,里面定义一个抽象方法,int add(int x,int y);
- 定义一个测试类(AddableDemo),在测试类汇中提供两个方法
一个方法是: useAddable(Addable a)
一个方法是主方法,在主方法中调用useAddablfe方法
public interface Addable {
int add(int x,int y);
}
package com.itdemo_29;
public class AddableDemo {
public static void main(String[] args) {
// Lambda
useAddable((int x,int y)->{
return x+y;
});
}
private static void useAddable(Addable a){
int sum = a.add(10, 29);
System.out.println(sum);
}
}
Lambda表达式的省略模式
省略的规则
- 参数类型可以省略,但是有多个参数的情况下,不能只省略一个
- 如果参数有且仅有一个,那么小括号可以省略
- 如果代码块的语句只有一条,可以省略大括号和分号,和return关键字
public interface Addable {
int add(int x,int y);
}
public interface Flyable {
void fly(String s);
}
package com.itdemo_29;
public class LambdaDemo01 {
public static void main(String[] args) {
useFlyable((String s)->{
System.out.println(s);
});
//如果参数只有一个,小括号可省略,参数类型可省略
useFlyable(s->{
System.out.println(s);
});
///如果代码块的语句只有一条，可以省略大括号和分号
useFlyable(s-> System.out.println(s));
useAddable((int x,int y)->{
return x+y;
});
//参数类型要省略,都必须省略
useAddable((x,y)->{
return x+y;
});
//如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉
useAddable((x,y)->x+y);
}
private static void useFlyable(Flyable f){
f.fly("风和日丽");
}
private static void useAddable(Addable a){
int sum = a.add(10,20);
System.out.println(sum);
}
}
Lambda表达式的注意事项
- 使用Lambda必须要有接口,并且要求接口中有且仅有一个抽象方法
- 必须有上下文环境,才能推导出Lanbda对应的接口
- 根据局部变量的赋值得知Lambda对应的接口
Runnable r =() ->System.out.println(“Lambda表达式”); - 根据调用方法的参数得知Lambda对应的接口
new Thread(()->System.out.println(“Lambda表达式”)).start();
- 根据局部变量的赋值得知Lambda对应的接口
package com.itdemo_29;
public class LambdaDemo02 {
public static void main(String[] args) {
useInter(()->{
System.out.println("好好学习");
});
//使用Lambda必须有接口, 并且要求接口中有且仅有一个抽象方法
useInter(()-> System.out.println("好好学习"));
//必须有上下文环境,才能推导出Lambda对应的接口
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类");
}
}).start();
Runnable r = ()-> System.out.println("lambda表达式");
new Thread(r).start();
new Thread(()-> System.out.println("lambda表达式")).start();
}
private static void useInter(Inter i){
i.show();
}
}
Lambda表达式和匿名内部类的区别
所需类型不同
- 匿名内部类: 可以是接口,可以是抽象类,可以是具体类
- Lambda表达式: 只能是接口
使用限制不同
- 如果接口中有且仅有一个抽象方法,可以使用Lambda表达式,也可以使用匿名内部类
- 如果接口中多了一个抽象方法,只能使用匿名内部类,而不能使用Lambda表达式
实现原理不同
- 匿名内部类: 编译之后,产生一个单独的.class字节码文件
- Lambda表达式: 编译之后,没有一个单独的.class字节码文件,对应的字节码会在运行时候动态生成
public abstract class Animal {
public abstract void method();
}
public interface Inter {
void show();
// void show2();
}
public class Student {
public void study(){
System.out.println("爱学习");
}
}
package com.itdemo_29;
public class LambdaDemo03 {
public static void main(String[] args) {
//匿名内部类
useInter(new Inter() {
@Override
public void show() {
System.out.println("接口");
}
});
// useAnimal(new Animal() {
// @Override
// public void method() {
// System.out.println("抽象类");
// }
// });
// useStudent(new Student(){
// @Override
// public void study() {
// System.out.println("具体类");
// }
// });
//lanbda
// useInter(()-> System.out.println("接口"));
// useAnimal(()-> System.out.println("抽象");//是接口类型
// useStudent(()-> System.out.println("具体类"));
//当有多个接口
// useInter(()-> System.out.println("接口"));
// useInter(new Inter() {
// @Override
// public void show() {
// System.out.println("show");
// }
//
// @Override
// public void show2() {
// System.out.println("show2");
// }
// });
}
private static void useStudent(Student s){
s.study();
}
private static void useAnimal(Animal a){
a.method();
}
private static void useInter(Inter i){
i.show();
}
}
接口的组成更新
接口组成更新概述
接口的组成
- 常量
public static final - 抽象方法
public abstract - 默认方法(java 8)
- 静态方法(java 8)
- 私有方法(java 9)
接口中默认方法
- 格式:
public default 返回值类型 方法名(参数列表){ } - 范例
public default void show3(){
}
- 注意事项
- 默认方法不是抽象方法,所以不强制被重写,但是可以被重写,重写的时候去掉default关键字
- public 可以省略,default 不能被省略
public interface MyInterface {
void show1();
void show2();
//默认方法
default void show3(){
System.out.println("show3");
}
}
public class MyInterfaceDemo {
public static void main(String[] args) {
MyInterface my = new MyInterfaceImplOne();
my.show1();
my.show2();
my.show3();
}
}
public class MyInterfaceImplOne implements MyInterface{
@Override
public void show1() {
System.out.println("One show1");
}
@Override
public void show2() {
System.out.println("One show2");
}
@Override
public void show3() {
System.out.println("One show3");
}
}
public class MyInterfaceImplTwe implements MyInterface{
@Override
public void show1() {
System.out.println("Two show1");
}
@Override
public void show2() {
System.out.println("Two show2");
}
}
接口中静态方法
接口中静态方法的定义格式
- 格式: public static 返回值类型 方法名 (参数列表){}
- 范例
public static void test(){}
接口中静态方法的注意事项
- 静态方法只能通过接口名调用,不能通过实现类名或者对象名调用
- public 可以省略,static不可以省略
public interface Flyable {
public static void test(){
System.out.println("Flyable的静态方法");
}
}
public interface Inter {
//抽象方法
void show();
default void mothod(){
System.out.println("Inter中的默认方法");
}
static void test(){
System.out.println("Inter中的静态方法");
}
}
public class InterImpl implements Inter{
@Override
public void show() {
System.out.println("实现类中show");
}
}
public class InterDemo {
public static void main(String[] args) {
//按照多态的方式创建对象使用
Inter i =new InterImpl();
i.show();
i.mothod();
//静态方法不能通过实现类名或者对象调用
// i.test();
// InterImpl.test();
//只能通过接口名调用
Inter.test();
Flyable.test();
}
}
接口中私有方法
Java 9 新增了带方法的私有方法,这其实在Java 8中就埋下了伏笔;Java8允许在接口中定义带方法体的默认方法和静态方法,这样可能会引发一个问题: 当两个默认方法或者静态方法中包含一段相同的代码实现时,程序必然考虑将这段实现代码抽取成一个共性方法,而这个共性方法是不需要让别人使用的,因此用私有给隐藏起来,这就是java9增加是由方法的必然性
接口中私有方法的定义格式:
- 格式1 :private 返回值类型 方法名(参数列表){}
- 范例1: private void show(){}
- 格式2: private static 返回值类型 方法名 (参数列表){}
- 范例2: private static void method(){}
接口中私有方法的注意事项
- 默认方法可以调用私有静态方法和非静态方法
- 静态方法只能调用私有的静态方法
public interface Inter01 {
//默认方法
default void show1(){
System.out.println("show1开始执行");
// System.out.println("初级工程师");
// System.out.println("中级工程师");
// System.out.println("高级工程师");
// show();
method();
System.out.println("show1结束执行");
}
default void show(){
System.out.println("初级工程师");
System.out.println("中级工程师");
System.out.println("高级工程师");
}
//静态方法
static void method1() {
System.out.println("method1开始执行");
// System.out.println("初级工程师");
// System.out.println("中级工程师");
// System.out.println("高级工程师");
// show();
method();
System.out.println("method1结束执行");
}
static void method(){
System.out.println("初级工程师");
System.out.println("中级工程师");
System.out.println("高级工程师");
}
}
public class InterImpl01 implements Inter01{
}
public class InterDemo01 {
public static void main(String[] args) {
//按照多态的方式创建对象并使用
Inter01 i = new InterImpl01();
i.show1();
Inter01.method1();
}
}
方法引用
体验方法引用
在使用Lambda表达式的时候, 我们实际上传递进去的代码就是一种解决方案: 拿参数做操作
那么考虑一种情况: 如果我们在Lambda中所指定的操作方案,已经有地方存在相同的方案,那么是否有必要在写重复逻辑呢?
答案肯定是没必要的
我们又是如何使用已经存在的方案的呢?
是通过方法引用的来使用已经存在的方案
package com.itdemo_30;
import com.itdemo_26.SystemOutDemo;
public class PrintableDemo {
public static void main(String[] args) {
usePrintable((String s)->{
System.out.println(s);
});
//简化
usePrintable(s-> System.out.println(s));
//方法引用符::
usePrintable(System.out::println);
}
private static void usePrintable(Printable p){
p.printString("aishengho");
}
}
方法引用符
方法引用符
- :: 该符号为引用运算符,而它所在的表达式被称为方法引用
回顾一下我们在体验方法引用中的代码
- Lambda表达式: usePrintable(s->System.out.println(s));
分析: 拿到参数s之后通过Lambda表达式,传递给System.out.println方法去处理 - 方法引用: usePrintable(System.out::println);
分析: 直接使用System.out中的println方法来取代Lambda,代码更加简洁
推导与省略
- 如果使用Lambda,那么根据"可推导就是可省略"的原则,无需指定参数类型,也无需指定的重载形式,它们都将被自动推导
- 如果使用方法引用,也是同样可以根据上下文进行推导
- 方法引用是Lambda的孪生兄弟
public interface Printable01 {
void printInt(int i);
}
public class PrintableDemo01 {
public static void main(String[] args) {
//使用lambda省略
usePrintable(i -> System.out.println(i));
//使用方法引用
usePrintable(System.out::println);
}
private static void usePrintable(Printable01 p) {
p.printInt(666);
}
}
Lambda表达式支持的方法引用
常见引用方法
- 引用类方法
- 引用对象的实例方法
- 引用类的实例方法
- 引用构造器
引用类方法
引用类方法: 其实就是引用类型的静态方法
- 格式: 类名::静态方法
- 范例: Integer::parseInt
Integer类的方法: public static int parseInt(String s)将此String转换为int类型数据
练习:
- 定义一个接口(Converter),里面定义一个抽象方法
int convert(String s) - 定义一个测试类(ConverterDemo)在测试类中提供了两个方法
一个是useConverter(Converter c)
一个方法是主方法,在主方法中调动useConverter方法
public interface Converter {
int convert(String s);
}
public class ConverterDemo {
public static void main(String[] args) {
//在主方法中调用useConverter
useConverter((String s)->{
return Integer.parseInt(s);
});
//简略
useConverter(s->Integer.parseInt(s));
//引用类方法
useConverter(Integer::parseInt);
//Lambda表达式被类方法替代时,它的形式参数全部传递给静态方法作为参数
}
private static void useConverter(Converter c){
int number = c.convert("6666");
System.out.println(number);
}
}
引用对象的实例方法
引用对象的实例方法,其实就是引用类中的成员方法
- 格式: 对象:: 成员方法
- 范例: "HelloWorld "::toUpperCase
String 类中的方法,public string toUpperCase() 将所有字符转换为大写
练习:
- 定义一个类(PrintString) , 里面定义一个方法
public void printUpper(String s):把字符串参数变成大写的数据,然后在控制台输出 - 定义一个接口(Printer),里面定义一个抽象方法
void printUpperCase(String s) - 定义一个测试类(PrinterDemo),在测试类中提供两个方法
一个方法是: usePrinter(Printer p)
一个方法是主方法: 在方法中调用usePrinter方法
public interface Printer {
void printUpperCase(String s);
}
public class PrintString {
public void printUpper(String s){
String result = s.toUpperCase();
System.out.println(result);
}
}
package com.itdemo_30;
public class PrinterDemo {
public static void main(String[] args) {
usePrinter((String s)->{
String result = s.toUpperCase();
System.out.println(result);
});
usePrinter(s-> System.out.println(s.toUpperCase()));
//引用对象的实例方法
PrintString ps = new PrintString();
usePrinter(ps::printUpper);
//Lambda表达式被对象的实例方法替代的时候,它的形式参数全部传递给该方法作为参数
}
private static void usePrinter(Printer p){
p.printUpperCase("helloworld");
}
}
引用构造器
引用构造器,其实就是引用构造方法
- 格式: 类名::new
- 范例: Student::new
练习:
- 定义一个类(Student),里面有两个成员变量(name,age)
并提供无参构造方法和带参构造方法,以及成员变量的get和set方法 - 定义一个接口(StudentBuilder),里面定义一个抽象方法
Student build(String name,int age); - 定义一个测试类(StudentDemo),在测试类中提供两个方法
一个方法是useStudentBuilder(StudentBuilder s)
一个方法是主方法,在主方法中调用useStudentBuilder方法
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public interface StudentBuilder {
Student build(String name,int age);
}
package com.itdemo_30;
public class StudnetDemo {
public static void main(String[] args) {
useStudentBuilder((String name,int age)->{
// Student s = new Student(name,age);
// return s;
return new Student(name,age);
});
//引用类型
useStudentBuilder((name,age)->new Student(name,age));
//引用构造器
useStudentBuilder(Student :: new);
//Lambda表达式被构造器替代的时候,它的形式参数全部传递到构造器作为参数
}
private static void useStudentBuilder(StudentBuilder s){
Student s1 = s.build("萌萌",23);
System.out.println(s1.getName()+","+s1.getAge());
}
}
使用说明
Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数
扫一扫
545
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
