乐趣区

关于java:玩转java8-Lambda表达式之实例方法引用

Lambda 表达式系列历史文章

玩转 Java8 lambda 表达式及自定义函数式接口入门
玩转 java8 Lambda 表达式一
玩转 java8 Lambda 表达式之静态方法援用


什么是办法援用?

Lambda 还有一个十分重要的性能,就是办法援用。办法援用能够了解为 lambda 表达式的简便写法。办法援用是用来间接拜访类或者实例的曾经存在的办法或构造方法(函数),它比 lambda 表达式更加的简洁,更高的可读性,更好的复用性。


办法援用的语法

类名(或实例):: 办法名


办法援用的分类


实例办法援用的定义

如果函数式接口的实现恰好能够通过一个实例的实例办法来实现,那么就能够应用实例办法援用。


实例办法援用的示例

废话少说,间接上干货,代码示例中都有重要正文


this 关键字办法援用

class Father5 {public void f1() {System.out.println("f1 method...");
    }
    public String f2() {
        /**
         * f2 办法调用 f1 办法,就能够应用 this 对象调用
         */
        Runnable r1 = this::f1;
        System.out.println("f2 method...");
        return "f2";
    }
}

super 关键字办法援用

class Father5 {public void f1() {System.out.println("f1 method...");
    }
    public String f2() {
        /**
         * f2 办法调用 f1 办法,就能够应用 this 对象调用
         */
        Runnable r1 = this::f1;
        System.out.println("f2 method...");
        return "f2";
    }
}

class Son extends Father5{
    @Override
    public void f1() {
        /**
         *super 关键字应用办法援用,调用父类 f1 办法
         */
        Runnable r1 = super::f1;
        System.out.println();}

    @Override
    public String f2() {return super.f2();
    }
}

无参数,无返回值

public class LambdaInstanceMethodTest {

    /**
     * 测试无参,无返回值
     */
    @Test
    public void test() {
        /**
         * 能够在 body 体间接 new Father 实例调用,如 r1
         * 也能够先创立实例对象 father, 再进行调用,如 r2
         */
        Runnable r1 = () -> new Father().f1();
        Father father = new Father();
        Runnable r2 = () -> father.f1();

        /**
         * 将 r2 改写为实例办法调用
         */
        Runnable r3 = father::f1;

        r1.run();
        r2.run();
        r3.run();

        /**
         * 也能够援用有返回值的办法,只有办法没有参数即可,如 f2 办法
         */
        Runnable r4 = father::f2;
        r4.run();}


}

class Father {public void f1() {System.out.println("f1 method...");
    }
    public String f2() {System.out.println("f2 method...");
        return "f2";
    }
}

无参数,有返回值

public class LambdaInstanceMethodTest2 {

    /**
     * 测试无参,有返回值
     */
    @Test
    public void test() {
        /**
         * java.util.function.Supplier java8 自带的函数式接口
         *
         * 能够在 body 体间接 new Father2 实例调用,如 s1
         * 也能够先创立实例对象 father2, 再进行调用,如 s2
         */
        Supplier<String> s1 = () -> new Father2().f2();
        Father2 father2 = new Father2();
        Supplier<String> s2 = () -> father2.f2();

        /**
         * 将 s2 改写为实例办法调用
         */
        Supplier<String> s3 = father2::f2;

        s1.get();
        s2.get();
        s3.get();}


}

class Father2 {public String f2() {System.out.println("f2 method...");
        return "f2";
    }
}

有参数,无返回值

public class LambdaInstanceMethodTest3 {

    /**
     * 测试有参,无返回值
     */
    @Test
    public void test() {
        /**
         * java.util.function.Consumer java8 自带的函数式接口
         *
         * 能够在 body 体间接 new Father3 实例调用,如 c1\c2
         * 也能够先创立实例对象 father3, 再进行调用,如 c3\c4
         */
        Consumer<String> c1 = str-> new Father3().f1(str);
        Consumer<String> c2 = str-> new Father3().f3(str);
        Father3 father3 = new Father3();
        Consumer<String> c3 = str-> father3.f1(str);
        Consumer<String> c4 = str-> father3.f3(str);

        /**
         * 将 c3/c4 改写为实例办法调用
         */
        Consumer<String> c5 = father3::f1;
        Consumer<String> c6 = father3::f3;

        c1.accept("lambda 1");
        c2.accept("lambda 2");
        c3.accept("lambda 3");
        c4.accept("lambda 4");
        c5.accept("lambda 5");
        c6.accept("lambda 6");

    }


}

class Father3 {public void f1(String s) {System.out.println("f1 method...");
    }

    public String f3(String s) {System.out.println("f3 method..."+s);
        return "f3";
    }
}

有参数,有返回值

public class LambdaInstanceMethodTest4 {

    /**
     * 测试有参数,有返回值
     */
    @Test
    public void test() {
        /**
         * java.util.function.Function\java.util.function.BiFunction java8 自带的函数式接口
         *
         * 能够在 body 体间接 new Father4 实例调用,如 f1\f2
         * 也能够先创立实例对象 father4, 再进行调用,如 f3\f4
         */
        Function<String, Integer> f1 = str -> new Father4().f3(str);
        BiFunction<String,String, Integer> f2 = (s1,s2) -> new Father4().f4(s1,s2);
        Father4 father4 = new Father4();
        Function<String, Integer> f3 = str -> father4.f3(str);
        BiFunction<String,String, Integer> f4 = (s1,s2) -> father4.f4(s1,s2);

        /**
         * 将 f3/f4 改写为实例办法调用
         */
        Function<String, Integer> f5 = father4::f3;
        BiFunction<String,String, Integer> f6 = father4::f4;

        System.out.println(f1.apply("lambda 1"));
        System.out.println(f2.apply("java","lambda 1"));
        System.out.println(f3.apply("lambda 2"));
        System.out.println(f4.apply("java", "lambda 2"));
        System.out.println(f5.apply("lambda 3"));
        System.out.println(f6.apply("java", "lambda 3"));

    }


}

class Father4 {public Integer f3(String s) {System.out.println("f3 method..." + s);
        return s.length();}

    public Integer f4(String s1, String s2) {System.out.println("f4 method...");
        return s1.length() + s2.length();
    }
}

本文分享了 Lambda 表达式的实例办法援用。如有不妥之处,欢送拍砖。
下一章将分享 Lambda 表达式的对象办法援用,请大家持续关注。

退出移动版