方法引用

通过对象名引用成员方法

使用前提是对象名是已经存在的，成员方法也是已经存在的，就可以使用对象名来引用成员方法。

代码演示

//创建一个成员方法
package day17;

public class MethodRerObject {
    //定义一个成员方法，吧字符串大写输出
    public void printUpperCseString(String str){
        System.out.println(str.toUpperCase());
    }
}

package day17;

public class Demo02 {
    //定义一个方法，方法的参数产地printable接口
    public static void printString(Printable p){
        p.print("hello");
    }

    public static void main(String[] args) {
        //调用PrintString方法，方法的参数Printable是一个函数式接口，所以可以传递lambda表达式。
        printString((s)->{
            //创建MethodRerObject对象
            MethodRerObject obj = new MethodRerObject();
            //调用该对象中的方法把字符串大写输出
            obj.printUpperCseString(s);
        });
    }
}

使用方法引用有话lambda表达式。

对象是已经存在的methodrerObject

成员方法也是已经存在的printUpperCseString

所以可以使用对象名引用成员方法。

package day17;

public class Demo02 {
    //定义一个方法，方法的参数产地printable接口
    public static void printString(Printable p){
        p.print("hello");
    }

    public static void main(String[] args) {
        //创建MethodRerObject对象
        MethodRerObject obj = new MethodRerObject();
        printString(obj::printUpperCseString);
    }
}

通过类名引用静态成员方法

类已经存在，静态成员方法也已经存在

就可以通过类名直接引用静态成员方法

代码演示

定义一个静态方法
package day18;

@FunctionalInterface
public interface Calcable {
    //定义一个抽象方法，传递一个整数，对整数进行绝对值计算并返回
    int calsAbs(int number);
}

使用常规方法完成目的
package day18;

public class Demo01 {
    public  static int method(int number, Calcable c) {
        return c.calsAbs(number);
    }

    public static void main(String[] args){
        int number = method(-10,(n)->{
            return Math.abs(n);
        });
        System.out.println(number);
    }
}

使用方法引用优化Lambda表达式

Math类是存在的

abs计算绝对值的静态方法也是已经存在的

所以我们可以直接通过类名引用静态方法

package day18;

public class Demo01 {
    public  static int method(int number, Calcable c) {
        return c.calsAbs(number);
    }

    public static void main(String[] args){
        int number = method(-10,Math::abs);
        System.out.println(number);
    }
}

通过super引用父类成员方法

定义一个接口
package day18;

@FunctionalInterface
public interface Greetable {
    //定义一个见面的方法
    void greet();
}

定义一个父类
package day18;

/*
定义父类
 */

public class Human {
    //定义一个sayHello的方法
    public void sayHello(){
        System.out.println("Hello 我是human");
    }
}

定义一个子类，使用普通方法调用父类方法
package day18;

/*
定义子类
 */

import java.lang.management.ManagementFactory;

public class man extends Human{
    //子类重写父类sayHello的方法
    @Override
    public void sayHello(){
        System.out.println("hello");
    }

    //定义一个方法参数传递Greetable接口
    public void method(Greetable g){
        g.greet();
    }

    public void show(){
        method(()->{
            Human h = new Human();
            h.sayHello();
        });
    }

    public static void main(String[] args) {
        new man().show();
    }
}

使用super引用类的成员方法

super是已经存在的

父类的成员方法sayHello也是已经存在的

所以我们可以直接使用super引用父类的成员方法

package day18;

/*
定义子类
 */

import java.lang.management.ManagementFactory;

public class man extends Human{
    //子类重写父类sayHello的方法
    @Override
    public void sayHello(){
        System.out.println("hello");
    }

    //定义一个方法参数传递Greetable接口
    public void method(Greetable g){
        g.greet();
    }

    public void show(){
        method(super::sayHello);
    }

    public static void main(String[] args) {
        new man().show();
    }
}

使用方法引用调用类构造器

定义一个person类
package day18;

public class Person {
    private String name;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

定义一个创建person对象的接口
package day18;

/*
定义一个创建Person对象的函数式接口
 */

@FunctionalInterface
public interface PersonBuilder {
    //定义一个方法，根据传递的姓名，创建Person对象返回
    Person builderPerson(String name);
}

使用lambda表达式创建对象
package day18;

/*
类的构造器引用
 */

public class Demo02 {
    //定义一个方法，参数传递姓名和personBuilder接口，方法中通过姓名创建Persion对象
    public static void printName(String name,PersonBuilder pb){
        Person person = pb.builderPerson(name);
        System.out.println(person.getName());
    }

    public static void main(String[] args) {
        //调用printName方法，方法的参数PersonBuilder接口是一个函数式接口，可以传递lambda
        printName("迪丽热巴",(String name)->{
           return new Person(name);
        });
    }
}

使用方法引用优化lambda表达式

构造方法new Person(String name)已知

创建对象已知 new

就可以使用person引用new创建对象

使用方法引用调用类的构造器
package day18;

/*
类的构造器引用
 */

public class Demo02 {
    //定义一个方法，参数传递姓名和personBuilder接口，方法中通过姓名创建Persion对象
    public static void printName(String name,PersonBuilder pb){
        Person person = pb.builderPerson(name);
        System.out.println(person.getName());
    }

    public static void main(String[] args) {
        printName("古力娜扎",Person::new);
    }
}