（三）Java 8 - 函数编程Lambda方法引用的三种形式

1. 对象 :: 非静态方法

2. 类 :: 静态方法

3. 类 :: 非静态方法

• 注意：方法引用规定：
• 1.对象不能调用静态方法
• 2.类可以调用非静态方法
• 3.这和JAVA中的一致

1.类引用静态方法

语法格式： 类名称::static方法名称

第一步，我们自定义一个接口，该接口中只有一个抽象方法，是一个函数式接口（前面也有讲过这个是必须的）。

     /**
     * 创建一个StudentMsg接口
     * 自定义一个接口，该接口中只有一个抽象方法，是一个函数式接口  
     */
    @FunctionalInterface
    interface StudentMsg {

        public String getAge(Integer age);

    }

第二步，新建一个类，创建一个方法。这里要注意，创建的静态方法返回值类型和形参列表必须和函数式接口中的抽象方法相同。（必须一致）

  public class Student {

    /**
     * 创建的方法返回值类型和形参列表必须和函数式接口中的抽象方法相同
     * @param age
     * @return
     */
    public static String getAge(Integer age){
        return "年龄为："+age;
    }

}

第三步，创建函数式接口的实现类，可以使用方法引用。相当于实现类里的重写的方法，就是方法引用的方法。这样才能方法引用。

    public static void main(String[] args) {

        StudentMsg studentMsg = Student::getAge;
        System.out.println(studentMsg.getAge(18));

    }

2.对象引用非静态方法

语法格式： 实例化对象::普通方法；

第一步，我们自定义一个接口，该接口中只有一个抽象方法，是一个函数式接口（前面也有讲过这个是必须的）。

    /**
     * 创建一个StudentMsg接口
     */
    @FunctionalInterface
    interface StudentMsg {
        public Integer getAge();
    }

 第二步，新建一个类，创建一个非静态方法。这里要注意，创建的方法返回值类型和形参列表必须和函数式接口中的抽象方法相同。（必须一致）

public class Student {

    private Integer age = 10;

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

第三步，语法格式： 实例化对象::普通方法；

public static void main(String[] args) {

        /**
         * 语法格式： 实例化对象::普通方法；
         */
        Student student = new Student();
        StudentMsg studentMsg = student::getAge;

        //调用的时候直接对象调用方法就可以了
        System.out.println(studentMsg.getAge());

    }

3.类引用普通方法

语法格式： 类::普通方法;

当抽象方法中有两个参数，且第一个参数是调用者，第二个参数是形参。

则可以使用【类::实例方法】

建立接口抽象方法中有两个参数，且第一个参数是调用者，第二个参数是形参

    /**
     * 当抽象方法中有两个参数，且第一个参数是调用者，第二个参数是形参，则可以使用类::实例方法。
     * 第二个参数开始就是参数了，多个就写多个
     */
    @FunctionalInterface
    interface StudentMsg {
        public Integer getAge(Student student,Integer age);
    }

建立一个Student类，这个方法的参数，就是接口中第二个以后的所有参数

public class Student {

    /**
     * 这个方法的参数，就是接口中第二个的参数
     * 多个就写多个
     * @return
     */
    public Integer getAge(Integer age) {
        return age;
    }

}

可以使用【类::实例方法。】 

 public static void main(String[] args) {

        /**
         * 语法格式： 实例化对象::普通方法；
         */
        Student student = new Student();

        StudentMsg studentMsg = Student::getAge;

        //调用的时候直接对象调用方法就可以了
        System.out.println(studentMsg.getAge(student,12));

    }

是不是有点不适应，自己写一下体会一下，其实就是一个对象调用而已，虽然花里胡哨的

4.构造引用

语法格式： 类名称::new

接口的参数其实就是类的构造方法参数

     /**
     * 接口的参数其实就是类的构造方法参数
     *
     */
    @FunctionalInterface
    interface StudentMsg {
        // 返回值就是实现类
        public Student getAge(String name);
    }

 接口的参数其实就是类的构造方法参数

public class Student {

    private String name;

    public Student(String name) {
        this.name = name;
    }
}

语法格式： 类名称::new 

 public static void main(String[] args) {

        StudentMsg studentMsg = Student::new;

        //调用的时候直接对象调用方法就可以了
        System.out.println(studentMsg.getAge("小明"));

    }