package com.itheima.yaoyao;

​

import java.util.Random;

​

public class LambdaDemo2 {

    public static void main(String[] args) {

        //基于匿名内部类调用useInterOne:分析有一个InterOne接口【快速创建接口的实现类对象】 怎么做!

        useInterOne(new InterOne() {

            @Override

            public void methodOne() {

                System.out.println("无参无返匿名内部类调用");

            }

        });

​

​

        //基于Lambda表达式调用useInterOne:分析(1)必须要传递InterOne接口实现类对象【省略】(2)必须要实现methodOne抽象方法【省略】

        //methodOne方法的逻辑【不能！】传递methodOne方法的逻辑(剩余的事情由Java来做) 【基于Lambda表达式来做methodOne方法的逻辑载体】

       useInterOne(()->{System.out.println("lambda表达式表示无参无返");});

​

​

        //基于匿名内部类调用useInterTwo

        useInterTwo(new InterTwo() {

            @Override

            public Integer methodTwo() {

                return 100;

            }

        });

​

​

        //基于Lambda表达式调用useInterTwo:分析(1)必须要传递InterTwo接口实现类对象【省略】(2)必须要实现methodTwo抽象方法【省略】

        //methodTwo方法的逻辑【不能！】传递methodTwo方法的逻辑(剩余的事情由Java来做) 【基于Lambda表达式来做methodTwo方法的逻辑载体】

        //如果Lambda实现的方法需要返回值就要在{}中return回满足要求的结果

​

        useInterTwo(()->{

            return new Random().nextInt(100);

        });

​

        //基于匿名内部类调用useInterThree

        useInterThree(new InterThree() {

            @Override

            public void methodThree(String name, String food) {

                System.out.println(name+"爱喝"+food);

            }

        });

​

​

        //基于Lambda表达式调用useInterThree:分析(1)必须要传递InterThree接口实现类对象【省略】(2)必须要实现methodThree抽象方法【省略】

        //methodThree方法的逻辑【不能！】传递methodThree方法的逻辑(剩余的事情由Java来做) 【基于Lambda表达式来做methodThree方法的逻辑载体】

        //如果Lambda表达式作为方法的载体,方法声明了形式参数,在Lambda的()中也要声明同样形式参数

        useInterThree( (String name,String food) ->{

            System.out.println(name + "爱吃"+"小鸡炖蘑菇");

        });

​

​

        //基于匿名内部类调用useInterFour

        useInterFour(new InterFour() {

            @Override

            public String methodFour(String foodOne, String foodTwo) {

                return foodOne+"炖"+foodTwo;

            }

        });

​

​

        //基于Lambda调用

         useInterFour((String foodOne, String foodTwo) ->{return foodOne + "炒"+ foodTwo ;});

​

    }

​

    //编写4个方法分别将四个接口作为方法的参数【传递四个接口中不同类型的方法Lambda表达式】

    //在编写方法的时候并不明确方法的具体逻辑是什么 【多态:传递进来的实现类的实现逻辑是什么,这里就执行什么逻辑】

    public static void useInterOne(InterOne interOne) {

        interOne.methodOne();

    }

​

    public static void useInterTwo(InterTwo interTwo) {

        Integer result = interTwo.methodTwo();

        System.out.println("useInterTwo Result:" + result);

    }

​

    public static void useInterThree(InterThree interThree) {

        interThree.methodThree("张二狗", "西红柿炒洋柿子");

    }

​

    public static void useInterFour(InterFour interFour) {

        String result = interFour.methodFour("大葱", "笨鸡蛋");

        System.out.println("useInterFour Result:" + result);

    }

}

​

@FunctionalInterface

interface InterOne {

    //无参无返回值的抽象方法

    void methodOne();

}

​

@FunctionalInterface

interface InterTwo {

    //无参有返回值的抽象方法

    Integer methodTwo();

}

​

@FunctionalInterface

interface InterThree {

    //有参无返回值的抽象方法

    void methodThree(String name, String food);

}

​

@FunctionalInterface

interface InterFour {

    //有参有返回值的抽象方法

    String methodFour(String foodOne, String foodTwo);

}

​

  面试题:有人说Lambda就是匿名内部类的代替的方式,你是否认同? 【不认同】

    答案:(1)Lambda只能作用于接口,匿名内部类可以作用于抽象类【子类对象】/接口【实现类对象】/具体类【子类对象】

    (2)Lambda只能作用于函数式接口【只能有一个抽象方法】,匿名内部类作用于接口【接口中可以有任意个数的抽象方法】

    (3)匿名内部类本质上是通过语法底层生成一个.class文件,Lambda表达式不会额外生成.class文件【会在代码执行的时候动态编译】

    (4)思想层面的不同,匿名内部类体现还是面向对象【对象】,Lambda表达式体现的是函数式思想【作为方法逻辑的载体而出现】

 Collection<String> names = List.of("施恩", "徐宁", "郁保四", "李应", "周通", "公孙胜", "白胜", "汤隆", "张清", "皇甫端");

// 使用迭代器Iterator遍历集合中的元素

Iterator<String> iterator = names.iterator();

while (iterator.hasNext()){

    String next = iterator.next();

    System.out.println(next);

}

Collection<String> names = List.of("施恩", "徐宁", "郁保四", "李应", "周通", "公孙胜", "白胜", "汤隆", "张清", "皇甫端");

// 使用增强for循环遍历names集合

for (String name: names) {

    System.out.println(name);

}

Collection<String> names = List.of("施恩", "徐宁", "郁保四", "李应", "周通", "公孙胜", "白胜", "汤隆", "张清", "皇甫端");

​

// 使用Lambda表达式循环遍历names集合

names.forEach(element->{

    System.out.println(element);

});

​

names.forEach(new Consumer<String>() {

    @Override

    public void accept(String s) {

        System.out.println(s);

    }

});