Java8新特性（一）lambda表达式

记录学习java8新特性的第一篇

Lambda

lambda是用来简化接口的

使用要求，接口必须是函数式接口

1.函数式接口

package lambda.lambdaInterface;

/**
 * @ Author     ：fqg
 * @ Date       ：Created in 8:43 2020/7/30
 */
@FunctionalInterface
public interface NoneReturnMultipleParameter {
    void test(int a, int b);
}

接口的实现类有且只有一个必须执行的抽象方法，使用Java自带的@FunctionalInterface注解可以判断这个接口是否是函数式接口

lambda主要表示匿名函数，并不关心方法名，主要关心参数列表和方法体

下面是主要定义的几个接口

package lambda.lambdaInterface;

/**
 * @ Author     ：fqg
 * @ Date       ：Created in 8:41 2020/7/30
 */
@FunctionalInterface
public interface NoneReturnNoneParameter {
    void test();
}

package lambda.lambdaInterface;

/**
 * @ Author     ：fqg
 * @ Date       ：Created in 8:42 2020/7/30
 */
@FunctionalInterface
public interface NoneReturnSingleParameter {
    void test(int a);
}

package lambda.lambdaInterface;

/**
 * @ Author     ：fqg
 * @ Date       ：Created in 8:45 2020/7/30
 */
@FunctionalInterface
public interface SingleReturnMultipleParameter {
    int test(int a, int b);
}

package lambda.lambdaInterface;

/**
 * @ Author     ：fqg
 * @ Date       ：Created in 8:42 2020/7/30
 */
@FunctionalInterface
public interface SingleReturnNoneParameter {
    int test();
}

package lambda.lambdaInterface;

/**
 * @ Author     ：fqg
 * @ Date       ：Created in 8:44 2020/7/30
 */
@FunctionalInterface
public interface SingleReturnSingleParameter {
    int test(int a);
}

下面是语法及其精简过程

package lambda;

import lambda.lambdaInterface.*;

/**
 * @ Author     ：fqg
 * @ Date       ：Created in 8:39 2020/7/30
 */
public class BasicSyntax {
    public static void main(String[] args) {
        //1.测试无参数无返回值的函数
        NoneReturnNoneParameter lambda1 = ()->{
            System.out.println("这是一个无参数无返回值的函数方法");
        };
        lambda1.test();
        //2.测试无返回值单一参数的函数
        NoneReturnSingleParameter lambda2 = (a) ->{
            System.out.println("这是一个单一参数无返回值的函数方法 a = " + a);
        };
        lambda2.test(10);
        //3.测试无返回值多个参数的函数
        NoneReturnMultipleParameter lambda3 = (a, b)->{
            System.out.println("这是一个无返回值多个参数的函数方法 a = " + a + ", b = "+ b);
        };
        lambda3.test(10, 20);
        //4.复杂逻辑，在方法体中就会不太方便，所以使用静态方法引用
        //使用多个参数单一返回值来访问这个静态方法calculate
        SingleReturnMultipleParameter lambda4 = BasicSyntax::calculate;
        System.out.println(lambda4.test(10, 20));//10
        //非静态方法调用
        //实例对象
        SingleReturnMultipleParameter lambda = new BasicSyntax()::calculateNotStatic;
        System.out.println(lambda.test(10, 20));//10
        //语法精简
        //参数列表精简
        //单一参数可以省略小括号
        SingleReturnSingleParameter lambda5 = a ->{
            System.out.println("这是精简过后的单一参数单一返回值方法 a = " + a);
            return a;
        };
        System.out.println(lambda5.test(10));

        //方法体精简
        //方法体中只含有一个语句可以省略大括号,同时可以省略return
        SingleReturnMultipleParameter lambda6 = (a, b) -> a + b;//直接返回a + b

        //调用构造方法
        GetPersonWithNoneParameter lambda7 = Person::new;
        Person person1 = lambda7.getPerson();
        //传入单一参数来执行构造方法
        GetPersonWithSingleParameter lambda8 = Person::new;
        Person person2 = lambda8.getPerson("xiaohong");
        //传入多个参数来执行构造方法
        GetPersonWithMultipleParameter lambda9 = Person::new;
        Person person3 = lambda9.getPerson("xiaoming", 10);

        //当传入参数是一个类，同时整个方法体中主要就是调用类其中的一个方法
        GetStudent lambda10 = Student::getName;
        Student student = new Student();
        student.setName("xiaoming");
        System.out.println(lambda10.get(student));

    }
    public static int calculate(int a, int b){
        if(a < b){
            return b - a;
        }else if (a > b){
            return a - b;
        }else{
            return a + b;
        }
    }
    public  int calculateNotStatic(int a, int b){
        if(a < b){
            return b - a;
        }else if (a > b){
            return a - b;
        }else{
            return a + b;
        }
    }
    @FunctionalInterface
    public interface GetPersonWithNoneParameter{
       Person getPerson();
    }
    @FunctionalInterface
    public interface GetPersonWithSingleParameter{
        Person getPerson(String name);
    }
    @FunctionalInterface
    public interface GetPersonWithMultipleParameter{
        Person getPerson(String name, int age);
    }

    public interface GetStudent{
        String  get(Student student);
    }

    private static class Person{
        String name;
        int age;
        public Person(){
            System.out.println("无参数的构造方法以执行");
        }
        public Person(String name){
            System.out.println("单一参数的构造方法以执行 name = " + name );
        }
        public Person(String name, int age){
            System.out.println("多个参数的构造方法以执行 name = " + name + ", age = " + age );
        }
    }

    private static class Student{
        private String name;
        private int age;
        public void setName(String name){
            this.name = name;
        }
        public String getName(){
            return this.name;
        }
    }
}

run ending