JAVA基础（方法的引用）

一，方法的引用（为方法起别名）需要一个函数式接口，接口中只有一个方法。

• 形式1：引用静态方法：类名称 ：： 方法名称

package 接口;
/**
 * 实现方法的引用接口
 * @param <P>引用方法的参数类型
 * @param <R>引用方法的返回类型
 */
 @FunctionalInterface//函数式接口声明注解，只能定义一个方法
 interface A<P,R>
{
    public R change(P p);
 }
public class InterfaceDemo {
    public static void main(String[] args){
        A<Integer,String> a = String::valueOf;//将String的静态valueOf方法给了change
        System.out.println(a.change(100)+100);//对change的使用就相当于对String的valueOf的使用
    }
 }

• 形式2：引用普通方法：实例化对象：：普通方法

package 接口;
/**
 * 实现方法的引用接口
 * @param <P>引用方法的参数类型
 * @param <R>引用方法的返回类型
 */
 @FunctionalInterface//函数式接口声明注解，只能定义一个方法
 interface A<P>
{
    public P upper();
 }
public class InterfaceDemo {
    public static void main(String[] args){
        A<String> a = "hello"::toUpperCase;
        System.out.println(a.upper());
    }
 }

• 形式3：引用特定类型的方法：特定类：：普通方法

package 接口;
/**
 * 实现方法的引用接口
 * @param <P>引用方法的参数类型
 * @param <R>引用方法的返回类型
 */
@FunctionalInterface//函数式接口声明注解，只能定义一个方法
 interface A<P>
{
    public int compare(P p1,P p2);
}
public class InterfaceDemo {
    public static void main(String[] args){
        A<String> a = String :: compareTo;//将String普通方法compareTo给了compare
        System.out.println(a.compare("h","j"));//将对象作为方法参数比较，不需要进行实例化对象后才能调用普通方法
    }
 }

• 形式4：引用构造方法：类名称：：new

package 接口;
/**
 * 实现方法的引用接口
 * @param <P>引用方法的参数类型
 * @param <R>引用方法的返回类型
 */
@FunctionalInterface//函数式接口声明注解，只能定义一个方法
 interface A<P>
{
    public P create(String name,int age);
}
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 InterfaceDemo {
    public static void main(String[] args){
        A<Person> a = Person :: new;
        Person p = a.create("aaaa",20);
        System.out.println(p);
    }
 }

二，内部函数式接口：java.util.function中的接口

• 功能型接口：
  public interface Function<T,R>{public R apply(T t);},需要接受一个参数并且返回一个结果

public class InterfaceDemo {
    public static void main(String[] args){
        Function<String,Boolean> fun = "hellow"::startsWith;
        System.out.println(fun.apply("he"));
    }
 }

• 供给型接口：
  public interface Supplier{public T get();},不接收参数，但返回结果

public class InterfaceDemo {
    public static void main(String[] args){
        Supplier<String> sup = "hello"::toUpperCase;//没有参数，只有返回值
        System.out.println(sup.get());
    }
 }

• 消费型接口：
  public interface Consumer{public void accept(T t); },只接收不返回

class demo
{
    public void print(String s){
        System.out.println(s);
    }
}
public class InterfaceDemo {
    public static void main(String[] args){
        Consumer<String> con = new demo()::print;//只有参数没有返回值
        con.accept("hello");
    }
 }

• 断言型接口：
  public interface Predicate{public boolean test(T t);},进行判断操作。

public class InterfaceDemo {
    public static void main(String[] args){
        Predicate<String> pre = "hello"::equalsIgnoreCase;
        System.out.println(pre.test("HELLO"));
    }
 }