方法引用和构造器引用

方法引用和构造器引用

一、方法引用

1、举例

public void test(){
	//匿名实现类对象
	Comparator<Integer> com = new Comparator<Integet>(){
		public int compare(Integer o1,Integer o2){
			return Integer.compare(o1,o2);
		}
	};
	//Lambda表达式写法
	Comparator<Integer> com = (Integer o1,Integer o2) -> Integer.compare(o1,o2);

	//方法引用写法
	Comparator<Integer> com = Integer::compare;
}

2、方法引用的理解

• 可以看作是基于Lambda表达式的进一步刻画。
• 当需要提供一个函数式接口的实例时，我们可以使用Lambda表达式提供此实例。
• 当满足一定条件的情况下，我们还可以使用方法引用或构造器引用替换Lambda表达式

3、方法引用的本质

Comparator<Integer> com = Integer :: compare;

方法引用作为了函数式接口的实例 —> ‘‘万事万物皆对象’’

4、格式

类（或对象）:: 方法名

5、具体使用情况说明

• ①对象 :: 实例方法（非静态方法）

例子1：
public void test(){
	//1.匿名实现类对象
	Consumer<String> con1 = new Consumer<String>(){
		public void accept(String s){
			System.out.println(s);
		}
	};
	con1.accept("hello!");
	//2.Lambda表达式
	Consumer<String> con2 = s -> System.out.println(s);
	con2.accept("hello!");
	
	//3.方法引用
	PrintStream ps = System.out;
	Consumer<String> con3 = ps::println;
	con3.accept("hello!");
}

例子2：
public void test2(){
	Employee emp = new Employee(1001,"马化腾",34,8000);
	//1.匿名实现类对象
	Supplier<String> sup1 = new Supplier<String>(){
		public String get(){
			return emp.getName();
		}
	};
	System.out.println(sup1.get());

	//2.Lambda表达式
	Supplier<String> sup2 = () -> emp.getName();
	System.out.println(sup2.get());

	//3.方法引用
	Supplier<String> sup3 = emp :: getName();
}

要求：函数式接口中的抽象方法a与其内部实现时调用的对象的某个方法b的形参列表和返回值类型相同，可以考虑使用方法b实现对方法a的替换、覆盖。
注意:此方法b是非静态方法，需要对象调用。

• ② 类 :: 静态方法

例子1：
public void test(){
	//1.匿名实现类对象
	Comparator<Integer> com = new Comparator<Integet>(){
		public int compare(Integer o1,Integer o2){
			return Integer.compare(o1,o2);
		}
	};
	//2.Lambda表达式写法
	Comparator<Integer> com = (Integer o1,Integer o2) -> Integer.compare(o1,o2);

	//3.方法引用写法
	Comparator<Integer> com = Integer::compare;
例子2：
public void test(){
	//1.匿名实现类对象
	Function<Double,Long> fun1 = new Function<Double,Long>(){
		public Long apply(Double aDouble){
			return Math.round(aDouble);
		}
	};
	//2.Lambda表达式写法
	Function<Double,Long> fun2 = aDouble -> Math.round(aDouble);
	//3.方法引用写法
	Function<Double,Long> fun2 = Math :: round;
}

要求：函数式接口中的抽象方法a与其内部实现时调用的类的某个方法b的形参列表和返回值类型相同，可以考虑使用方法b实现对方法a的替换、覆盖。
注意:此方法b是静态方法，需要类调用。

• ③ 类 :: 实例方法

例子1：
public void test(){
	//1.匿名实现类对象
	Comparator<String> com1 = new Comparator<Integet>(){
		public int compare(String s1,String s2){
			return o1.compareTo(s2);
		}
	};
	System.out.println(com1.compare("abc","abd"));
	//2.Lambda表达式写法
	Comparator<String> com = (s1,s2) -> s1.compareTo(s2);

	//3.方法引用写法
	Comparator<Integer> com = String::compareTo;
例子2：
public void test2(){
	//1.匿名实现类对象
	BiPredicate<String,String> biPre1 = new BiPredicate<String,String>(){
		public boolean test(String s1,String s2){
			return s1.equals(s2);
		}
	};
	//2.Lambda表达式写法
	BiPredicate<String,String> biPre2 = (s1,s2) -> s1.equals(s2);

	//3.方法引用写法
	BiPredicate<String,String> biPre3 = String :: equals;
}
例子3：
public void test3(){
	Employee emp = new Employee(1001,"马化腾",34,6099);
	//1.匿名实现类对象
	Function<Employee,String> fun1 = new Function(){
		public String apply(Employee employee){
			return employee.getName();
		}
	};
	//2.Lambda表达式写法
	Function<Employee,String> fun2 = employee -> employee.getName();
	//3.方法引用写法
	Function<Employee,String> fun3 = Employee :: getName;
}

要求:函数式接口中的抽象方法a与其内部实现时调用的对象的某个方法b的返回类型相同。同时，抽象方法a中有n个参数，方法b中有n-1个参数，且抽象方法a的第一个参数作为方法b的调用者，且抽象方法a的后n-1个参数与方法b的n-1个参数的类型相同。则称为方法引用。
注意：此方法b是非静态的方法，需要对象调用，但格式上使用对象a所属的类。

二、构造器引用

1、构造器引用

例子1
public void test1(){
	//1.匿名实现类对象
	Supplier<Employee> sup1 = new Supplier<Employee>(){
		public Employee get(){
			return new Employee();
		}
	};
	System.out.println(sup1.get());
	//2.构造器引用
	Supplier<Employee> sup2 = Employee :: new;//调用的是Employee类中空参构造器
	System.out.println(sup2.get());
}
例子2:
public void test2(){
	//1.匿名实现类对象
	Function<Integer,Employee> func1 = new Function<Integer,Employee>(){
		public Employee apply(Integer id){
			return new Employee(id);
		}
	};
	System.out.println(func1.apply(12));
	//2.构造器引用
	Supplier<Employee> func2 = Employee :: new;//调用的是Employee类中参数是Integer/int类型的构造器
}

2、格式

类名 :: new;

3、说明

• 调用了类名对应的类中的某一个确定的构造器
• 具体调用的是类中的哪一个构造器，取决于函数式接口的抽象方法的形参列表