lamda表达式

/**
 * 符合lambda表达式的接口也叫函数式接口:
 * 除了默认方法和Object类的方法外,只有一个抽象方法的接口才能符合lambda表达式的要求
 * 可以使用@FunctionalInterface来校验,如果没报错就是符合要求的
 *
 *
 */
@FunctionalInterface
public interface Animal {

    default String getName(){
        return "animal";
    }

    void eat();

}
//无参有返回
public interface Person {
    String getName();
}
//有参无返回
public interface Sckool {

    void learn(String name);
}
//有参有返回
public interface Student {
    String conCat(String str,String str2);
}
package lambda;

public class testLambda {
    public static void main(String[] args) {
        //要调用一个接口的方法,要么定义一个类来实现该接口,要么使用匿名内部类:
        //下面使用匿名内部类:

        eat(new Animal() {
            @Override
            public void eat() {
                System.out.println("动物吃东西");
            }
        });
        /**
         * 如果匿名内部类只有一个方法,可以使用lambda表达式替换:
         *  总共分下面4种情况:
         *          无参无返回格式:
         *              单条语句时()->xxx ;多条语句时()->{xx;aa;}
         *          无参有返回:
         *              单条语句时()->xxx;多条语句时()->{xx; return aa;}
         *          有参无返回:
         *              单条语句单个参数时:a->xxx;多条语句单个参数时a->{xx;cc;}
         *              单条语句多个参数时:(a,b)->xxx;多条语句多个参数时(a,b)->{xx;cc;}
         *
         *          有参有返回:
         *              单条语句单个参数时:a->xxx;多条语句单个参数时a->{xx;return cc;}
         *              单条语句多个参数时:(a,b)->xxx;多条语句多个参数时(a,b)->{xx; return cc;}
         */

        //-------- 无参无返回格式:
        //单条语句时()->xxx
        eat(()-> System.out.println("aaa"));

        //多条语句时()->{xx;aa;}
        eat(()->{
            System.out.println("dd");
            System.out.println("cc");
        });

        //---------无参数有返回格式:
        // 单条语句时()->xxx;
        String name=getName(()->"kk");

        //多条语句时()->{xx; return aa;}
        getName(()->{
            System.out.println("dd");
            return "cc";
        });

        //--------有参数无返回时

        //单条语句单个参数时
        learn(a-> System.out.println(a));

        //多条语句单个参数时a->{xx;cc;}
        learn(a->{
            System.out.println("lll");
            System.out.println("cc");
        });

        //单条语句多个参数时
        // learn((a,b)-> System.out.println(a+b));

        //多条语句多个参数时(a,b)->{xx;cc;}
        /**
         *
         *  learn((a,b)-> {
            System.out.println("lll");
            System.out.println("cc");
            });

         *
         */

        //---------有参数有返回

        //单条语句单个参数时:a->xxx;
        // learn(a-> "dd");

        //多条语句单个参数时a->{xx;return cc;}
        /**
         *   learn(a->{
                System.out.println("lll");
                 return "ss";
                });
         *
         *
         */

        //单条语句多个参数时:(a,b)->xxx
        String subject=concat((a,b)->a+b);

        //多条语句多个参数时(a,b)->{xx; return cc;}
        String subject2=concat((a,b)->{
            System.out.println("ddd");
            return a+b;
        });

        /**
         *
         * 我们使用lambda表达式时候,都是要实现一个方法,如果你要实现的方法刚好其他类有,那么就可以引用其他类的方法过来当做该匿名内部类的实现
         * 所以方法的引用分为:
         * 静态方法的引用,如System.out:println
         * 非静态方法的引用:如 new Dog()::eat;
         * 参数类型方法的引用,例如一个要实现的方法参数是String a,String b ,期望的结果是a+b,那么可以引用String::concat方法
         *
         *
         */

        learn(System.out::print); //刚好learn的内部类要实现的方法跟System.out的方法长得一样,所以可以引用该方法当做自己的实现方法
        eat(new testLambda()::haveMeal);//非静态方法的引用
        String str=concat(String::concat);//参数
        System.out.println(str);



    }

    public static void eat(Animal animal){
        animal.eat();
    }
    public static String getName(Person person){
        return person.getName();
    }
    public static void learn(Sckool sckool){
        sckool.learn("java");
    }
    public static String concat(Student student){
        return student.conCat("java","php");
    }

    public void haveMeal(){
        System.out.println("吃饭");
    }
}