jdk新特性 02 .接口增强和函数式接口，方法引用

1.JDK8中接口的新增
在JDK8中针对接口有做增强，在JDK8之前

interface 接口名{
静态常量;
抽象方法;
}

JDK8之后对接口做了增加，接口中可以有默认方法和静态方法

interface 接口名{
静态常量;
抽象方法;
默认方法;
静态方法;
}

2.默认方法

2.1 为什么要增加默认方法
在JDK8以前接口中只能有抽象方法和静态常量，会存在以下的问题：
如果接口中新增抽象方法，那么实现类都必须要抽象这个抽象方法，非常不利于接口的扩展的
举个例子：
接口

interface A{
void test1();
// 接口中新增抽象方法，所有实现类都需要重写这个方法，不利于接口的扩展
void test2();
}

两个接口的实现类

class B implements A{
	@Override
	public void test1() {
	}
	@Override
	public void test2() {
	}
}
class C implements A{
	@Override
	public void test1() {
	}
	@Override
	public void test2() {
	}
}

主启动类：

package com.bobo.jdk.inter;
public class Demo01Interface {
	public static void main(String[] args) {
		A a = new B();
		A c = new C();
	}
}

2.2 接口默认方法的格式

接口中默认方法的语法格式是

interface 接口名{
修饰符 default 返回值类型 方法名{
方法体;
}
}

接口的第三个方法是默认方法：

interface A{
void test1();
// 接口中新增抽象方法，所有实现类都需要重写这个方法，不利于接口的扩展
void test2();
/**
* 接口中定义的默认方法
* @return
*/
public default String test3(){
	System.out.println("接口中的默认方法执行了...");
	return "hello";
}
}

在接口的实现类中默认方法可以不强制重写实现，也可以重写实现

class B implements A{
	@Override
	public void test1() {
	}
	@Override
	public void test2() {
	}
	@Override
	public String test3() {
		System.out.println("B 实现类中重写了默认方法...");
		return "ok ...";
	}

package com.bobo.jdk.inter;
public class Demo01Interface {
public static void main(String[] args) {
	A a = new B();
	a.test3();
	A c = new C();
	c.test3();
}
}


}

2.3接口中的默认方法有两种使用方式

1. 实现类直接调用接口的默认方法
2. 实现类重写接口的默认方法，再用这个

---

3.静态方法
JDK8中为接口新增了静态方法，作用也是为了接口的扩展
3.1 语法规则

接口的静态方法格式：

interface 接口名{
修饰符 static 返回值类型 方法名{
方法体;
}
}

举个例子：
接口：

interface A{
	void test1();
	// 接口中新增抽象方法，所有实现类都需要重写这个方法，不利于接口的扩展
	void test2();
	/**
	* 接口中定义的默认方法
	* @return
	*/
	public default String test3(){
		System.out.println("接口中的默认方法执行了...");
		return "hello";
	}
	/**
	* 接口中的静态方法
	* @return
	*/
	public static String test4(){
		System.out.println("接口中的静态方法....");
		return "Hello";
	}
}

接口实现类：

class B implements A{
	@Override
	public void test1() {
	}
	@Override
	public void test2() {
	}
	@Override//这个是接口实现类的默认方法的重载
	public String test3() {
	System.out.println("B 实现类中重写了默认方法...");
	return "ok ...";
	}
}

class C implements A{
	@Override
	public void test1() {
	}
	@Override
	public void test2() {
	}
}

3.2 静态方法的使用
接口中的静态方法在实现类中是不能被重写的，调用的话只能通过接口类型来实现: 接口名.静态方法名
();

4. 两者的区别介绍

1. 默认方法通过实例调用，静态方法通过接口名调用
2. 默认方法可以被继承，实现类可以直接调用接口默认方法，也可以重写接口默认方法
3. 静态方法不能被继承，实现类不能重写接口的静态方法，只能使用接口名调用

---

函数式接口

1.1 函数式接口的由来
我们知道使用Lambda表达式的前提是需要有函数式接口，

而Lambda表达式使用时不关心接口名，抽象方法名。只关心抽象方法的参数列表和返回值类型。

因此为了让我们使用Lambda表达式更加的方法，在JDK中提供了大量常用的函数式接口。
举个例子：

package com.bobo.jdk.fun;
public class Demo01Fun {
	public static void main(String[] args) {
		fun1((arr)->{//此处的lambda表达式参数是arr数组
			int sum = 0 ;
			for (int i : arr) {
				sum += i;
			}
			return sum;
		});
	}
	public static void fun1(Operator operator){
		int[] arr = {1,2,3,4};
		int sum = operator.getSum(arr);
		System.out.println("sum = " + sum);
	}
}
/**
* 函数式接口
*/
@FunctionalInterface
interface Operator{
	int getSum(int[] arr);
}

1.2@FunctionalInterface注解（带有这个注解的接口是函数式接口）

/**
* @FunctionalInterface
* 这是一个标志注解，被该注解修饰的接口只能声明一个抽象方法
*/
@FunctionalInterface
public interface UserService {
void show();
}

2 函数式接口介绍
在JDK中帮我们提供的有函数式接口，主要是在 java.util.function 包中。

2.1 Supplier

无参有返回值的接口，对于的Lambda表达式需要提供一个返回数据的类型。

Supplier接口：

@FunctionalInterface
public interface Supplier<T> {
	/**
	* Gets a result.
	*
	* @return a result
	*/
	T get();//这个是lambda关注
}

使用：

/**
* Supplier 函数式接口的使用
*/
public class SupplierTest {
	public static void main(String[] args) {
		fun1(()->{//lambda表达式
			int arr[] = {22,33,55,66,44,99,10};
			// 计算出数组中的最大值
			Arrays.sort(arr);
			return arr[arr.length-1];//返回值
		});
}
	private static void fun1(Supplier<Integer> supplier){//先要声明一个方法来用接口
		// get() 是一个无参的有返回值的 抽象方法
		Integer max = supplier.get();//用到了接口的抽象方法
		System.out.println("max = " + max);
}}

2.2 Consumer

有参无返回值得接口

前面介绍的Supplier接口是用来生产数据的，而Consumer接口是用来消费数据的，使用的时候需要指定一个泛型来定义参数类型
Consumer 接口：

@FunctionalInterface
public interface Consumer<T> {
/**
* Performs this operation on the given argument.
*
* @param t the input argument
*/
void accept(T t);//接口的抽象方法，lambda关注的重点
}

使用：

public class ConsumerTest {
	public static void main(String[] args) {
		test(msg -> {//有参，参数是Hello World
			System.out.println(msg + "-> 转换为小写：" + msg.toLowerCase());
		});
	}
public static void test(Consumer<String> consumer){//声明一个方法，来用comsumer接口
	consumer.accept("Hello World");//在方法内用接口的抽象方法
	}
}

2.3 Function

有参有返回值的接口，

Function接口是根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。有参数有返回值。

Function接口：

@FunctionalInterface
public interface Function<T, R> {
	/**
	* Applies this function to the given argument.
	*
	* @param t the function argument
	* @return the function result
	*/
	R apply(T t);//接口的抽象方法，lambda关注的重点，有参数T t，有返回值R
}

运用：

public class FunctionTest {
	public static void main(String[] args) {
		test(msg ->{//lambda表达式，msg是test方法中字符串
			return Integer.parseInt(msg);
		});
	}
	public static void test(Function<String,Integer> function){//先声明一个方法，用到接口
		Integer apply = function.apply("666");//接口的抽象方法，接口中的字符串是前提条件，也就代表参数是字符串类型的
		System.out.println("apply = " + apply);
	}
}

2.4 Predicate
有参且返回值为Boolean的接口
Predicate接口：

@FunctionalInterface
public interface Predicate<T> {
	/**
	* Evaluates this predicate on the given argument.
	*
	* @param t the input argument
	* @return {@code true} if the input argument matches the predicate,
	* otherwise {@code false}
	*/
	boolean test(T t);//接口的抽象方法，lambda关注的重点，有参数T t，有返回值
}

运用：

public class PredicateTest {
	public static void main(String[] args) {
		test(msg -> {//msg是参数，值是后面的那个字符串HelloWorld，这个是test方法中
			return msg.length() > 3;
		},"HelloWorld");
	}
	private static void test(Predicate<String> predicate,String msg){//先声明一个方法，用到接口
		boolean b = predicate.test(msg);//接口的抽象方法
		System.out.println("b:" + b);
	}
}

方法引用
01 lambda表达式冗余
在使用Lambda表达式的时候，也会出现代码冗余的情况，比如：用Lambda表达式求一个数组的和

package com.bobo.jdk.funref;
import java.util.function.Consumer;
public class FunctionRefTest01 {
	public static void main(String[] args) {
		printMax(a->{
		// Lambda表达式中的代码和 getTotal中的代码冗余了
			int sum = 0;
			for (int i : a) {
				sum += i;
			}
			System.out.println("数组之和：" + sum);
		});
	}
	/**
	* 求数组中的所有元素的和
	* @param a
	*/
	public void getTotal(int a[]){
		int sum = 0;
		for (int i : a) {
			sum += i;
		}
		System.out.println("数组之和：" + sum);
	}
	private static void printMax(Consumer<int[]> consumer){
		int[] a= {10,20,30,40,50,60};
		consumer.accept(a);
	}
}

0.2 解决方案
因为在Lambda表达式中要执行的代码和我们另一个方法中的代码是一样的，这时就没有必要重写一份逻辑了，这时我们就可以“引用”重复代码

package com.bobo.jdk.funref;
import java.util.function.Consumer;
public class FunctionRefTest02 {
	public static void main(String[] args) {
	// :: 方法引用 也是JDK8中的新的语法
	printMax(FunctionRefTest02::getTotal);
	}
	/**
	* 求数组中的所有元素的和
	* @param a
	*/
	public static void getTotal(int a[]){
		int sum = 0;
		for (int i : a) {
			sum += i;
		}
		System.out.println("数组之和：" + sum);
	}
	private static void printMax(Consumer<int[]> consumer){
		int[] a= {10,20,30,40,50,60};
		consumer.accept(a);//抽象方法运用，有参数
	}
}

0 3. 方法引用的格式

符号表示： ::

符号说明：双冒号为方法引用运算符，而它所在的表达式被称为 方法引用

应用场景：如果Lambda表达式所要实现的方案，已经有其他方法存在相同的方案，那么则可以使用方法引用。

常见的引用方式：
方法引用在JDK8中使用是相当灵活的，有以下几种形式：

1. instanceName::methodName 对象::方法名
2. ClassName::staticMethodName 类名::静态方法
3. ClassName::methodName 类名::普通方法
4. ClassName::new 类名::new 调用的构造器
5. TypeName[]::new String[]::new 调用数组的构造器

3.1 对象名::方法名
这是最常见的一种用法。如果一个类中的已经存在了一个成员方法，则可以通过对象名引用成员方法

public static void main(String[] args) {
	Date now = new Date();
	Supplier<Long> supplier = ()->{return now.getTime();};//lambda表达式
	System.out.println(supplier.get());//这个接口的实例对象的get方法已经重写了
	// 然后我们通过 方法引用 的方式来处理
	Supplier<Long> supplier1 = now::getTime;
	System.out.println(supplier1.get());
}

方法引用的注意事项：

1. 被引用的方法，参数要和接口中的抽象方法的参数一样
2. 当接口抽象方法有返回值时，被引用的方法也必须有返回值

3.2 类名::静态方法名
也是比较常用的方式：

public class FunctionRefTest04 {
	public static void main(String[] args) {
		Supplier<Long> supplier1 = ()->{
		return System.currentTimeMillis();
	};
	System.out.println(supplier1.get());
	// 通过 方法引用 来实现
	Supplier<Long> supplier2 = System::currentTimeMillis;
	System.out.println(supplier2.get());
	}
}

3.3 类名::引用实例方法
Java面向对象中，类名只能调用静态方法，类名引用实例方法是用前提的，实际上是拿第一个参数作为方法的调用者

package com.bobo.jdk.funref;
import java.util.Date;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
public class FunctionRefTest05 {
	public static void main(String[] args) {
		Function<String,Integer> function = (s)->{//这里是重写方法，参数是字符串类型，但是值不知道
		return s.length();
		};
	System.out.println(function.apply("hello"));
	// 通过方法引用来实现
	Function<String,Integer> function1 = String::length;
	System.out.println(function1.apply("hahahaha"));
	BiFunction<String,Integer,String> function2 = String::substring;
	String msg = function2.apply("HelloWorld", 3);
	System.out.println(msg);
	}
}

3.4类名::构造器
由于构造器的名称和类名完全一致，所以构造器引用使用 ::new 的格式使用，

import java.util.Date;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
public class FunctionRefTest06 {
	public static void main(String[] args) {
		Supplier<Person> sup = ()->{return new Person();};
		System.out.println(sup.get());
		// 然后通过 方法引用来实现
		Supplier<Person> sup1 = Person::new;
		System.out.println(sup1.get());
		BiFunction<String,Integer,Person> function = Person::new;
		System.out.println(function.apply("张三",22));
	}
}

3.5 数组::构造器
数组是怎么构造出来的呢？

public static void main(String[] args) {
	Function<Integer,String[]> fun1 = (len)->{//这是重写接口的抽象方法
	return new String[len];
	};
	String[] a1 = fun1.apply(3);
	System.out.println("数组的长度是：" + a1.length);
	// 方法引用 的方式来调用数组的构造器
	Function<Integer,String[]> fun2 = String[]::new;
	String[] a2 = fun2.apply(5);
	System.out.println("数组的长度是：" + a2.length);
}