Java8方法引用

内容简介:
方法引用Demo详解
通过5种语法使用方法引用
方法引用使用总结

1. 在Java8中方法引用Demo详解
   1.1 方法引用出现的背景
   在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿什么参数做什么操作。
   那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢?
   1.2 问题的引出

   //函数式接口,用于打印字符串.    @FunctionalInterface    interface Print{        public void print(String s);    }    //使用lambda表达式完成案例测试.    public class PrintDemo {        public static void main(String[] args) {            //Lambda方式解决            print(s -> {System.out.println(s);}, "hello");        }        public static void print(Print p,String s){            p.print(s);        }    }    输出结果:            hello

1.3 问题的发现与解决
这段代码的问题在于，对String进行控制台打印输出的操作方案，明明已经有了现成的实现，那就是System.out对象中的println(String)方法。既然Lambda希望做的事情就是调用println(String)方法，那何必自己手动调用呢？
能否省去Lambda的语法格式（尽管它已经相当简洁）呢？只要“路由”过去就好了：

//函数式接口,用于打印字符串.    @FunctionalInterface    interface Print{        public void print(String s);    }    //使用lambda表达式完成案例测试.    public class PrintDemo {        public static void main(String[] args) {            //方法引用解决方式            //请注意其中的双冒号“::”写法，这被称为“方法引用”，而双冒号是一种“引用运算符”。            print(System.out :: print,"world");        }        public static void print(Print p,String s){            p.print(s);        }    }    输出结果:            world

1.4 方法引用案例的总结
以上例中，System.out对象中有一个重载的println(String)方法恰好就是我们所需要的。那么对于printString方法的函数式接口参数，对比下面两种写法：
Lambda表达式：s -> System.out.println(s);
方法引用：System.out::println
第一种语义是指：拿到参数之后经Lambda之手，继而传递给System.out.println方法去处理。第二种等效写法的语义是指：直接让System.out中的println方法来取代Lambda。两种写法的执行效果完全一样，而第二种方法引用的写法复用了已有方案，更加简洁。1.5 引用运算符
双冒号“::”为引用运算符，而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者。
2.通过5种语法使用方法引用
2.1 通过对象名引用成员方法

  //函数式接口    @FunctionalInterface    interface Printable{        public void print(String s);    }    //已存在的类,类中有打印字符串的方法.    class AlreadyExistPrint{        public void PrintString(String s){        System.out.println(s);    }    //测试通过对象名进行方法引用.    public class ObjectMethodReference {        public static void main(String[] args) {            //通过对象名引用方法            AlreadyExistPrint ap = new AlreadyExistPrint();            print(ap :: PrintString,"java");        }        public static void print(Printable p,String s){            p.print(s);        }    }    输出结果:            java

2.2 通过类名引用静态方法

  //函数式接口    @FunctionalInterface    interface MyMath{        int max(int a, int b);    }    //已存在的类    这里使用JDK提供的Math类中的静态方法max(int a,int b);    //测试通过类名引用静态方法.    public class ClassStaticMethod {        public static void main(String[] args) {            //通过Math类的类名引用静态方法max();            int max = getMax(Math :: max, 10, 20);            System.out.println(max);        }        public static int getMax(MyMath lambda ,int a,int b){            return lambda.max(a, b);        }    }    输出结果:            20

2.3 通过类名引用成员方法

/*    成员方法需要依托对象才可以执行，所以当并不存在对象时，成员方法无法执行。    如果希望成员方法的引用中仅出现类名称而不出现对象名称，情况则要复杂一些：    必须为其指定一个用来执行成员方法的对象实例。    */    //在函数式接口中的参数里加入对象实例：    @FunctionalInterface    interface Printable{        public void print(AlreadyExistPrint a ,String s);    }    //已存在的类    class AlreadyExistPrint{        public void PrintString(String s){            System.out.println(s);        }    }    //测试通过类名引用成员方法.    public class ClassMethod {        public static void main(String[] args) {            //通过类名引用成员方法;            //lambda方式实现:            //语义解析: 拿着对象a去调用a的print方法打印s             print((a,s) -> {a.PrintString(s);},new AlreadyExistPrint(),"hello");            //简化写法: 方法引用 (通过类名引用成员方法)            print(AlreadyExistPrint :: PrintString,new AlreadyExistPrint(),"hello");        }        public static void print(Printable p ,AlreadyExistPrint a,String s){            p.print(a,s);        }    }    输出结果:            hello            hello

2.4 通过super引用成员方法

    //函数式接口    @FunctionalInterface    interface Eat{        void eat(String food);    }    //已存在的类    class Animal{        public void eat(String food){            System.out.println("吃:"+food);        }    }    //Animal的子类    class Cat extends Animal{        @Override        public void eat(String food) {            //通过super引用父类的方法.            method(super :: eat,food);        }        public void method(Eat e, String s){            e.eat(s);        }    }    //测试通过类名引用成员方法.    public class SuperMethod {        public static void main(String[] args) {            Cat c = new Cat();            c.eat("鱼");        }    }    输出结果:            吃鱼

2.5通过this引用成员方法

    //函数式接口    interface shopping {        void buy(int money);    }    //已存在的类    class Man {        //男人将来都要买个属于自己的房子.        public void buyHouse(int money) {            System.out.println("买套房子消费:"+money);        }        //结婚就得购物,买买买啊.        public void marry(shopping lambda,int money) {            lambda.buy(money);        }        //开心方法.男人要想开心.就得结婚        public void beHappy() {            //通过this引用成员方法.            marry(this::buyHouse,1000000);        }    }    //测试通过类名引用成员方法.    public class ThisMethod {        public static void main(String[] args) {            Man man = new Man();            man.beHappy();        }    }    输出结果:            买套房子消费:1000000

3.方法引用使用总结
       (1) Lambda表达式：s -> System.out.println(s);        (2) 方法引用：System.out::println

第一种语义是指：拿到参数之后经Lambda之手,继而传递给System.out.println方法去处理。

第二种等效写法的语义是指：直接让System.out中的println方法来取代Lambda。
两种写法的执行效果完全一样，而第二种方法引用的写法复用了已有方案，更加简洁。

函数式接口是Lambda的基础，而方法引用是Lambda的孪生兄弟。