-
2020-02-13 16:09:17
利用lamda表达式实现接口方法
更多干货见博主个人网站:https://blog.zhenglin.work
若想直接使用 接口中方法,在jdk8之前的做法有:1,编写一个类实现这个接口的(抽象)方法;2,或者直接在创建对象时 采用匿名类。- 接口:
package com.zhengling.work; public interface DecoratorF { void m1(); }
- 里面有个方法m1;如果想调用m1方法,必须先实现这个接口的m1方法。用匿名内部类来实现:
DecoratorF df = new DecoratorF() { @Override public void m1() { System.out.println("内部匿名类实现m1方法"); } }; df.m1();
- 这样就可以直接调用m1方法;或者搞一个内部类来实现这个接口:
static class B implements DecoratorF{ @Override public void m1() { System.out.println("静态内部类实现接口的m1方法"); } //定义为静态内部类 方便在main方法中调用 }
然后用多态的特点 调用m1方法:
DecoratorF def = new B(); def.m1();
上面不管哪种写法都显得比较繁琐,而且效率不高。jdk8推出了lamda表达式,采用这种形式能快速简化代码;说句题外话Python中lamda已经推出好久了,以后编程语言会大一同,很多优秀规范、表达式会互相借鉴。像jdk13中也引入了三个双引号 +内容+三个双引号,可以原样保持内容的规范、switch表达式借鉴swift语言写法。总之就是代码上越来越简单。
lamda表达式写法
public static void doM1(DecoratorF df){ df.m1(); }
之所以定义为static类型方法,是方便在main中调用和测试。 上面方法是直接调用了m1方法,在main方法中,调用时 用lamda表达式实现接口中的方法。
doM1(()-> System.out.println("lamda表达式实现的抽象方法"));
doM1(这个里面其实是DecoratorF 类型参数,这个参数并且实现了m1方法),由于m1是没有参数的方法,可以直接写成()->{} ,由于方法体就是一句话,{}可以省略。如果有参数可以写成 (parm1,parm2)->{}这种形式。
- 不适用地方,接口中有多个方法的。
更多相关内容 -
Java开发技巧——Lamda表达式实现接口
2020-04-03 20:17:19Lamda作为Java8引入的语法,不会的话...1.Lamda表达式常用情景:实现Runnbale接口创建线程 我们经常可以在编程中看到如下代码: public class test { public static void main(String[] args) { Thread thread...Lamda作为Java8引入的语法,不会的话也不影响我们的正常开发,但如果学会的话,可以极大地减少我们的无用代码数量,让我们一起来看一下!
1.Lamda表达式常用情景:实现Runnbale接口创建线程
我们经常可以在编程中看到如下代码:
public class test { public static void main(String[] args) { Thread thread = new Thread(()-> {/*某耗费时间的代码*/}); thread.start(); } }
这其实就是我们Lamda表达式的使用方式之一:快速创建匿名类
如果我们不使用Lamda表达式,当然也可以实现相同的功能,不过,要花费的固定格式的代码就要多很多。比如:
public class test { public static void main(String[] args) { Thread thread = new Thread(new Runnable() { @Override public void run() { /*耗费时间的代码*/ } }); thread.start(); } }
可以看到,如果实现接口,要将实现接口的固定格式全部写出(接口名方法名等),而Lamda则可以使用一行代码搞定,极大简化我们的代码,看起来不会乱糟糟~
2.Lamda表达式的使用
Lamda表达式的基本格式:()->{}
其中()括号内填写的是方法的参数,{}大括号内填写的是方法实现语句举例说明:实现Runnable接口,就可以这样来写
public class test { public static void main(String[] args) { Runnable myRunnable = () -> { for(int i=0;i<100;i++) { System.out.println(i); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }; } }
因为run方法没有参数,所以并不需要在括号内填写参数。
现在来举个例子模拟有参数的情况:
现在我们创建一个IEat接口,其中有一个eat方法,还有一个PersonEat方法,使用到了该接口的抽象方法,方法中内容需要我们自己实现,参数为eat的内容!
public class test { //此方法调用了IEat接口中的eat方法 public static void personEat(IEat e) { e.eat("蔬菜"); } public static void main(String[] args) { IEat e = new IEat() { @Override public void eat(String v) { System.out.println("正在吃"+v); } }; personEat(e); } } interface IEat { void eat(String v); }
以上就是我们通过匿名类实现接口并使用的例子,可以发现,我们写了很多的不必要内容,来实现eat方法!
而使用我们Lamda表达式就很方便:
public class test { //此方法调用了IEat接口中的eat方法 public static void personEat(IEat e) { e.eat("蔬菜"); } public static void main(String[] args) { IEat e = (String v) -> {System.out.println("正在吃" + v);}; personEat(e); } } interface IEat { void eat(String v); }
此时就可以发现,我们化简了很多规定格式的代码,使项目更加简洁,省掉了很多不必要的内容!
变式写法:
1.我们在此基础上,还可以去参数类型
IEat e = (v) -> {System.out.println("正在吃" + v);};
2.除了去掉参数类型 ,如果只有一个参数,还可以去掉括号
IEat e = v -> {System.out.println("正在吃" + v);};
3.如果实现方法的代码只有一条,连大括号都可以去掉
IEat e = v -> System.out.println("正在吃" + v);
4.如果在想懒一下,我们甚至可以直接将Lamda表达式直接写入到参数内
personEat(v -> System.out.println("正在吃" + v));
写到这个时候我们就可以很明显发现,我们(画红框)7行代码,使用Lamda表达式之后,只需要一行代码就可以搞定!
此时如果有人问:
方法没有参数怎么办?
public class test { //此方法调用了IEat接口中的eat方法 public static void personEat(IEat e) { e.eat(); } public static void main(String[] args) { //直接使用空括号就可以了 personEat(() -> System.out.println("正在吃蔬菜")); } } interface IEat { //没有参数 void eat(); }
有返回值怎么办?
public class test { //此方法调用了IEat接口中的eat方法 public static void personEat(IEat e) { //输出处理结果 System.out.println(e.eat("蔬菜")); } public static void main(String[] args) { //对字符串进行处理 personEat(v -> "正在吃" + v); } } interface IEat { //返回字符串 String eat(String v); }
总结来说:Lamda表达式是对抽象方法的快速实现,并且为了追求效率,编译器会根据接口定义自动推断参数类型和返回值,所以,都可以进行省略,不会报错!
-
Lamda表达式好处、Lamda表达式演变、Lamda表达式使用总结
2022-02-11 09:55:47使用内部类定义实现类2.1静态内部类2.2局部内部类2.3匿名内部类3.Lamda表达式3.1Lamda表达式继续简化Lamda表达式使用总结 使用Lamda表达式的好处 避免匿名内部类定义过多 可以让代码看起来更简洁 去掉一对无意义的...Lamda表达式好处、Lamda表达式演变、Lamda表达式使用总结
使用Lamda表达式的好处
- 避免匿名内部类定义过多
- 可以让代码看起来更简洁
- 去掉一对无意义的代码,只留下核心逻辑
Functional Interfere:函数式接口
理解Functional Interfere:函数式接口是学习Lamda表达式的关键。
注意:只有函数式接口才可以使用Lamda表达式
函数式接口定义:
- 任何接口,如果只包含唯一一个抽象方法,那么就是一个函数式接口
public interface Runable(){ public abstract void run(); }
- 对于函数式接口,可以通过Lamda表达式来创建该接口的对象
Lamda表达式的演变过程
1.一个接口对应多个实现类,造成编写的文件数量很多
package testlamda; public class Test1 { public static void main(String[] args) { PeopleCan iCan = new ICan(); iCan.doSomething(); } } //1.定义一个函数式接口 interface PeopleCan { //Java 中接口的方法默认是 public abstract的 void doSomething(); } //2.定义实现类 class ICan implements PeopleCan{ @Override public void doSomething() { System.out.println("我能吃饭"); } }
正常是独立文件定义接口和实现类,这里只是演示,就在一个文件定义。
2.使用内部类定义实现类
2.1静态内部类
其他类中定义定义实现类,省去一个实现类文件ICan2
package testlamda; public class Test2 { //2.定义实现类:静态内部类 static class ICan2 implements PeopleCan2{ @Override public void doSomething() { System.out.println("我能吃饭2"); } } public static void main(String[] args) { PeopleCan2 iCan = new ICan2(); iCan.doSomething(); } } //1.定义一个函数式接口 interface PeopleCan2 { //Java 中接口的方法默认是 public abstract的 void doSomething(); }
2.2局部内部类
用的时候再定义实现类ICan3
package testlamda; public class Test3 { public static void main(String[] args) { //2.定义实现类:局部内部类 class ICan3 implements PeopleCan3{ @Override public void doSomething() { System.out.println("我能吃饭3"); } } PeopleCan3 iCan = new ICan3(); iCan.doSomething(); } } //1.定义一个函数式接口 interface PeopleCan3 { //Java 中接口的方法默认是 public abstract的 void doSomething(); }
2.3匿名内部类
匿名内部类(没有类的名称,必须借助接口或者父类),这个实现类没有名字
package testlamda; public class Test4 { public static void main(String[] args) { //2.定义实现类:匿名内部类(没有类的名称,必须借助接口或者父类) PeopleCan4 iCan = new PeopleCan4(){ @Override public void doSomething() { System.out.println("我能吃饭4"); } }; iCan.doSomething(); } } //1.定义一个函数式接口 interface PeopleCan4 { //Java 中接口的方法默认是 public abstract的 void doSomething(); }
3.Lamda表达式
package testlamda; public class Test5 { public static void main(String[] args) { //2.定义实现类:Lamda表达式,()里可以传参数 PeopleCan4 iCan = () -> { System.out.println("我能吃饭5"); }; iCan.doSomething(); } } //1.定义一个函数式接口 interface PeopleCan5 { //Java 中接口的方法默认是 public abstract的 void doSomething(); }
3.1Lamda表达式继续简化
package testlamda; public class Test5 { public static void main(String[] args) { //Lamda表达式,()里可以传参数 // PeopleCan5 iCan = (String sth) -> { // System.out.println(sth); // }; //简化1:省略参数类型,多个参数也可以去掉参数类型,但要去就都去掉 // PeopleCan5 iCan = (sth) -> { // System.out.println(sth); // }; //简化2:省略括号() // PeopleCan5 iCan = sth2 -> { // System.out.println(sth2); // }; //简化3:省略括号{},这个省略是因为方法体只有System.out.println(sth3);一行,多行就不能省略 PeopleCan5 iCan = sth3 -> System.out.println(sth3); iCan.doSomething("我能吃饭5"); } } //1.定义一个函数式接口 interface PeopleCan5 { //Java 中接口的方法默认是 public abstract的 void doSomething(String sth); }
Lamda表达式使用总结
- 省略括号{},这个省略是因为方法体只有一行,多行就不能省略
- 省略参数类型,多个参数也可以去掉参数类型,但要去就都去掉
- 只有函数式接口才可以使用Lamda表达式
JUC:11四大原生函数式接口:函数型接口Function、判断型函数接口Predicate、Supplier供给型接口、消费型接口Consumer
lambda表达式过滤、链式编程、函数式接口、Stream流式计算
-
Lamda表达式详解
2020-07-23 12:00:13Lamda表达式 1、λ 希腊字母表中排序第十一位的字母,英语名称为 Lamda 2、避免匿名内部类定义过多 3、可以让你的代码看起来很简洁 4、去掉了一堆没有意义的代码,留下核心的逻辑 3、其实质属于函数式编程的概念 ...Lamda表达式
1、λ 希腊字母表中排序第十一位的字母,英语名称为 Lamda
2、避免匿名内部类定义过多
3、可以让你的代码看起来很简洁
4、去掉了一堆没有意义的代码,留下核心的逻辑
3、其实质属于函数式编程的概念(params)-> expression[表达式]
(params) -> statement[语句]
(params) -> {statements}
a -> System.out.println("i like lamda-->"+a)
new Thread (()->System.out.println(“多线程学习。。。。”)).start();
怎么理解
1、理解Functional interface(函数式接口)是学习java8 lamda表达式的关键所在。
2、函数式接口的定义:
- 任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口。
public interface Runnable{ public abstract void run(); }
- 对于函数式接口,我们可以通过lamda表达式来创建该接口的对象
代码推导λ表达式
package com.haiyang.lamda; public class TestLamda01 { //3、静态内部类,同样实现ILike接口 static class Like2 implements ILike{ @Override public void lamda() { System.out.println("i like lamda2"); } } public static void main(String[] args) { ILike like = new Like(); like.lamda(); like = new Like2(); like.lamda(); //4、局部内部类 class Like3 implements ILike{ @Override public void lamda() { System.out.println("i like lamda3"); } } like = new Like3(); like.lamda(); //5、匿名内部类,没有类的名称。必须借助接口或者父类 like = new ILike() { @Override public void lamda() { System.out.println("i like lamda4"); } }; like.lamda(); //6、lamda表达式 like = ()->{ System.out.println("i like lamda5"); }; like.lamda(); } } //1、定义一个只有一个抽象方法的接口 interface ILike{ abstract void lamda(); } //2、实现类 class Like implements ILike{ @Override public void lamda() { System.out.println("i like lamda1"); } }
输出:
带一个参数的Lamda简化
package com.haiyang.lamda; public class TestLamda02 { public static void main(String[] args) { ILive live = null; //Lamda简化 live = (int a)->{ System.out.println("I live you"+a); }; live.live(1); //Lamda简化参数类型 live = (a)->{ System.out.println("I live you"+a); }; live.live(2); //Lamda简化括号 live = a->{ System.out.println("I live you"+a); }; live.live(3); //Lamda简化花括号(只有一条语句时) live = a->System.out.println("I live you"+a); live.live(4); } } interface ILive{ abstract void live(int a); }
输出:
带多个参数的Lamda简化
package com.haiyang.lamda; public class TestLamda02 { public static void main(String[] args) { ILive live = null; //Lamda简化 live = (int a,int b)->{ System.out.println("I live you"+a+b); }; live.live(1,1); //Lamda简化参数类型(要去掉就要都去掉) live = (a,b)->{ System.out.println("I live you"+a+b); }; live.live(2,2); //Lamda简化花括号(只有一个语句时) live = (a,b)->System.out.println("I live you"+a+b); live.live(3,3); } } interface ILive{ abstract void live(int a,int b); }
输出:
-
Java中Lamda表达式和实例化类的几种方式
2021-03-26 18:51:10Lamda表达式作用: * 避免匿名内部类定义过多 * 可以让代码看起来更简洁 * 去掉了一些没有意义的代码,只留下核心的逻辑 创建函数式接口ILike 以及实例化 函数式接口定义:任何接口,只包含一个抽象方法,那么就是一... -
Lamda表达式
2022-02-23 20:07:25定义:任何接口,如果它只包含唯一一个抽象方法,那么它就是一个函数式接口。 对于函数式接口,我们可以通过Lamda表达式来创建该接口的对象。 Lamda表达式 定义:Lamda表达式是一个匿名函数,它是基于数学中的λ演算... -
C++ lamda表达式
2018-07-31 10:35:25lamda表达式是c++11规范引入的新语法。这是一个已经出现在众多语言中的一个语法形式。引用百科中对于lamda表达式的解释: “Lambda 表达式”(lambda expression)是一个匿名函数,Lambda表达式基于数学中的λ演算... -
lamda表达式是啥?是如何来的呢?如何快速理解lamda表达式
2022-01-16 21:16:30lamda表达式是一种函数式接口,可以使代码更加简洁。 何为函数式接口,若一个接口只包含唯一一个抽象方法,那么它就是一个函数式接口。 lamda表达式是何如来简化代码的呢?往下看。 举个栗子 1.首先是我们... -
java lamda表达式
2021-08-25 13:09:551 lamda表达式的意义:简化冗余的代码 2 lamda表达式的标准格式;(重写方法的参数列表) -> {重写接口的抽象方法} 举例:无参数无返回值的lambda表达式 //自定义一个抽象接口,里面有一个抽象方法叫做makefood package ... -
lambda表达式实现原理分析
2021-12-12 10:33:14本文将深入了解lambda表达式的实现原理和这样的实现方案的取舍权衡。 Java为什么需要lambda表达式? 能够提升代码简洁性、提高代码可读性。 例如,在平时的开发过程中,把一个列表转换成另一个列表或map等等这样... -
lamda表达式
2021-04-16 11:32:23理解Functional Interface(函数式接口是学习lamda表达式的关键所在) 函数式接口: 任何接口,如果只包含唯一一个抽象方法,那么他就是一个函数式接口 对于函数式接口,可以通过lamda表达式来创建该接口的对象 ... -
java-Lamda表达式
2021-06-20 11:29:20lamda表达式:1.定义1.1 lamda表达式的语法1.2 函数时接口1.3 代码演示2.变量捕获;2.1 匿名内部类2.2 Lamda的变量捕获3.lamda表达式在集合中的用法3.1 Collection接口示例3.3 Map接口4.总结 1.定义 Lambda表达式是... -
多线程—Lamda表达式
2022-02-02 18:26:04笔记总结—如何快速理解多线程Lamda表达式 -
【无标题】lamda表达式
2022-03-14 13:23:582 lamda表达式组成: ()-> {} 参数列表 被引用 方法体 1)参数类型可以省略,如果要省略,就要把每个参数类型都要省略; 2)如果参数的小括号中只有一个参数,那么小括号可以省略 3)如果方法体中只有一句... -
Java提升二:Lambda表达式与方法引用
2021-03-08 16:30:351、Lambda表达式1.1、定义lambda表达式是对于函数式接口(只含有一个抽象方法的接口)的简洁实现方式。它与匿名内部类的作用相似,但是就使用范围而言,匿名内部类更为广泛,而lambda表达式则更为简洁。1.2、使用... -
lamda表达式与函数式接口
2021-11-26 15:09:27lamda表达式,也叫做闭包,lamda表达式允许把函数做为一个方法的参数 语法: (parameters) -> expression 或 (parameters) ->{ statements; } 可选类型声明:不需要声明参数类型,编译器可以统一识别参数值... -
JAVA基础--Lamda表达式&方法引用
2021-11-05 10:28:56JAVA基础---Lamda表达式与方法引用 什么是函数式接口: 函数式接口有且仅有一个抽象方法,可以有多个普通方法和静态方法。 Java中对函数式接口的编译约束定义了@FunctionalInterface注释;标注了@Functional... -
lamda表达式以及推导
2022-02-16 11:56:20接口只包含一个抽象方法,就是函数式接口 总结 lambda表达式只能由一行代码才能简化为一行代码,如果有多行,只能使用代码块包裹 前提是函数式接口 多个参数也可以去掉参数类型,要去掉就都去掉,必须加上() ... -
Java多线程(三):lamda表达式
2022-03-15 10:26:37Lamda表达式 学习视频:【狂神说Java】多线程详解 up主:遇见狂神说 ...任何接口,如果只含唯一一个抽象方法,那么它就是一个函数式接口 对于函数式接口,我们可以通过lamda表达式来创建接口的对象 ... -
Lamda 表达式简介
2018-12-06 18:20:29Lamda 表达式基于JDK1.8 1.0 认识一下Lamda 表达式的作用 2.0 掌握Lamda 表达式的基础语法 二、过程 Lamda 是一种基于函数的编程语言,对于这种类型的语言典型的代表就是Haskell。但是从...