精华内容
下载资源
问答
  • 利用lamda表达式实现接口方法 更多干货见博主个人网站:https://blog.zhenglin.work 若想直接使用 接口中方法,在jdk8之前的做法有:1,编写一个类实现这个接口的(抽象方法;2,或者直接在创建对象时 采用匿名类...

    利用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)->{}这种形式。

    • 不适用地方,接口中有多个方法的。
    展开全文
  • 2.使用Lamda表达式实现接口里面只能有一个抽象方法,可以有普通方法和静态方法; 3.JDK8新增了一个注解 @FunctionalInterface 表示该接口用Lamda表达式实现 只能用于接口声明,检查当前接口是否只有一个抽象方法;...

    Lamda表达式(java中的函数式编程)

    注意点:

    1.实际上是对匿名内部类的优化:

    2.使用Lamda表达式实现接口里面只能有一个抽象方法,可以有普通方法和静态方法;

    3.JDK8新增了一个注解 @FunctionalInterface 表示该接口用Lamda表达式实现

    只能用于接口声明,检查当前接口是否只有一个抽象方法;

    匿名内部类:
    1.匿名内部类必须继承一个抽象类,或者实现一个接口;
    2.匿名内部类可以在方法中也可以在类中
    3.匿名内部类要是在方法中要使用方法的形参,方法形参必须被final修饰
    4.匿名内部类没有构造方法,因为没有类名;

    Lamda表达式语法:

    1.方法无返回值

    a.方法体实现只有一行:

    ()->具体实现代码;

    b.方法体有多行实现;

    ()->{

    ​ 多行代码的具体实现

    ​ };

    @FunctionalInterface //注解
    interface ISubject{
        void test();
    }
    public class Test {
        public static void main(String[] args) {
            ISubject subject=
                    new ISubject() {
                        //相当于 implements  ISubject
                        @Override
                        public void test() {
                            System.out.println("hehe");
                        }
                    };
                        subject.test();
                        ISubject subject1=()-> System.out.println("hehe");//方法体只有一行
                        ISubject subject2=()-> {//方法体有多行
                            System.out.println("hehe");
                            System.out.println("haha");
                        }
                        subject1.test();//调用subject1的test();
                        subject2.test();//调用subject2的test();
            
        }
    }
    

    2.方法有返回值

    ​ a.只有一行代码,省略return;

    ​ ISubject subject=(r1,r2)->r1+r2;

    @FunctionalInterface
    interface ISubject{
        int add(int r1,int r2);
    }
    public class Test{
        public static void main(String[] args) {
            ISubject subject=(r1,r2)->r1+r2;
            System.out.println(subject.add(10,20));
        }
    }
    

    ​ b.方法体有多行代码,此时return不能省略

    @FunctionalInterface
    interface ISubject{
        int add(int r1,int r2);
    }
    public class Test{
        public static void main(String[] args) {
            ISubject subject=(r1,r2)->{
                r1=r1+10;
                r2=r2+10;
                return r1+r2;
            };
            System.out.println(subject.add(10,20));
        }
    }
    

    ##方法引用:一般结合Lamda表达式使用

    1.首先JDK8之前,只可以引用数组,类,接口;(指向一个对象或者数组的堆内存地址)

    2.JDK8对方法进行引用(四种) 方法引用是引用的方法的具体实现

    ​ a.引用摸个类的静态方法 语法 类名::静态方法名

    interface ISubject1<P,R>{
        /*int add(int r1,int r2);*/
        R switchPara(P p);
    }
    public class Test {
        public static void main(String[] args) {
            //方法引用 静态方法
          ISubject1<Integer,String> stringISubject1=
                  String::valueOf;
            System.out.println(stringISubject1.switchPara(10)+10);
        }
    }
    

    ​ b.引用某个对象的普通方法 语法 对象::方法名

    interface ISubject1<R>{
        R switchPara();
    }
    public class Test {
        public static void main(String[] args) {
            ISubject1<String> subject="hello"::toLowerCase;
            System.out.println(subject.switchPara());
        }
    }
    

    ​ c.引用某个类的普通方法 语法 类名::方法名

    interface ISubject1<R,P>{
        R switchPara(P p1,P p2);
    }
    public class Test {
        public static void main(String[] args) {
            ISubject1<Integer,String> subject=String::compareTo;
            System.out.println(subject.switchPara("郭","方"));//相当于调用了compareTo();
        }
    }
    

    ​ d.引用某个类的构造方法;

    interface ISubject1<R,PI,PS>{
        R switchPara(PI name,PS age);
    }
    class Person{
        private String name;
        private Integer age;
    
        public Person(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
        public  String toString(){
            return "Person{"+"age="+age+",name="+name+'}';
        }
    }
    public class Test {
        public static void main(String[] args) {
            ISubject1<Person,String,Integer> subject1=Person::new;
            Person per1=subject1.switchPara("guo ",21);
            System.out.println(per1);
        }
    }
    
    展开全文
  • lamda表达式

    2021-04-16 11:32:23
    任何接口,如果只包含唯一一个抽象方法,那么他就是一个函数式接口 对于函数式接口,可以通过lamda表达式来创建该接口的对象 package lamda; /* 1.定义一个类 TestLambda 2.定义一个函数式接口 ILike 3.定义一个...

    理解Functional Interface(函数式接口是学习lamda表达式的关键所在)

    函数式接口:
    任何接口,如果只包含唯一一个抽象方法,那么他就是一个函数式接口
    对于函数式接口,可以通过lamda表达式来创建该接口的对象

    package lamda;
    /*
    1.定义一个类 TestLambda
    2.定义一个函数式接口 ILike
    3.定义一个实现类
    4.在TestLambda类中写main方法:接口new实现类对象调用方法
    5.优化:可以把实现类写在 TestLambda 中作为静态内部类  局部内部类  匿名内部类  lambda
    
    */
    
    public class TestLambda {
    
    //    静态内部类 3
        static class Like2 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like lambda----2");
            }
        }
    
    
    
        public static void main(String[] args) {
            ILike like = new Like();//接口new实现类
            like.lambda();
            like =new Like2();
            like.lambda();
    
    //        局部内部类 4
            class Like3 implements ILike{
                @Override
                public void lambda() {
                    System.out.println("I like lambda----3");
                }
            }
    
            like=new Like3();
            like.lambda();
    
    //        匿名内部类 没有类的名称  必须借助接口或者父类  5
            like=new ILike() {
                @Override
                public void lambda() {
                    System.out.println("I like lambda----4");
    
                }
            };
            like.lambda();
    
    //        用lambda简化   6
            like= ()-> {
                System.out.println("I like lambda----5");
            };
            like.lambda();
    
        }
    }
    
    interface ILike{
        void lambda();
    }
    
    //实现类  2
    class Like implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like lambda");
        }
    }
    
    
    
    
    展开全文
  • Lamda表达式

    2021-03-01 16:54:07
    Lamda表达式 Lambda表达式可以理解为一种匿名函数:它没有名称,但有参数列表、函数主体、返回类型 函数式接口就是仅仅声明了一个抽象方法的接口 只有在接受函数式接口的地方才可以使用Lambda表达式 Lambda表达式...

    Lamda表达式

    1. Lambda表达式可以理解为一种匿名函数:它没有名称,但有参数列表、函数主体、返回类型
    2. 函数式接口就是仅仅声明了一个抽象方法的接口
    3. 只有在接受函数式接口的地方才可以使用Lambda表达式
    4. Lambda表达式允许你直接内联,为函数式接口的抽象方法提供实现,并且将整个表达式作为函数式接口的一个实例
    5. 优点
      • 代码更加简洁
      • 方便函数式编程
      • 减少匿名内部类的创建,节省资源
    6. 缺点
      • 代码可读性变差
      • 不易于后期维护,必须熟悉lambda表达式和抽象函数中参数的类型
    /*
    推导lambda表达式
     */
    public class TestLambadal {
        //3.静态内部类
        static class Like2 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like lambda1");
            }
        }
    
        public static void main(String[] args) {
            ILike like = new Like();
            like.lambda();
    
            like = new Like2();
            like.lambda();
    
            //4.局部内部类
            class Like3 implements ILike{
                @Override
                public void lambda() {
                    System.out.println("I like lambda3");
                }
            }
            like = new Like3();
            like.lambda();
    
            //5.匿名内部类,没有类的名称,必须借助接口或者父类
            like = new ILike() {
                @Override
                public void lambda() {
                    System.out.println("I like lambda4");
                }
            };
            like.lambda();
    
            //6.用lambda简化
            like = ()->{
                System.out.println("I like lambda6");
            };
            like.lambda();
            
            like = ()-> System.out.println("I like lambda6");
            like.lambda();
            //lambda表达式只能有一行代码的情况下才能简化为一行,如果有多行,那么就用代码包裹。
            //前提是接口为函数式接口
            //多个参数也可以去掉参数类型,要去掉就都去掉,必须加上括号
        }
    }
    
    //1.定义一个函数式接口
    interface ILike{
        void lambda();
    }
    //2.实现类
    class Like implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like lambda");
        }
    }
    
    

    学习视频

    展开全文
  • java Lamda表达式

    千次阅读 2018-10-18 19:21:52
    匿名内部类: 必须基于抽象类或接口,主要目的是减少...要使用lamda表示式必须将方法定义在一个接口之中,为了区分接口的lamda表达式,一般使用@FunctionalInterface 来注释,且接口中必须只有一个未实现方法。...
  • Lamda表达式基本实现:package cn.demo; @FunctionalInterface//函数式编程注解,只接口允许有一个普通的抽象方法,但可以有 默认方法静态方法 interface IMessage0{ String msg="xx"; public static ...
  • java的lamda表达式

    2019-09-25 06:50:20
    Java8才支持lamda表达式 lamda是一中函数式编程语言 通过实现模式是匿名内部类 java使用内部类实现接口 首先定义一个接口 @FunctionalInterfaceinterface Foo{ //定义一个抽象方法 void fun();} public class ...
  • java1.8 lamda表达式

    2019-08-22 10:06:47
    直接使用lamda表达式编写接口的实现 参数为接口抽象方法的入参 后面接着方法的实现 然后就可以作为该接口的对象使用了 2、lamada表达式语法 (parameters) -> statement;或(parameters) -> {statements;} ...
  • java8新特性——Lamda表达式

    千次阅读 2019-05-28 11:36:51
    以上的匿名类为了完成一个输出,结果写了一堆代码,为了解决此类问题,所以在Java8开始引入了Lamda的特征,利用这个Lamda表达式可以实现更为简单的匿名内部类的使用。 这就是函数式编程的语法形式,而以上的操作...
  • lamda表达式的前提是一个接口中只有一个抽象方法 public class Lamda { public static void main(String[] args) { Like like=new Ilike(); like.like(520); } } interface Like{ void like(int a); } //1...
  • 一句话:代替匿名内部类,使代码变的更加简洁,被匿名内部类实现的接口中有且仅有一个抽象方法 2.Lamda表达式的基本语法 ->左边是参数,右边是表达式 (parameters) -> expression 或 (parameters) ->{ ...
  • Lambda是JAVA 8添加的新特性,作用是当接口里只有一个抽象方法时,可以通过Lamda在没有实现类的情况下为接口对象赋值,具体如下 public interface InterfaceTest { void test(); //这个接口里只有一个方法 } ...
  • Lamda表达式作用: * 避免匿名内部类定义过多 * 可以让代码看起来更简洁 * 去掉了一些没有意义的代码,只留下核心的逻辑 创建函数式接口ILike 以及实例化 函数式接口定义:任何接口,只包含一个抽象方法,那么就是一...
  • Lambda表达式

    2021-04-24 16:45:38
    对于任何接口,如果这个接口中只含有唯一的一个抽象方法,那么,这个接口就是函数式接口。 比如说Runnable接口,我们来看Runnable接口的实现代码。 @FunctionalInterface public interface Runnable .
  • lambda表达式

    2021-01-19 10:11:13
    任何接口,如果只包含唯一一个抽象方法,那么他就是一个函数式接口 对于函数式接口 我们可以通过lamda表达式来创建该接口的对象 以往我们实现函数式接口的方法 ////1.实现类 //class Legend implements ILegend { //...
  • Lambda表达式演变过程

    2020-07-28 21:54:48
    使用lamda表达式前提:是函数式接口 函数式接口:任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口。 对于函数式接口,我们可以通过lambda表达式来创建该接口的对象。 无参数时 使用普通类来...
  • 使用Lamda表达式可以对一个接口进行十分简单的实现。Lambda对接口的要求:Lambda要求接口中定义的必须实现抽象方法只能是一个。@FunctionInterface用来修饰函数式接口,接口中的抽象方法只能有一个。Lambda基础...
  • Java基础-Lambda表达式

    2020-02-09 13:47:05
    函数式接口(Functional Interface)是Java8 Lamda表达式的关键。 函数式接口的定义: 任何接口,如果只含有唯一一个抽象方法,它就是一个函数式接口。 对于函数式接口,我们可以通过lambda表达式来简化创建它的...
  • lamda表达式只能有一行代码的情况下才能简化称为简化3,如果有多行就用花括号 接口必须为函数式接口,即接口中只能有一个抽象方法 多个参数也可以去掉参数类型,但要加括号 public class TestLambda02 { public ...
  • Java---lambda表达式

    2016-08-23 23:12:58
    JDK1.8开始将匿名内部类的实现转为了函数式实现,引入了Lamda表达式。 函数式编程的最严格要求:每一个接口里面只允许有一个抽象方法。 为了保证所定义的接口一定是函数式编程所使用的接口,那么一般在定义函数...
  • 函数式接口:任何一个接口,只包含一个抽象方法,就是函数式接口 演进:接口的实现类,静态内部类,局部内部类,匿名内部类,lambda 1.lambda表达式只能有一行代码的情况下才能简化成一行,多行需要有代码块 ...
  • Java中的闭包

    万次阅读 热门讨论 2021-01-07 17:29:12
    lamda表达式实现了唯一的抽象方法,也就是实现了函数式接口。 如果函数式接口有多个抽象方法定义,就无法用lamada表达式实现多个方法,如下: 函数式接口(functional interface 也叫功能性接口,其实是同一个...
  • java8的很多特性是java虚拟机层面实现的,比如lamda表达式,而不是编译器是实现。但是java8新增的default修饰符,其实就是在接口定义的非抽象的public的修饰符。我们看下API: Modifier.toString(int mod)输出不了...
  • 2021-04-06

    2021-04-06 21:32:59
    只包含一个抽象方法的接口:函数式接口 对于函数式接口,lamda表达式可以创建该接口的对象! 使用方法 接口定义 interface Ilove{ void love(int a); } //实现类 class love implement Ilove{ @override public ...
  • 函数式编程

    2021-02-11 14:48:12
    lamda表达式实现要求:SAM(Single Abstract Method)。只有一个抽象方法的接口被称为函数式接口,我们称它为函数式接口,只有函数式接口才可以被lamda使用。 public class Demo{ public static void main(String ...
  • 支持“默认方法”(Default Method),即可以在接口上声明和实现方法,这一点有点类似于抽象类、抽象方法,可以简化类的多个接口扩展的复杂度,潜在淡化JAVA有关多继承的缺陷,此外默认方法在lamda表达式使用方面非常...
  • JAVA8新特性学习笔记

    千次阅读 2015-12-31 17:38:33
    一、Lamda表达式 在JAVA8新特性中主要一点就是支持了Lamda表达式,这为我们开发带来了一些便利。 传统中我们实现匿名内部类是这样的: ...// 里面只有一个抽象方法 } public class TestDemo { public static void
  • JDK8

    2019-11-20 16:23:33
    使用default关键字向接口添加非抽象方法实现。 主要是强调一种代码的复用,实现类可以直接调用接口中的非抽象方法lamda表达式 对于函数体只有一行代码的,你可以去掉大括号{}以及return关键字 这里有个小细节...

空空如也

空空如也

1 2 3
收藏数 44
精华内容 17
关键字:

lamda表达式实现抽象方法