JAVA方法引用

方法引用

/*
    定义一个打印的函数式接口
 */
@FunctionalInterface
public interface Printable {
    //打印字符串的抽象方法
    void print(String s);
}

public class Demo01Printable {
    //定义 方法 参数传入Printable接口，对字符串进行打印
    public static void printString(Printable p){
        p.print("HelloWorld");
    }

    public static void main(String[] args) {
        //调用print String方法
        printString(s-> System.out.println(s));

        /*
            分析：
                Lambda表达式的目的，打印参数传递的字符串
                把参数S传递给了System.out对象，调用out对象的方法println对字符串进行了输出
                注意：
                    1.System.out对象是已经存在的
                    2.println方法也是已经存在的
                所以我们可以使用方法引用来，优化Lambda表达式
                可以使用System.out方法直接引用（调用）println方法
         */

        printString(System.out::println);
    }
}

通过对象名来引用成员方法

/*
    定义一个打印的函数式接口
 */
@FunctionalInterface
public interface Printable {
    //打印字符串的抽象方法
    void print(String s);
}

public class MethodRerObject {
    //定义方法 传递字符串，把字符串大写输出
    public void printUpperCaseString(String str){
        System.out.println(str.toUpperCase());
    }
}

/*
    通过对象名引用成员方法
 */
public class Demo01ObjectMethodReference {
    //定义方法 参数传递Printable接口
    public static void printString(Printable p){
        p.print("hello");
    }

    public static void main(String[] args) {
        printString((s)->{
            //创建MethodRerObject对象
            MethodRerObject obj=new MethodRerObject();
            //调用对象中的方法printUpperCaseString，把字符串按照大写输出
            obj.printUpperCaseString(s);

        });

        /*
            使用方法引用来优化Lambda
            对象已经存在 MethodRerObject
            成员方法也存在 printUpperCaseString
            所以可以使用对象名来引用成员方法
         */
        MethodRerObject obj=new MethodRerObject();
        printString(obj::printUpperCaseString);
    }
}

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

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

/*
    通过类名引用静态成员方法
    类存在 静态成员方法存在
    就可以通过类名直接引用静态成员方法
 */
public class Demo01StaticMethodReference {
    //定义一个方法，方法的参数传递要计算绝对值的整数，和函数式接口Calcable
    public static int method(int num,Calcable c){
        return c.calsAbs(num);
    }

    public static void main(String[] args) {
        int num=method(-5,(n)->{
            //对参数计算绝对值
            return Math.abs(n);
        });
        System.out.println(num);

        /*
            使用方法引用优化
            Math类存在
            abs静态方法存在
            所以可以直接通过类名引用静态方法
         */

        int num2 = method(-5, Math::abs);
        System.out.println(num2);


    }
}

通过super引用父类的成员方法

/*
    定义见面的函数式接口
 */
@FunctionalInterface
public interface Greetable {
    //定义一个见面的方法
    void greet();
}

/*
    定义父类
 */
public class Human {
    //定义sayHello方法
    public void sayHello(){
        System.out.println("hello 我是Human");
    }
}

/*
    定义子类
 */
public class Man extends Human {
    //子类重写父类sayHello方法

    @Override
    public void sayHello() {
        System.out.println("Hello 我是Man!");
    }

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

    public void show(){
        //调用method方法
        /*method(()->{
            //创建父类
            Human h=new Human();
            //调用父类的sayHello方法
            h.sayHello();
        });*/



        //因为有子父类关系  所以存在关键字super代表父类 所以可以直接使用super调用父类的成员方法
        method(()->{
            super.sayHello();
        });

        /*
            使用super引用父类的成员方法
            super已经存在的
            父类的方法sayHello方法也是已经存在的
            所以可以直接使用super引用父类的成员方法
         */
        method(super::sayHello);

    }

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

this引用本类的成员方法

@FunctionalInterface
public interface Richable {
    void buy();
}

/*
    通过this用用本类的成员方法
 */
public class Husband {
    public void buyHouse(){
        System.out.println("北京二环内买一套四合院");
    }

    public void marry(Richable r){
        r.buy();
    }

    public void soHappy(){
        /*marry(()->{
            this.buyHouse();
        });
*/
        /*
            用方法引用
            this已经存在
            本类的成员方法buyHouse也存在
            可以直接使用this引用本类的成员方法 buyHouse
         */

        marry(this::buyHouse);
    }

    public static void main(String[] args) {
        new Husband().soHappy();
    }
}

类的构造器引用

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对象的函数式接口
 */
@FunctionalInterface
public interface PersonBuilder {
    //根据传的姓名创建Person
    Person builderPerson(String name);
}

/*
    类的构造器引用
 */
public class Demo {
    //方法 参数传递姓名和PersonBuilder接口 方法中通过姓名创建对象
    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("迪丽热巴",(name)->{
            return new Person(name);
        });*/

        /*
            使用方法引用
            构造方法new Person(String name) 已知
            创建对象已知 new
            就可以使用Person引用new创建对象
         */
        printName("虎虎",Person::new);
    }

}

数组的构造器引用

/*
    创建数组的函数式接口
 */
@FunctionalInterface
public interface ArrayBuilder {
    //创建int类型数组的方法
    int[] builderArray(int length);
}

import java.util.Arrays;

/*
    数组的构造器引用
 */
public class Demo01 {
    /*
        定义方法
        参数传创建数组的长度和ArrayBuilder接口
        方法内部根据传递的长度使用ArrayBuilder中的方法创建数组并返回
     */
    public static int[] createArray(int length,ArrayBuilder ab){
        return ab.builderArray(length);
    }

    public static void main(String[] args) {
        int[] arr1=createArray(10,(len)->{
            return new int[len];
        });
        System.out.println(arr1.length);

        /*
            方法引用
            已知创建的int[]数组
            长度已知
            可以使用方法引用
            int[] 引用new，根据参数传递的长度来创建数组
         */
        int[] arr2=createArray(10,int[]::new);
        System.out.println(Arrays.toString(arr2));

        System.out.println(arr2.length);
    }
}