初识Lambda表达式1----java

写在前面的话

 　 　终于还是换了新的工作，比起原来每天早上8:00上班晚上12点多才回宿舍的日子，现在真的幸福的不止一点半点。但真正让我最开心的是公司里有很多的大牛，也用了很多的新技术，而现在我也有相对比较充足的时间去给自己充电，希望自己能够通过不懈的努力更快的成为一个大牛。

首先我想啃的是lambda表达式。

首先看如下代码：

package com.nrsc.lambda;
interface Interface1 {
    int calculate(int i);
}
class Test implements Interface1 {
    @Override
    public int calculate(int i) {
        System.out.println("-----继承----");
        return i * 2 + 4;
    }
}
public class LambdaDemo1 {
    public static void main(String[] args) {
        Interface1 test = new Test();
        int value = test.calculate(3);
        System.out.println(value);
    }
}

 　 运行结果如下：

 　 上面的代码很简单，就是有一个类Test继承了一个接口Interface1 并实现了Interface1内的calculate方法，然后在LambdaDemo1 类中new一个Test类就可以完成对该方法的调用。

再看一下lambda表达式与上面方式的对比

package com.nrsc.lambda;

interface Interface1 {
    int calculate(int i);
}
class Test implements Interface1 {
    @Override
    public int calculate(int i) {
        System.out.println("-----继承----");
        return i * 2 + 4;
    }
}
public class LambdaDemo1 {
    public static void main(String[] args) {
        Interface1 test = new Test();
        int value = test.calculate(3);
        System.out.println(value);
        System.out.println("=========割========");
        
        /**
         * Lambda表达式
         */
        Interface1 i1 = (i) -> i * 1;

        //与继承的方式进行对比可以知道lambda表达式中
        //      "->"左边是接口中方法需要输入的参数,
        //      "->"右边是继承了该接口的类对接口中定义方法的一个具体实现
        //      而"="号右边所有的内容加起来就是构建了一个实现了Interface1接口的实例(多态)

        int i1Value = i1.calculate(3);  //返回值类型就是接口内方法的返回值类型
        System.out.println(i1Value);
    }
}

lambda表达式还有如下几种书写方式

package com.nrsc.lambda;
//@FunctionalInterface为一个编译注解--标志本接口为函数式接口,不写也不会报错
//但建议能加的时候还是加上
//这里有一个注意点，假如加上了该注解，那么这个接口就必须有一个未实现的方法
//否则会报编译错误 No target method found
@FunctionalInterface
interface Interface1 {
    int calculate(int i);
    // int add(int i, int j); //@FunctionalInterface会报编译错误,因为被此注解标注的接口,只能有一个未实现的方法
}
class Test implements Interface1 {
    @Override
    public int calculate(int i) {
        System.out.println("-----继承----");
        return i * 2 + 4;
    }
}
public class LambdaDemo1 {
    public static void main(String[] args) {
        Interface1 test = new Test();
        int value = test.calculate(3);
        System.out.println(value);
        System.out.println("=========割========");

        //与继承的方式进行对比可以知道lambda表达式中
        //      "->"左边是接口中方法需要输入的参数,
        //      "->"右边是继承了该接口的类对接口中定义方法的一个具体实现
        //      而"="号右边所有的内容加起来就是构建了一个实现了Interface1接口的实例(多态)
        /**
         * Lambda表达式常见写法如下
         */
        Interface1 i1 = (i) -> i * 1;

        Interface1 i2 = i -> i * 2 + 1;  //比较简单且常见的写法

        Interface1 i3 = (int i) -> i * 3 + 2;
        //前三种方式默认有一个return，下面这种方式可以显示写出要return的内容
        //并且还可以有一些中间操作，如下面的输出语句
        Interface1 i4 = i -> {
            System.out.println("---------");
            return i * 4 + 3;
        };

        int i1Value = i1.calculate(3);  //返回值就是接口内方法的返回值
        System.out.println(i1Value);
        System.out.println(i2.calculate(2));
        System.out.println(i3.calculate(2));
        System.out.println(i4.calculate(2));
    }
}

注意

 　 Interface1接口上的注解@FunctionalInterface，它放在某个接口上的话，该接口只能有一个未实现的方法（java官方鼓励一个接口只干一件事），但是还可以有一些默认实现的方法，如下：

package com.nrsc.lambda;

//@FunctionalInterface为一个编译注解--标志本接口为函数式接口,不写也不会报错
//但建议能加的时候还是加上
@FunctionalInterface
interface Interface2 {
    int calculate(int i);

    // int add(int i, int j); //@FunctionalInterface会报编译错误,因为被此注解标注的接口,只能有一个未实现的方法

    //但是函数式接口可以有一个或多个默认实现的方法,如下:
    default int plus(int x, int y) {
        System.out.println("默认方法加");
        return x + y;
    }

    default int minus(int x, int y) {
        System.out.println("默认方法减");
        return x - y;
    }
}

public class LambdaDemo2 {

    public static void main(String[] args) {
        Interface2 i1 = i -> i * 3;

        System.out.println(i1.minus(5, 4));
        System.out.println(i1.plus(5, 4));
        System.out.println(i1.calculate(5));
    }
}

 　 还有一个知识点需要补充一下，当两个函数式接口都默认实现了某个方法时（如plus），如果第三个接口想继承这两个接口时,必须得指定要继承哪个接口的默认实现方法,当然它也可以重新实现这个默认方法.

package com.nrsc.lambda;

//@FunctionalInterface为一个编译注解--标志本接口为函数式接口,不写也不会报错
//但建议能加的时候还是加上
@FunctionalInterface
interface Interface11 {
    int calculate(int i);

    //但是函数式接口可以有一个或多个默认实现的方法,如下:
    default int plus(int x, int y) {
        System.out.println("默认方法加");
        return x + y;
    }
}

@FunctionalInterface
interface Interface12 {
    int calculate(int i);

    //但是函数式接口可以有一个或多个默认实现的方法,如下:
    default int plus(int x, int y) {
        System.out.println("默认方法加");
        return x + y;
    }
}

@FunctionalInterface
interface Interface13 extends Interface11, Interface12 {
    //int minus (int i); //---- 如果加上这句话肯定也会报错，因为FunctionalInterface标注的类只能有一个未实现的方法
    //---- 而且假如Interface11和Interface12中未实现的方法（calculate）不是一个，肯定也会报错

    //如果继承的两个接口里有相同的默认方法的话,必须得选择继承哪一个的
    @Override
    default int plus(int x, int y) {
        return Interface11.super.plus(x, y);
    }

    //下面这种方式也可以
/*    @Override
    default int plus(int x, int y) {
        return x + y;
    }*/
}

public class LambdaDemo3 {

    public static void main(String[] args) {
        Interface13 i1 = i -> i * 3;
        System.out.println(i1.plus(5, 4));
        System.out.println(i1.calculate(5));
    }
}