精华内容
下载资源
问答
  • 利用lamda表达式实现接口方法
    千次阅读
    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)->{}这种形式。

    • 不适用地方,接口中有多个方法的。
    更多相关内容
  • Lamda作为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表达式是对抽象方法的快速实现,并且为了追求效率,编译器会根据接口定义自动推断参数类型和返回值,所以,都可以进行省略,不会报错!

    展开全文
  • 使用内部类定义实现类2.1静态内部类2.2局部内部类2.3匿名内部类3.Lamda表达式3.1Lamda表达式继续简化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:13
    Lamda表达式 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);
    }
    

    输出:
    在这里插入图片描述

    展开全文
  • Lamda表达式作用: * 避免匿名内部类定义过多 * 可以让代码看起来更简洁 * 去掉了一些没有意义的代码,只留下核心的逻辑 创建函数式接口ILike 以及实例化 函数式接口定义:任何接口,只包含一个抽象方法,那么就是一...
  • Lamda表达式

    2022-02-23 20:07:25
    定义:任何接口,如果它只包含唯一一个抽象方法,那么它就是一个函数式接口。 对于函数式接口,我们可以通过Lamda表达式来创建该接口的对象。 Lamda表达式 定义:Lamda表达式是一个匿名函数,它是基于数学中的λ演算...
  • C++ lamda表达式

    千次阅读 2018-07-31 10:35:25
    lamda表达式是c++11规范引入的新语法。这是一个已经出现在众多语言中的一个语法形式。引用百科中对于lamda表达式的解释: “Lambda 表达式”(lambda expression)是一个匿名函数,Lambda表达式基于数学中的λ演算...
  • lamda表达式是一种函数式接口,可以使代码更加简洁。 何为函数式接口,若一个接口只包含唯一一个抽象方法,那么它就是一个函数式接口。 lamda表达式是何如来简化代码的呢?往下看。 举个栗子 1.首先是我们...
  • java lamda表达式

    2021-08-25 13:09:55
    1 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:20
    lamda表达式: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表达式
  • 2 lamda表达式组成: ()-> {} 参数列表 被引用 方法体 1)参数类型可以省略,如果要省略,就要把每个参数类型都要省略; 2)如果参数的小括号中只有一个参数,那么小括号可以省略 3)如果方法体中只有一句...
  • 1、Lambda表达式1.1、定义lambda表达式是对于函数式接口(只含有一个抽象方法的接口)的简洁实现方式。它与匿名内部类的作用相似,但是就使用范围而言,匿名内部类更为广泛,而lambda表达式则更为简洁。1.2、使用...
  • lamda表达式,也叫做闭包,lamda表达式允许把函数做为一个方法的参数 语法: (parameters) -> expression 或 (parameters) ->{ statements; } 可选类型声明:不需要声明参数类型,编译器可以统一识别参数值...
  • JAVA基础---Lamda表达式方法引用 什么是函数式接口: 函数式接口有且仅有一个抽象方法,可以有多个普通方法和静态方法。 Java中对函数式接口的编译约束定义了@FunctionalInterface注释;标注了@Functional...
  • lamda表达式以及推导

    2022-02-16 11:56:20
    接口只包含一个抽象方法,就是函数式接口 总结 lambda表达式只能由一行代码才能简化为一行代码,如果有多行,只能使用代码块包裹 前提是函数式接口 多个参数也可以去掉参数类型,要去掉就都去掉,必须加上() ...
  • Lamda表达式 学习视频:【狂神说Java】多线程详解 up主:遇见狂神说 ...任何接口,如果只含唯一一个抽象方法,那么它就是一个函数式接口 对于函数式接口,我们可以通过lamda表达式来创建接口的对象 ...
  • Lamda 表达式简介

    2018-12-06 18:20:29
     Lamda 表达式基于JDK1.8   1.0 认识一下Lamda 表达式的作用   2.0 掌握Lamda 表达式的基础语法    二、过程 Lamda 是一种基于函数的编程语言,对于这种类型的语言典型的代表就是Haskell。但是从...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,796
精华内容 1,518
关键字:

lamda表达式实现抽象方法