利用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表达式（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);
    }
}

理解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表达式

Lambda表达式可以理解为一种匿名函数：它没有名称，但有参数列表、函数主体、返回类型
函数式接口就是仅仅声明了一个抽象方法的接口
只有在接受函数式接口的地方才可以使用Lambda表达式
Lambda表达式允许你直接内联，为函数式接口的抽象方法提供实现，并且将整个表达式作为函数式接口的一个实例
优点

代码更加简洁
方便函数式编程
减少匿名内部类的创建，节省资源


缺点

代码可读性变差
不易于后期维护，必须熟悉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");
    }
}


学习视频