一、接口

1.1 接口组成更新概述

• 常量

public static final 可以省略

• 抽象方法

public abstract 可以省略

• 默认方法（since java8）

如下图所示

• 静态方法（since java8）

如下图所示

• 私有方法（since java9）

1.2 默认方法

1.2.1 使用场景

假设我们已经存在一个劲接口MyInterface，但是随着业务的进行我们还需要在MyInterface接口中增加一个方法，但是如果我们增加的话，他的每个实现类都需要将这个方法进行实现。

此时有一个坏处，并不是每个类都能使用到这个接口，那我们就重新创建一个接口MyInterfaceSon去继承MyInterface接口，并且写上想增加的方法，如果有类想要使用这个方法，直接可以实现MyInterfaceSon这个类。 但是这样用的话，以后还是会出现想用的问题

public interface MyInterfaceSon extends MyInterface{
}

那我们就可以在接口中使用默认方法，如下所示，当我们添加一个默认方法后，实现MyInterface的类可以选择实现方法show3，也可以选择不实现，很人性化

public interface MyInterface {void show1();void show2();public default void show3(){}
}

总结来说：方法的升级不会破坏现有的代码

1.2.2 默认方法的使用

public default 返回值类型 方法名(参数列表){ }

其中 public是可以省略的

 public interface MyInterface {void show1();void show2();public default void show3(){
//    方法体}
}

当我们给MyInterface接口多加了一个default方法后，下面的实现类并没有报错

当我们子类实现show3方法的时候，发现没有default这个关键字了，一定要注意

1.3 静态方法

静态方法只能通过接口名调用，不能通过实现类名或者对象名调用

public static 返回值类型 方法名(参数列表){}

public可以省略

    public static  void show(){}

1.3.1 静态方法的使用

public interface Inter {void show();default void method(){System.out.println("Inter中的默认方法执行了");}public static void test(){System.out.println("Inter中的静态方法执行了");}
}

public class InterImpl implements Inter{@Overridepublic void show() {System.out.println("show方法执行了");}
}

然后我们发现我们掉用不了静态的test方法

静态方法只能在包含接口类上调用
Static method may be invoked on containing interface class only

为什么只能通过类来调用呢？
假设InterImpl这个实现类实现了好几个接口，并且每个接口中都有test静态方法，那如果此时再通过实例对象调用，编译器将不会知道调用哪个接口的test方法

1.4 私有方法(Java9)

1.4.1 接口中的私有方法

Java 9 中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。

这样可能会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段代码抽取成一个共性的方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java 9增加私有方法的必然性

格式：

private 返回值类型 方法名(参数列表){}

private static 返回值类型 方法名(参数列表){}

示例：

private void show(){}private static void method(){}

1.4.2 接口中私有方法的使用

一定要注意！！！！

默认方法可以调用私有静态方法，但是静态方法无法调用私有默认方法

自我理解出现这种情况的原因：
其实说白了和这个根本没有关系，其实和 方法是不是静态方法或者是实例方法有关。
我为什么这么说呢，我解释一下

静态方法什么时候被加载呢？
当然是在class文件被加载的时候，也就是说在方法区就被加载了

实例方法什么时候被加载？
在程序运行过程中类实例化后才会存在。

那这样说来就很清晰了，即我们不实例化我们也是可以使用静态方法的，但是不可以使用实例方法。 那如果我们在静态方法中调用了实例方法，但我没有对此类进行实例化，那肯定是不符合要求的呀，你没有实例化怎么能在静态方法中调用实例方法呢？

public class InterImpl implements Inter{
}

public interface Inter {default void show1() {System.out.println("show1开始执行");
//        抽取下面的三行
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");show();System.out.println("show1结束执行");}default void show2() {System.out.println("show2开始执行");
//        抽取下面的三行
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");show();System.out.println("show2结束执行");}private void show() {System.out.println("初级工程师");System.out.println("中级工程师");System.out.println("高级工程师");}static void method1() {System.out.println("method1开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");method();System.out.println("method1结束执行");}static void method2() {System.out.println("method2开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");method()System.out.println("method2结束执行");}private static void method() {System.out.println("初级工程师");System.out.println("中级工程师");System.out.println("高级工程师");}
}

public class InterDemo {public static void main(String[] args) {
//    按照多态的方式创建对象并使用Inter i = new InterImpl();i.show1();System.out.println("----------");i.show2();System.out.println("----------");Inter.method1();System.out.println("----------");Inter.method2();}
}

二、引用

对lambda表达式不熟悉可以看下面的文章
(45条消息) JDK 8新特性——Lambda表达式_我爱布朗熊的博客-CSDN博客

2.1 体验方法引用

在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方法：拿参数做操作

那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同的方案，那是否还有必要再重写逻辑呢？那我们如何使用已经存在的解决方案的呢？

@FunctionalInterface
public interface Printable {void printString(String s);
}

public class PrintableDemo {public static void main(String[] args) {
//     第一种写法： lambda表达式usePrintable( (s -> System.out.println(s)));System.out.println("****************");//     第二种写法：lambda表达式Printable printable = (s) -> {System.out.println(s);};usePrintable(printable);System.out.println("****************");//     第三种写法：方法引用符 ::
//           System.out是一个对象，我们要调用此对象下的println方法usePrintable(System.out::println);}private static void usePrintable(Printable p){p.printString("爱生活爱Java");}
}

2.2 方法引用符

如果使用Lambda，那么根据"可推导就是可省略"的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导。如果使用方法引用，也是同样可以根据上下文进行推导

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

usePrintable(System.out::println);

直接使用System.out中的println方法来取代Lambda，代码更加的简洁

• 对比一下lambda表达式

usePrintable( (s -> System.out.println(s)));

分析： 拿到参数s之后通过Lambda表达式，传递给System.out.println方法去处理

2.3 引用类方法(静态方法)

• 格式： 类名::静态方法

• 范例： Integer::parseInt

Integer类的方法，public static int parseInt(String s) 将此String转换为int类型的数据

@FunctionalInterface
public interface Converter {int convert(String s);
}

public class ConverterDemo {public static void main(String[] args) {
//    1.匿名内部类表达式useConverter(new Converter() {@Overridepublic int convert(String s) {return Integer.parseInt(s);}});//    2.lambda表达式
//        Converter converter = (String s) -> {
//            return Integer.parseInt(s);
//        };
//        useConverter(converter);useConverter((String s) -> {return Integer.parseInt(s);});//     3.引用类方法
//         lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数useConverter(Integer::parseInt);}private static void useConverter(Converter c){int number = c.convert("666");System.out.println(number);}
}

2.4 引用对象的实例方法(成员方法)

其实就是引用类中的成员方法、

• 格式： 对象::成员方法

• 范例： "HelloWord"::toUpperCase

String类中的方法：public String toUpperCase() 将此String所有字符转换成大写

public class PrinterDemo {public static void main(String[] args) {
//      1.Lambda表达式userPrinter((String s) ->{String result = s.toUpperCase();System.out.println(result);});//      2.引用成员方法PrintString printString = new PrintString();userPrinter(printString::printUpper);}private static void userPrinter(Printer p) {p.printUpperCase("HelloWord");}
}

public interface Printer {void printUpperCase(String s);
}

public class PrintString {public void printUpper(String s){System.out.println(s.toUpperCase());}
}

2.5引用类的实例方法

其实就是引用类中的成员方法

• 格式： 类名::成员方法

• 范例： String::substring

String类中的方法：public String substring(int beginIndex, int endIndex) 从beginIndex开始到endIndex结束，截取字符串，返回一个子串，子串的长度为endIndex-beginIndex

public interface MyString {String mySubString(String s,int x,int y);
}

public class MyStringDemo {public static void main(String[] args) {
//      1.lambda表达式的形式useMyString((s,x,y)->{String substring = s.substring(x, y);return  substring;});//       2.方法引用useMyString(String::substring);}public static void useMyString(MyString my){String s = my.mySubString("HelloWorld", 2, 5);System.out.println(s);}
}

2.6 引用构造器

引用构造器，其实就是引用构造方法

• 格式： 类名:: new

• 范例： Student::new

三、函数式接口

3.1 概述

函数式接口： 有且仅有一个抽象方法的接口

Java中的函数式变成体现就是lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口，只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导

public interface MyInterface {void show();
}

public class MyInterfaceDemo {public static void main(String[] args) {MyInterface my  = ()->{System.out.println("函数式接口");};my.show();}
}

但是对于MyInterface接口，我们知道其有一个方法，知道是函数式接口，那万一以后有人再修改接口，新增加抽象方法，那岂不是我们在Demo中的程序无法运行了？

答案： 是的！

为了避免这种情况，我们可以在接口上使用@FunctionalInterface注解，用意是标注此接口为函数式接口

@FunctionalInterface
public interface MyInterface {void show();
}

3.2 函数式接口作为方法的参数

public class RunnableDemo {public static void main(String[] args) {
//      1.匿名内部类startThread(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"线程启动了");}});//      2.lambda表达式startThread(()->{System.out.println(Thread.currentThread().getName()+"线程启动了");});//        2.1更清晰的写法Runnable runnable =()->{System.out.println(Thread.currentThread().getName()+"线程启动了");};startThread(runnable);}//  Runnable 接口是函数式接口public static void startThread(Runnable r){
//        Thread t = new Thread(r);
//        t.start();new Thread(r).start();}
}

3.3 函数式接口作为方法的返回值

很明显，我们的返回值类型是一个函数式接口

public class ComparatorDemo {public static void main(String[] args) {ArrayList<String> arrayList = new ArrayList<>();arrayList.add("cccc");arrayList.add("aa");arrayList.add("b");arrayList.add("saff");System.out.println("排序前："+arrayList);//      排序Collections.sort(arrayList,getComparator());System.out.println("排序后："+arrayList);}private static Comparator<String> getComparator(){Comparator<String> comp = new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {return o1.length()-o2.length();}};return comp;
//      比较的逻辑也能使用Lambda表达式的形式
//        return (s1,s2)->{
//            return s1.length()-s2.length();
//        };}
}

3.4 常用的函数式接口

3.4.1 Supplier

Supplier<T>:包含一个无参的方法

• T get(): 获得结果

• 该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据

• Supplier<T> 接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用

public class SupplierDemo {public static void main(String[] args) {
//      写法1：String string1 = getString(() -> {return "林青霞";});System.out.println(string1);//      写法2：Supplier<String> supplier =  ()->{return "林青霞";};String string2 = getString(supplier);System.out.println(string2);} 
//    定义一个方法，返回字符串数据private static String getString(Supplier<String> supplier){return supplier.get();}
}

3.4.1.1 Supplier接口获取最大值

public class SupplierTest {public static void main(String[] args) {
//       定义一个int数组int[] arr= {19,50,28,37,46};int maxNum = getMax(() -> {int max = arr[0];for (int i = 1; i < arr.length; i++) {if (arr[i] > max) {max = arr[i];}}return max;});System.out.println(maxNum);}private static int getMax(Supplier<Integer> supplier){return supplier.get();}
}

3.4.2 Consumer接口 消费型接口

Consumer<T> 包含两个方法

Consumer接口也称为消费型接口，它消费的数据的数据类型由泛型指定

• void accept(T t): 对给定的参数执行此操作

• default Consumer<T> andThen(Consumer after): 返回一个组合的Consumer，依次执行此操作，然后执行after操作

public class ConsumerDemo {public static void main(String[] args) {operatorString("林青霞", (String s) -> {System.out.println(s);});}private static void operatorString(String name, Consumer<String> consumer) {consumer.accept(name);}
}

3.4.2.1 Consumer—按要求打印信息

• String[] strArray={"林青霞,30" , "张曼玉,35" , "王祖贤,33" };

• 字符串数组中有多条信息，请按照格式："姓名：xx，年龄：xx"的格式将信息打印出来

• 要求：

把打印姓名的动作作为第一个Consumer接口的Lambda实例

把打印年龄的动作作为第二个Consumer接口的Lambda实例

将两个Consumer接口按照顺序组合到一起使用

public class ConsumerTest {public static void main(String[] args) {String[] strArray={"林青霞,30" , "张曼玉,35" , "王祖贤,33" };printInfo(strArray,(String str)->{String name = str.split(",")[0];System.out.println("姓名："+name);},(String str)->{int age = Integer.parseInt(str.split(",")[1]);System.out.println("年龄："+age);});}private static void printInfo(String[] strArry, Consumer<String> con1,Consumer<String> con2){for (String str: strArry){con1.andThen(con2).accept(str);}}
}

3.4.3 Predicate

表示对一个参数进行判断的，返回一个布尔值

下图是Api文档中对Predicate接口方法的描述

• Predicate<T>:常用的四个方法

• boolean test(T t):对给定的参数进行判断(判断罗辑由Lambda表达式实现)，返回一个布尔值

• default Predicate<T>negate0:返回一个逻辑的否定，对应逻辑非default

• Predicate<T>and(Predicate other): 返回一个组合判断，对应短路与

• defaultPredicate<T>or(Predicate other): 返回一个组合判断，对应短路或

3.4.3.1 Predicate<T> 接口通常用于判断参数是否满足指定的条件

public class PredicateDemo01 {public static void main(String[] args) {boolean b = checkString("hello", (String s) -> {return s.length() > 8;});System.out.println(b);}private static boolean checkString(String s, Predicate<String> pre){return pre.test(s);}
}

3.4.3.2 negate逻辑非的运算

    private static boolean checkString(String s, Predicate<String> pre){
//        return !pre.test(s);   这种情况是我们之前的饿用法return pre.negate().test(s);}

3.4.3.3 组合判断，对应短路与

public class PredicateDemo01 {public static void main(String[] args) {boolean b = checkString("hello",(String s) -> {return s.length() > 8;},(String s) -> {return s.length() <15;});System.out.println(b);}//  同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终的结果private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
//        
//        boolean b1 = pre1.test(s);
//        boolean b2 = pre2.test(s);
//        boolean b = b1 && b2;
//        return b;return pre1.and(pre2).test(s);}
}

3.4.3.4 组合判断，对应短路或

    private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {return pre1.or(pre2).test(s);}

3.4.3.5 筛选满足条件的数据

• String[] strArray={"林青霞,30","柳岩,34","张曼玉,35","貂蝉,31","王祖贤,33"};

• 字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符审筛选到集合ArraList中，并遍历ArrayList

• 集合同时满足如下要求:姓名长度大于2;年龄大于33

public class PredicateDemo02 {public static void main(String[] args) {String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};ArrayList<String> arrayList = myFilter(strArray,(String s) -> {return s.split(",")[0].length() > 2;}, (String s) -> {return Integer.parseInt( s.split(",")[1])>33;});System.out.println(arrayList);}private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {ArrayList<String> arrayList = new ArrayList<>();
//    便利数组for (String str : strArray) {if (pre1.and(pre2).test(str)) {arrayList.add(str);}}return arrayList;}
}

3.4.4 Function

Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值

• R apply(T t): 将此函数应用于给定的参数

• default<V> Function andThen(Function after): 返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果

public class FunctionDemo {public static void main(String[] args) {convert("100",(String s)->{return Integer.parseInt(s);});}
//  将String转化为integerprivate static void convert(String s, Function<String, Integer> function){Integer apply = function.apply(s);System.out.println(apply);}
}

3.4.4.1 按照指定要求操作数据

• String s="林青霞,30"

• 请按照我指定的要求进行操作:

• 1:将字符串截取得到数字年龄部分

• 2:将上一步的年龄字特串转换成为int类型的数据

• 3:将上一步的int数据加70，得到一个int结果，在控制台输出请通过Function接口来实现函数拼接

public class FunctionDemo {public static void main(String[] args) {convert("林青霞,30",(String s) -> {
//                  提取出30return s.split(",")[1];},
//               将字符串转换成Integers1 -> {return Integer.parseInt(s1);},
//              将这个数加70s2 -> {return s2+70;});}//  将String转化为integerprivate static void convert(String s, Function<String, String> function1, Function<String, Integer> function2, Function<Integer, Integer> function3) {
//        Integer apply = function1.apply(s);
//        System.out.println(apply);Integer integer = function1.andThen(function2).andThen(function3).apply(s);System.out.println(integer);}
}