JAVA8新特性——方法引用

　　JAVA9都要出来了，JAVA8新特性都没搞清楚，是不是有点掉队哦~

　　在Lamda新特性的支持下，JAVA8中可以使用lamda表达式来创建匿名方法。然而，有时候我们仅仅是需要调用一个已存在的方法（如java中已经定义好的方法），在这时候java8新特性“方法引用”将会进一步简化操作（注意：需要有Lamda的支持）。

方法引用的四种形式：

• 引用静态方法-->类名称::static 方法名称；
• 引用某个对象的实例的普通方法-->示例化对象::普通方法；
• 引用某个类型的任意对象的实例的普通方法-->特定类::普通方法；
• 引用构造方法-->类名称::new

引用静态方法

　　如：String类中的valueOf()方法：public static String valueOf(int x);

 /**
  * 实现方法的引用接口
  * @param <P>引用方法的参数类型
  * @param <R>引用方法的返回类型
  */
 interface MyInterface<P,R>{
     public R function(P p);//和String.valueOf(int x)类似
 }

 interface MyInterface1{
     String function(Integer a);
 }

 public class Main {

     public static void test(MyInterface1 myInterface1){
         String result = myInterface1.function(2000);
         System.out.println(result+"  --");
     }

     public static void main(String[] args) {

         //匿名内部类实现
         test(new MyInterface1() {
             @Override
             public String function(Integer a) {
                 return String.valueOf(a);
             }
         });

         //Lamda表达式实现
         test((a)->String.valueOf(a));

         //方法引用实现:引用类的静态方法
         MyInterface<Integer,String> msg = String::valueOf;
         String str = msg.function(2000);
         System.out.println(str);
     }
 }

引用某个对象的实例的普通方法

　　如：String类中的toUpperCase()方法：public String toUpperCase();

　　这个方法没有参数，但是有返回值，并且这个方法一定要在有实例化对象的时候才可以调用。

 interface MyInterface2<R>{
     public R upper();
 }
 public class Main1 {
     public static void main(String[] args) {
         String str = new String("hello");
         MyInterface2<String> msg = str::toUpperCase;
         System.out.println(msg.upper());//调用upper方法，就相当于调用toUpperCase方法
     }
 }

　　在上面的演示中已经发现，如果要实现方法的引用，就必须要有接口，并且这个接口中只能存在一个方法，否则方法是无法进行引用的。

　　所以为了保证被引用的接口里面只能够定义一个方法，就要在接口上加以限制，使用@FunctionalInterface 注解。

 @FunctionalInterface   //此为函数式接口，只能够定义一个方法
 interface MyInterface2<R>{
     public R upper();
 }

引用某个类型的任意对象的实例的普通方法

　　比如：String类中的compareTo(String str1,String str2)方法 public int compareTo(String anotherString);

　　如果要进行比较的话，比较的形式：字符串1对象.compareTo(字符串2对象)，要准备两个参数。

 @FunctionalInterface   //此为函数式接口，只能够定义一个方法
 interface MyInterface3<P>{
     public int compare(P p1,P p2);
 }
 public class Main2 {
     public static void main(String[] args) {
         MyInterface3<String> msg = String::compareTo;
         System.out.println(msg.compare("A","B"));
     }
 }

　　与之前相比，方法引用前不需要再定义对象，而是可以理解为将对象定义在了参数中。

引用构造方法

 @FunctionalInterface   //此为函数式接口，只能够定义一个方法
 interface MyInterface4<C>{
     public C person(String n,int a);
 }
 class Person{
     private String name;
     private int age;

     public Person(String name, int age) {
         this.name = name;
         this.age = age;
     }
     @Override
     public String toString() {
         return  "姓名："+this.name+",年龄："+this.age;
     }
 }
 public class Main3 {
     public static void main(String[] args) {
         MyInterface4<Person> msg = Person::new;//引用构造方法
         Person person = msg.person("小明",20);
         System.out.println(person);
     }
 }

　　小结：有点毁三观的感觉！