/**
     * 【接口中 默认方法 有方法体】
     *      JDK8之前，接口中可以定义 变量、方法：
     *          变量 必须 为 public static final修饰
     *          方法 必须 为 public abstract 修饰
     *
     *      JDK8及以后，接口中可以定义 普通方法（有方法体）
     *          default
     *          static
     *
     */
    interface MyJDK8{

        void test1();

        default void test2(){
            System.out.println("test2...");
        }

        static void test3(){
            System.out.println("test3...");
        }

    }

    class MyJDK8Impl implements MyJDK8{
        @Override
        public void test1() {
            System.out.println("test1...");
        }
    }

/**
     * 【lambda表达式】
     *      why？
     *          期望 使用 接口的方法：
     *              a,写一个class 实现接口；
     *              b,使用匿名内部类；
     *      好处：
     *          简化 匿名内部类的调用；
     *
     *      How？
     *          使用 lambda表达式 依赖于 函数式接口；
     *
     *          【函数式接口】
     *              what？
     *                 接口 只有 一个 抽象方法，可以 认为该接口是 函数式接口，可以用 @FunctionalInterface 标识
     *              规范：
     *                  函数式接口中 允许 重新 Object方法；
     *                  函数式接口中 允许 default、static方法；
     *
     *       语法：
     *          () :参数列表
     *          -> ：分隔符
     *          {}  :方法体
     *
     *        使用：
     *           a, 无参
     *           b, 有参
     *
     */
    interface MyLambda{
        void test();
    }

    void testInterfaceMethod(){

        // 使用匿名内部类
        new MyLambda(){
            @Override
            public void test() {
                System.out.println("test...");
            }
        }.test();

        // 使用lambda
        ((MyLambda) () -> System.out.println("test...")).test();
    }

    @FunctionalInterface
    interface MyFuncInterface{

        // 唯一 抽象方法
        void test();

        default void test1(){
            System.out.println("test1...");
        }

        static void test2(){
            System.out.println("test2...");
        }

        // Object 方法
        String toString();
    }

    void testMyFuncInterface(){
        MyFuncInterface m = () -> System.out.println("aa");
        m.test();

        // 简化
        ((MyFuncInterface) () -> System.out.println("aa")).test();
    }

    @FunctionalInterface
    interface MyFuncInterface1{
        String test(String a, String b);
    }

    void testMyFuncInterface1(){
        MyFuncInterface1 m = (a, b) -> {
            return a + ":" + b;
        };
        m.test("a", "b");

        // 简化
        MyFuncInterface1 m1 = (a, b) -> a + ":" + b;

        ((MyFuncInterface1) (a, b) -> a + ":" + b).test("aaaa", "bbbbb");

    }