函数式接口

/*
    Lambda表达式
    () -> {}

    Lambda表达式可以代替掉匿名内部类。

    Lambda标准格式
    (数据类型 变量名, 数据类型 变量名) -> {
        方法体;
        return 返回值;
    }

    Lambda表达式省略规则
        1. 参数位置的数据类型可以省略。
        2. 如果参数只有一个，那么可以省略小括号
        3. 如果大括号内只有一条语句，那么可以省略大括号，return，以及分号

    Lambda表示使用前提：
        1. 接口中有且仅有一个需要被重写的抽象方法。
        2. 必须支持上下文推倒。 要么把接口作为参数，要么用接口接收lambda表达式的结果。

    可推导就是可省略
 */
public class Demo01Lambada {
    public static void main(String[] args) {
        //使用匿名内部类创建多线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行了");
            }
        }).start();

        //使用lanbada表达式创建多线程
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "执行了");
        }).start();

        //使用lambada表达式的省略格式
        new Thread(() -> System.out.println(Thread.currentThread().getName() + "执行了")).start();
    }

}

例

import java.util.ArrayList;
import java.util.Collections;

public class Demo02Lambada {
    public static void main(String[] args) {
        //创建集合添加Person对象
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("张三庚", 18));
        list.add(new Person("灭绝师太", 19));
        list.add(new Person("赵丽颖", 18));
        //使用比较器排序对集合中的Person对象按照年龄从小到大进行排序
        /*
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });*/
        //使用lambda表达式
        Collections.sort(list, (o1, o2) -> o1.getAge() - o2.getAge());
        System.out.println(list);


    }
}

/*
        请定义一个函数式接口 Eatable ，内含抽象 eat 方法，没有参数或返回值。使用该接口作为方法的参数，并进而
        通过Lambda来使用它。
        Lambda表达式是作为接口中抽象方法的内容存在的
        */
public class Demo01LambadaTest {
    public static void method(Eatable eatable) {
        eatable.eat();
    }

    public static void main(String[] args) {
//使用匿名内部类吃
        method(new Eatable() {
            @Override
            public void eat() {
                System.out.println("\"使用匿名内部类吃饭饭， 很难吃\"");
            }
        });
        //使用lambada表达式吃

        method(() -> {
            System.out.println("使用lambada吃饭");
        });



    }

}

package cn.itcast.demo02函数式接口;

public interface Eatable  {
    void eat();
}

 

-------------------------------------------------------------------------------------------------------------

        请定义一个函数式接口 Sumable ，内含抽象 sum 方法，可以将两个int数字相加返回int结果。使用该接口作为方法
        的参数，并进而通过Lambda来使用它
        */
public class Demo02LambdaTest {
    public static void main(String[] args) {
    /* method(new Sumable() {
         @Override
         public int getSum(int a, int b) {
             return a+b;
         }
     });*/
        //使用lambada表达式改进
        method((a, b) -> {
            return a + b;
        });
//        使用lambada表达式改进
        method((a, b) -> a + b);


    }

    public static void method(Sumable sumable) {
        int result = sumable.getSum(10, 20);
        System.out.println(result);
    }
}

package cn.itcast.demo02函数式接口;

public interface Sumable {
   int getSum(int a,int b);
}

------------------------------------------------------------------------------------------------------------

/*
    函数式接口

    如果一个接口内有且仅有一个需要被重写的方法，那么这个接口就是一个函数式接口

    函数式接口的作用：
        1. 可以当做普通接口去使用  implements
        2. 当做Lambda表达式的使用前提

    有一个注解，可以验证一个接口是否是函数式接口。这个注解叫做FunctionalInterface

    如果一个接口只有一个需要被重写的抽象方法，但是这个接口上面没有FunctionalInterface这个注解，这个
    还是函数式接口
 */
public interface MyInterface {
    void method();

}

public class Fu {
    public void method() {
        System.out.println("父类的方法");
    }
}

public class Zi extends Fu{
    @Override
    public void method() {
        super.method();
    }
}