方法引用以及函数式接口

什么是函数式接口

            一个接口里面只有一个抽象方法，那么这个接口就称为函数式接口

        

           @FunctionalInterface注解概述

                    这个注解是jdk1.8的新特性，用在接口上面，说明这个接口是一个函数式接口，只能有一个抽象方法，如果有多个抽象方法就编译不通过

     

            常用函数式接口

                     Runnable   Callable   Comparator    FileFilter   Consumer    Function   Predicate

 方法引用

               什么是方法引用

                        方法引用是jdk1.8的新特性，是用来简化lambda表达式的

                使用方法引用的前提

                        必须要有函数式接口，必须要使用到lambda表达式，的前提下才可以考虑可不可以使用方法引用

               方法引用的好处

                        简化了lambda表达式，重复使用已经存在的方法

                方法引用类型

                          静态方法引用    格式    类名 ::  静态方法名

                          对象方法引用     格式   对象名 ::非静态方法名

                          构造方法引用    格式    类名 :: new

                          特定类型的实列方法引用    格式    类名 :: 非静态方法名

                 

                     使用方法引用注意：必须要使用到lambda表达式，并且只有当lambda表达式里面只有一条语句，的前提下才可以考虑能不能使用方法引用；

                     如果函数式接口里面的抽象方法，没有返回值，被引用的方法可以没有返回值，也可以有返回值

                     如果函数式接口的抽象方法，有返回值，那么被引用的方法也一定要有返回值，并且返回值类型要是他的子类或者和抽象方法的类型一样

   静态方法引用使用介绍       

1.  

2. public class Dome05 {

3. public static void main(String[] args){

4. //abs方法是Math类的一个静态方法用于获取一个数的绝对值

5. //因为Test为一个函数式接口，并且他的抽象方法里面需要一个int类型的参数，并且也返回一个int类型的参数

6. //而且这个接口里面的方法是为了求一个数的绝对值，而Math类正好有一个abs的静态方法，这个方法的功能数获取一个数的绝对值

7. //他需要的参数和他的返回值正好和Test接口的fun方法一样，所以就可以使用静态方法引用

8. test(Math::abs,-5);

9. }

10.  

11. // test方法第一个参数为Test接口的实现类 ，第二个参数为一个数字求他的绝对值

12. public static void test(Test t,int i){

13. System.out.println(t.fun(i));

14. }

15. }

16.  

17. //创建一个函数式接口

18. @FunctionalInterface

19. interface Test{

20. //里面只有一个fun方法 ，里面需要一个int类型的参数，要获得这个参数的绝对值

21. public abstract int fun(int i);

22.  

23. }

             静态方法引用的参数要和函数式接口里面的参数类型和参数个数要一样

     

 非静态方法引用介绍        

1. import java.util.Random;

2.  

3. public class Dome {

4. public static void main(String[] args){

5. //创建Random对象，产生随机数

6. Random random = new Random();

7. //因为MyRandom里面的getInt方法返回一个，int的随机数

8. //而random的nextInt的非静态方法也返回一个int数，而且需要的一个int数，正好和getInt的参数和返回值一样

9. prin(random::nextInt,56);

10. }

11. // 参数为MyRandom的实现类对象,i为产生随机数的范围

12. public static void prin(MyRandom myRandom,int i){

13. //打印获得的随机数

14. System.out.println(myRandom.getInt(i));

15. }

16. }

17.  

18. //这是一个函数式接口

19. @FunctionalInterface

20. interface MyRandom{

21. //这个个抽象方法的作用是获得一个随机的int数 返回一个int类型的，

22. //参数为一个int值产生的数字范围是 0到i的范围

23. public abstract int getInt(int i);

24. }

         

 构造方法引用

         

1. public class Test02 {

2. public static void main(String[] args){

3. //因为Int抽象方法里面只有一个抽象方法，并且返回一个Random类的对象

4. //所以 抽象方法里面就只有 Random random = new Random() 这一条语句，所以就可以使用方法引用

5. Int i = Random::new;

6. Random random = i.fun();

7. }

8. }

9.  

10. //创建了一个函数式接口

11. @FunctionalInterface

12. interface Int{

13. //抽象方法返回一个Random的对象

14. public abstract Random fun();

15. }

            

  特定类型的实列方法引用 

1. public class Test02 {

2. public static void main(String[] args){

3. //这个接口里面的一个抽象方法要传入两个String类型的参数，返回一个boolean类型的值

4. //而equals又是String类型的非静态方法，我们这样先就相当于

5. //实现了这个接口，并且让接口的第一个参数，调用equals方法，

6. // 第二个参数作为参数传到equals方法里面作为equals方法里面的参数

7. Int i = String::equals;

8. //然后调用fun方法返回一个boolean值

9. boolean fun = i.fun("aaa", "bbb");

10.  

11. }

12. }

13.  

14. //创建了一个函数式接口

15. @FunctionalInterface

16. interface Int{

17. //抽象方法返回一个boolean类个方法的作用是判断两个字符串是否是相同的

18. public abstract boolean fun(String s,String s1);

19. }

 特定类型方法引用注意事项，抽象传入的参数，要比被引用的静态方法参数要少一个