Java8新特性（入门）

在Java8之前接口中的方法默认都是 public abstract 修饰的抽象方法且没有方法体，而在Java8时，对接口增加了static方法和default方法。

1、static方法

1.1、代码实例

代码示例如下：

public interface MyInterface {

    /**
     * TODO 功能描述
     *
     * 普通的接口中的方法
     * Create At 2021/09/07 14:12 By dujlc
     */
    void method();

    /**
     * TODO 功能描述
     * <p>
     * <p> java8之后接口中的静态方法
     * Create At 2021/09/07 14:13 By dujlc
     */
    static void staticMethod() {
        System.out.println("Java8 static method...");
    }

}

// 测试类
public class Test {
    public static void main(String[] args) {
        MyInterface.staticMethod();
    }
}

1.2、总结

1、接口中被static修饰的方法必须有方法体。
2、在其它的方法中和普通的静态方法一样可以。直接用 接口名.方法名进行调用 。
3、静态方法只能自己使用，子接口不能继承父接口的静态方法。
4、实现类不能复写接口的静态方法.

2、default方法

2.1、代码示例

public interface MyInterface {

    /**
     * TODO 功能描述
     *
     * 接口中的默认方法
     * Create At 2021/09/07 14:27 By dujlc
     */
    default void defaultMethod(){
        System.out.println("Java8 default method...");
    }
}

// 实现类重写
public class MyInterfaceImpl implements MyInterface {
    @Override
    public void defaultMethod(){
        // 调用父类接口的默认方法
        MyInterface.super.defaultMethod();
        System.out.println("MyInterfaceImpl...");
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        MyInterface myInterface = new MyInterfaceImpl();
        myInterface.defaultMethod();
    }
}

2.2、总结

1、接口中的default方法必须有方法体。
2、可以通过实现类来调用接口中的default方法。
3、default方法可以被子接口继承使用。
4、实现类以及子接口的实现类都可以复写default方法。

3、函数式接口

3.1、什么是函数式接口

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
函数式接口可以被隐式转换为 lambda 表达式。
@FunctionalInterface 注解代表当前接口为一个函数式接口。

Java8之前的函数式接口

类的完整限定名
java.lang.Runnable
java.util.concurrent.Callable
java.security.PrivilegedAction
java.util.Comparator
java.io.FileFilter
java.nio.file.PathMatcher
java.lang.reflect.InvocationHandler
java.beans.PropertyChangeListener
java.awt.event.ActionListener
javax.swing.event.ChangeListener

Java8时增加的函数式接口

类的完整限定名
java.util.function

4、Lambda对匿名内部类的简写

4.1、代码示例

public interface MyInterface {
    /**
     * TODO 功能描述
     * 计算两个整数的和的方法
     * @param num1  加数1
     * @param num2  加数2
     * @return
     *
     * Create At 2021/09/07 15:02 By dujlc
     */
    int sum(int num1, int num2);
}

// 测试类
public class Test {
    public static void main(String[] args) {
        // 使用匿名内部类的方式去调用，针对于接口
        MyInterface myInterface = new MyInterface() {
            @Override
            public int sum(int num1, int num2) {
                return num1 + num2;
            }
        };

        /**
         * 使用 Lambda 表达式的写法：常规写法
         */
        MyInterface myInterface2 = (int num1, int num2) -> {
            return num1 + num2;
        };

        /**
         * 使用 Lambda 表达式的写法：简写写法
         *      1、形参列表中的数据类型可以不写，会自动推断
         *      2、如果方法体中的代码只有一句，可以省略掉大括号，如果是return返回数据的，可以省略掉 return
         *      3、如果只有一个参数的话，参数的括号也可以省略掉
         */
        MyInterface myInterface3 = (num1, num2) -> num1 + num2;;

        int sum = myInterface3.sum(300,2);
        System.out.println("和为：" + sum);
    }
}

5、Lambda中使用的变量

Lambda中使用的变量必须为final修饰的变量，就算我们自己不写final修饰符，代码在编译的过程中还是会自己去加上final修饰符，如果下面的代码对这个变量进行操作的话，就会报错。

5.1、代码示例

public interface MyInterface {
    /**
     * TODO 功能描述
     *
     * 测试打印类
     * Create At 2021/09/07 15:36 By dujlc
     */
    void print();
}

// 测试类
public class Test {
    public static void main(String[] args) {
        String str = "Hello MY";

        // 使用匿名内部类的方式去调用，针对于接口
        MyInterface myInterface = new MyInterface() {
            @Override
            public void print() {
                System.out.println(str);
            }
        };

        str = "111";

        myInterface.print();
    }
}

其实上面的代码已经报错，具体看下图：

6、Lambda构造方法的引用

6.1、代码示例

// 实体类
public class Person {

    private String firstName;

    private String lastName;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    @Override
    public String toString() {
        return "Person{" +
                "firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                '}';
    }
}

// 用于构造匿名函数的接口
public interface PersonFactory {
    /**
     * TODO 功能描述
     *
     * @param firstName
     * @param lastName
     * @return
     * 创建人
     * Create At 2021/09/07 16:09 By dujlc
     */
    Person createPerson(String firstName, String lastName);
}

// 测试类
public class Test {
    public static void main(String[] args) {
        // 使用匿名内部类的方式去调用，针对于接口
        PersonFactory personFactory = new PersonFactory() {
            @Override
            public Person createPerson(String firstName, String lastName) {
                return new Person(firstName,lastName);
            }
        };

        /**
         * 使用 Lambda 表达式的写法：常规写法
         */
        PersonFactory personFactory2 = (String firstName, String lastName) ->
                new Person(firstName,lastName);

        /**
         * 使用 Lambda 表达式的写法：简写写法
         *      前提是外面传入的参数名必须和里面的参数名一致
         */
        PersonFactory personFactory3 = Person::new;

        Person person = personFactory3.createPerson("ss", "ww");
        System.out.println(person);

    }
}

6.2、总结

PersonFactory personFactory3 = Person::new;
这句代码的意思就是调用 Person实体的 new（这个new就是调用构造方法，会根据当时传入的参数个数以及类型去匹配）。

7、Lambda静态方法的引用

7.1、代码示例

public interface ParseInterface {
    /**
     * 将字符串转化为int类型
     * @param str
     * @return
     */
    int parse(String str);
}

// 测试类
public class Test {
    public static void main(String[] args) {
        // 使用匿名内部类的方式去调用，针对于接口
        ParseInterface parseInterface = new ParseInterface() {
            @Override
            public int parse(String str) {
                return Integer.parseInt(str);
            }
        };

        /**
         * 使用 Lambda 表达式的写法：常规写法
         */
        ParseInterface parseInterface1 = str -> Integer.parseInt(str);

        /**
         * 使用 Lambda 表达式的写法：简写写法
         */
        ParseInterface parseInterface2 = Integer::parseInt;

        int parse = parseInterface2.parse("123");
        System.out.println(parse);

    }
}

7.2、总结

ParseInterface parseInterface2 = Integer::parseInt;
这行代码相当于直接调用 Integer的parseInt方法

8、Lambda实例方法的引用

8.1、代码示例

// 测试类
public class Test {
    public static void main(String[] args) {
        /**
         * 需求：
         *      已知 String 中有一个实例方法（非静态的） endsWith
         *      想自己写一个类封装上面这个方法
         *
         *      借助于java8，提供的一个接口 function
         *      @FunctionalInterface
         * public interface Function<T, R> {
                R apply (T t);
            }
         */

        // 被判断的字符串
        String str = "hello.txt";

        // 使用匿名内部类的方式
        /*Function<String,Boolean> function = new Function<String, Boolean>() {
            @Override
            public Boolean apply(String s) {
                return str.endsWith(s);
            }
        };
        Boolean flag = function.apply("123");
        System.out.println(flag);*/

        /**
         * 使用  Lamdba 表达式常规写法
         */
        /*Function<String,Boolean> function = s -> str.endsWith(s);
        Boolean flag = function.apply("txt");
        System.out.println(flag);*/

        /**
         * 使用  Lamdba 表达式 简写
         */
        Function<String,Boolean> function = str::endsWith;
        Boolean flag = function.apply("123");
        System.out.println(flag);

    }
}

8.2、总结

Function<String,Boolean> function = str::endsWith;
这句代码的意思就是直接调用 str 的 endsWith方法。