方法引用

方法引用

1. 通过new出类的对象来引用方法

例：

（1）传统方式实现字符串转大写

①定义一个print接口

package cn.itcast.day_16;

@FunctionalInterface
public interface Printable {

    //打印字符串
    void print(String s);
}

②定义一个字符串转换类

package cn.itcast.day_16;

public class MethodTest {
    public void printupper(String str){
        String s = str.toUpperCase();
        System.out.println(s);
    }
}

③主函数

package cn.itcast.day_16;

public class DemoPrintable {

    public static void printString(Printable printable){
        printable.print("hello");
    }

    public static void main(String[] args) {
        printString((String s)->{
            //创建methodTest对象
            MethodTest obj = new MethodTest();
            obj.printupper(s);
        });
    }
}

注意： 1.对象是存在的

　　　 2.成员方法也是存在的

　　　3.所以可以使用方法引用

（2）使用方法引用

package cn.itcast.day_16;

public class DemoPrintable {

    public static void printString(Printable printable){
        printable.print("hello");
    }

    public static void main(String[] args) {

        MethodTest obj = new MethodTest();
        //使用对象引用方法
        printString(obj::printupper);
    }
}

2. 通过类名引用静态方法

①该方法为静态方法

package cn.itcast.day_16;

public class MethodTest {
    public static void printupper(String str){
        String s = str.toUpperCase();
        System.out.println(s);
    }
}

②主函数

package cn.itcast.day_16;

public class DemoPrintable {

    public static void printString(Printable printable){
        printable.print("hello");
    }

    public static void main(String[] args) {

        //使用对象引用方法
        printString(MethodTest::printupper);
    }
}

3. 通过super引用成员方法

 ①定义一个父类

package cn.itcast.day_18;

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

②定义一个接口

package cn.itcast.day_18;

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

③定义一个字类

package cn.itcast.day_18;

public class Man extends Human{
    @Override
    public void sayHello() {
        System.out.println("hello,我是Man");
    }

    public void method(greetable greetable){
        greetable.greet();
    }

    public void show(){
        //因为有子夫类关系，所以存在一个关键字super代表父，直接使用super调用父类的成员方法
        method(()->{
            super.sayHello();
        });
        //使用super引用父类成员方法
        //super存在，父类方法也存在，使用super引用父类方法
        method(super::sayHello);
    }

④主函数

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

4.使用this引用本类中的方法

①定义一个接口

package cn.itcast.day_19;

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

②定义一个类

package cn.itcast.day_19;

import cn.itcast.day_18.Human;

public class Husband {
    public void buyHouse(){
        System.out.println("买房子");
    }

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

    public void beHappy(){
        //传统写法
        marry(()->{
            this.buyHouse();
        });

        //使用this引用本类中的方法
        marry(this::buyHouse);
    }
}

5. 使用new来引用类中的带参构造方法

①生成一个类Person

package cn.itcast.day_20;

public class Person {
    private String name;

    public String getName() {
        return name;
    }

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

    public Person() {
    }

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

②生成一个Person对象的函数式接口

package cn.itcast.day_20;

//创建person对象的函数式接口
public interface PersonBulider {
    Person BuliderPerson(String name);

}

③生成一个测试类

package cn.itcast.day_20;

public class Demo {
    //类的构造器
    public static void printName(String name,PersonBulider pb){
        Person person = pb.BuliderPerson(name);
        System.out.println(person.getName());
    }

    public static void main(String[] args) {
        //传统方法
        printName("aaa",(String name)->{
            return new Person(name);
        });

        /**
         * Person已知
         * Person类的带参构造方法已知
         * 就可以使用Person引用new来引用person的带参构造方法
         */
        printName("aa",Person::new);
    }
}

6. 使用new来引用数组构造方法

①定义一个创建数组的函数式接口

package cn.itcast.day_21;

//定义一个创建数组的函数式接口
@FunctionalInterface
public interface ArrayBuilder {
    int[] buildArray(int length);
}

②测试类

package cn.itcast.day_21;

public class test {
    public static int[] create(int length, ArrayBuilder ab){
        return ab.buildArray(length);
    }

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

        //使用方法引用
        int[] arr2 = create(10, int[]::new);
        System.out.println(arr2.length);
    }
}