一、关于接口的新特性

1.1 jdk1.8之前的接口重要特性

• 方法全都是抽象方法,即都没有方法体

1.2 JDK8以后

• 允许接口中有被default和static修饰的方法带方法体

代码演示

接口USB

public interface USB {/** jdk8之前接口中只能有抽象方法* jdk8之后接口中被default的方法不是抽象方法，可以被重写，也可以不重写，不强制* 且方法还可以被static修饰，不能被重写，调用，只能通过接口调用*/int a =1;void fun1();// 默认抽象方法default void funNew(){// 被default修饰方法System.out.println("JDK8新特性：default修饰的方法要有方法体,实现类不强制重写");}static void funNew2(){// 被static修饰方法System.out.println("JDK8新特性：static修饰的方法要有方法体，实现类不可重写，不可调用，通过接口直接调用");}
}

实现类USBImpl

public class USBImpl implements USB{@Overridepublic void fun1() {System.out.println("重写旧方法");}@Overridepublic void funNew() {  //可以重写default修饰的方法}}

测试

public class USBImplTest {public static void main(String[] args) {USBImpl usb = new USBImpl();usb.fun1();usb.funNew();//usb.funNew2(); //实现类无法调用USB.funNew2();// 通过接口调用静态方法}
}

1.3 总结

通过代码演示发现

• jdk8之后接口中被default的方法不是抽象方法，可以被重写，也可以不重写，不强制
• 且方法还可以被static修饰，不能被重写，调用，只能通过接口调用

作用

• 默认方法允许在不破坏现有实现的情况下向接口添加新功能。
• 可以在不改变现有用户代码的情况下扩展接口。
• 促进了API的演进，同时保持了向后的兼容性。

二、Lambda表达式[重点]

Lambda是匿名内部类的简化

Lambda 允许把函数(方法)作为一个方法的参数（函数作为参数传递到方法中）。

---

其实就是简化了匿名内部类的写法,更准确的说是对接口方法的重写的简化

2.1 将匿名内部类写法改写为lambda写法

使用lambda改写创建线程的方式

    public static void main(String[] args) {new Thread(new Runnable( ) {@Overridepublic void run() {for (int i = 0; i < 10001; i++) {System.out.println("正常实现Runnable完成线程" + i);}}}).start( );// 改成lambda形式// lambda是简化了匿名内部类,只剩下关于方法的参数列表和方法体// () -> {}new Thread(() -> {for (int i = 0; i < 10001; i++) {System.out.println("lambda完成线程"+i);}}).start( );// lambda是将方法当参数传递给另外一个方法}
}

2.2 语法特点

能够写成lambda形式的的前提

1. 方法得有参数
2. 参数的必须是接口
3. 接口中的方法有且只能有一个!!!

语法特征

(参数) -> {执行语句}
或者
参数 -> 执行语句

• 参数圆括号,当参数是一个的时候,圆括号可加可不加

  • (x) -> System.out.println(x)
  • x -> System.out.println(x)

• 参数圆括号,当参数是多个的时候,圆括号必须加

  • (x,y) -> System.out.println(x+y)

• 参数数据类型可写可不写,编译时会自动推断是什么类型

  • (x,y) -> System.out.println(x+y)
  • (int x,String y) -> System.out.println(x+y)

• 执行语句的花括号,当且仅当执行语句只有一句时,可以不加花括号

  • new Thread(() -> System.out.println("匿名内部类开启线程")).start();
    

• 执行语句的花括号,当执行语句不只一句时,必须加花括号

  • new Thread(() -> {int a = 1;a++;System.out.println("lambda开启线程" );}).start();
    

• 关于返回值

  • 如果方法有返回值,且执行语句只有一行语句时,可以不用写return,直接写值

    test(() -> {return 1;});
    test(() -> 1);// 1就是return1
    

  • 如果代码比较多,又要返回数据,就必须写上return

    test(() -> {int a = 1;a++;return a;
    });
    

代码演示

ppublic class lambdaTest {/*1. **方法得有参数**2. **参数的必须是接口**3. **接口中的方法有且只能有一个!!!***/public static void main(String[] args) {// 如果lambda方法体中只有一行代码,{}可以省略show1(() -> System.out.println("无参无返回值"));// 如果lambda方法体中有多行代码,{}不能省略show1(() -> {System.out.println("无参无返回值1");System.out.println("无参无返回值2");System.out.println("无参无返回值3");});/** 有参数列表时，参数类型可以省略*/// 只有一个参数,（）可以省略show2(b1 -> System.out.println(b1 * 10));// 参数数量>1,（）不可以省略show3((c1,c2)->System.out.println(c1 + c2));// 有返回值，但是只有一行代码，{}可以省略，return也可以省略，-> 跟的就是返回值show4(d -> d);}//接口IA为参数，IA只有一个方法static void show1(IA ia){ia.a();}//接口IB为参数，IB只有一个方法static void show2(IB ib){ib.b(1);}//接口IC为参数，IC只有一个方法static void show3(IC ic){ic.c(1,2);}//接口ID为参数，ID只有一个方法static void show4(ID id){id.d(10);}
}
// 接口：IA只有一个无参无返回值方法
interface IA{void a();  //无参无返回值
}// 接口：IA只有两个个无参无返回值方法
interface IC{void c(int c1,int c2);  //参无返回值
}// 接口：IA只有一个无参无返回值方法
interface IB{void b(int b);  //无参无返回值
}// 接口：IA只有一个无参无返回值方法
interface ID{int d(int a);  //无参无返回值
}

深入理解lambda

为什么lambda要设计成,将方法(功能) 当参数传递给方法

• 有了lambda,方法的功能不再局限,方法具体如何,要看看lambda功能如何

public class Demo3 {public static void main(String[] args) {double add = add(1, 2);System.out.println("add = " + add);double yunsuan = yunsuan((x, y) -> x / y, 1, 2);System.out.println("yunsuan = " + yunsuan);}/*** 已经的方法,参数列表是普通变量* 方法功能已经定好,唯一变化的是参数的值* 例如,这个add方法,是做两数相加,只能相加* 唯一能变的是,加的数不一样* --------------------------* 那如果,我想传入两个参数,让其相除返回结果?让其相乘返回结果?* 就需要重新设计方法*/public static double add(int a,int b){return a + b;}/*** 有了lambda之后,方法的执行功能就不再固定* 如何运行,要看调用时,传入的lambda是如何运行的*/public static double yunsuan(IE e,int a,int b){return e.jisuan(a, b);}}
interface IE {double jisuan(int a,int b);
}

2.3 总结

• 其实 () -> {}
  • ()里面放的是重写方法的参数
  • {}里面放的是重写方法的方法体
  • 上面各种写法只是在特定情况下的简写，没有特定条件是没法简写的，就要按部就班来

• lambda就是简化了匿名内部类的写法
• lambda其实就是接口方法的重写
• lambda的参数和返回值是根据接口方法决定的

三、函数式接口

3.1 概念

什么是函数式接口

接口中只有一个抽象方法时,该接口就是函数式接口.

Java提供了一个注解可以校验接口是否是函数式接口

@FunctionalInterface

---

Java中提供了几个特别常用的函数式接口

• Supplier 供应,即返回一个数据 (无参有返回值的方法)
• Consumer 消费,即给其传入数据做运算 (有参无返回值的方法)
• Function 函数,传入2个参数,用于转换数据的 (有参有返回值的方法)
• Predicate 判断,返回时boolean (有参,返回值是boolean)

---

四个典型的函数式接口

3.2 Supplier

• Supplier.java源码

@FunctionalInterface
public interface Supplier<T> {/*** Gets a result.** @return a result*/T get();
}
// 该接口用来返回一个数据,所以叫供应商
// 其实就是无参数有返回值的接口,用的时候就是无参有返回值的lambda

练习,设计方法,通过Supplier接口,获得字符串的长度

		/** Supplier接口 ---顾名思义：供应，提高*  提供的方法--- T get();*  不需传入参数，就有返回值*///利用Supplier接口，实现获得字符串长度功能int i = get(() -> "java".length());System.out.println("i = " + i);// i = 4//参数为Supplier接口的方法public static int get(Supplier<Integer> supplier){return supplier.get();}

3.3 Consumer

JDK中Consumer.java源码

@FunctionalInterface
public interface Consumer<T> {/*** Performs this operation on the given argument.* 给传入一个值,对该值进行操作* @param t the input argument*/void accept(T t);
}
// 其实就是有参数无返回值的接口,用的时候就是有参无返回值的lambda

练习:设计方法,传入字符串,将字符串全部转大写,后输出

 		/** Consumer接口 ---顾名思义：消费，消耗*  提供的方法--- void accept(T t);*  需传入参数，无返回值*///利用Consumer接口，实现字符串转大写功能String s = "java";accept(c -> System.out.println(c.toUpperCase()),s);// JAVA//参数为Consumer接口的方法public static void accept(Consumer<String> consumer,String s){consumer.accept(s);}

3.4 Function

JDK中Function.java源码

@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

利用Function，实现字符串数字转为整形数字功能

	 	/** Function<T, R>接口 ---顾名思义：函数，功能*  提供的方法--- R apply(T t);*  将T转换乘R类型 ，即转换数据*///利用Function，实现字符串数字转为整形数字功能String s2 = "111";Integer apply = apply(f -> Integer.parseInt(f), s2);System.out.println("apply = " + apply);// apply = 111//参数为Function接口的方法public static Integer apply(Function<String,Integer> function,String s){return function.apply(s);}

3.5 Predicate

JDK中Predicate.java源码

@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);
}

判断数据是否是偶数

   /** Predicate接口 ---顾名思义：判断，断定*  提供的方法--- boolean test(T t);*  提供判断方法*///利用Predicate接口，实现判断是否时偶数功能int i1 = 2;boolean b = predicate(a -> a % 2 == 0, i1);System.out.println("b = " + b); // b = true//参数为Predicate接口的方法public static boolean predicate(Predicate<Integer> predicate,Integer integer){return predicate.test(integer);}

3.6 总结

• Supplier接口的方法一般用于 获得数据
• Consumer接口的方法 一般用于 处理数据
• Function接口的方法一般用于 转换数据
• Predicate接口的方法一般用于 判断数据

思维导图

---

最后

如果感觉有收获的话，点个赞 👍🏻 吧。
❤️❤️❤️本人菜鸟修行期，如有错误，欢迎各位大佬评论批评指正！😄😄😄

💘💘💘如果觉得这篇文对你有帮助的话，也请给个点赞、收藏下吧，非常感谢!👍 👍 👍