谈一下对本节使用的泛型的理解： List接口继承自Iterable接口，获得Iterable接口的forEach方法。 forEach方法的参数Consumer也是一个接口。 因此最终的实现类继承自List接口，调用forEach时，得让这个Consumer接口引用指向实现该Consumer接口的对象（代码中使用匿名类实现）。 foreach方法的Consumer引用使用了逆变泛型，要求实际使用的类型为T类或其父类。举个例子，假设B类继承自A类，则List泛型类型为B类（则Iterable泛型类型也为B类）时，用到的Consumer的泛型类型可以为A类。这时，Consumer的accept方法要求参数为A类引用，实际传入的是B类引用，符合“子类引用可以给父类引用赋值”的规范。

继续上一个留言的解释部分： 这里我们不在单独定义实现类，有两种方法： 1.匿名类 2.lambda 匿名类的实现原理本质就是定义了一个Consumer的实现类，然后new该类实例并作为ForEach()的参数。匿名类只是一种简便写法，本质没差别。 而lambda又是什么底层原理呢？ 看着strs.forEach(s -> System.out.println(s + "_test")); 这种语法总觉得有点茫然。以前往方法里传过基本数据类型，传过引用数据类型，忽然传了串乱码一样的东西就不知道怎么回事了。 我尝试放开Consumer接口中acceptInt(int s)的注释，让Consumer接口有两个抽象方法。然后发现AppMain中的lambda表达式出错了。 报错信息是： Multiple non-overriding abstract methods found in interface com.cebj.javaBasic.learnLambda.demo1.Consumer 意思是说Consumer接口中有多个没有实现的抽象方法。感觉好像对lambda底层的机制有点眉目了。 前面用匿名类对象作为forEach()参数，本质上传递的是Consumer的实现类的对象。而lambda表达式由于让Consumer有了两个抽象方法就报错了，所以我推测lambda也是在底层自己搞了个类实现了Consumer接口（不然不会报错）。而 "s -> System.out.println(s + "_test")" 这个lambda表达式则变成了这个实现类实现的方法体 。然后Java将这个实现类的实例作为参数传到了forEach()中。 所以如果想使用lambda，需要满足以下条件 1.调用方法(forEach)的参数要定义成接口类型，即这里的Consumer要是一个接口： 2.接口中只能有一个抽象方法：Consumer中只能有一个抽象方法，不然Java去创建这个实现类的时候会不知道要实现哪个方法。因为lambda表达式其实只能反映一个方法的内容。 另外在定义lambda表达式的时候需要注意，要让lambda表达式满足接口中唯一抽象方法的参数、返回值、异常类型。

老师，感觉视频里有个问题： IterateListLambdaAppMain这个类的代码中，讲到： myList.forEach(IterateListLambdaAppMain::processString); 这行代码时，说到： 如果不使用外部变量，可以使用上述的调用方式：类名::方法名 但是IterateListLambdaAppMain::processString这个函数是有参数的。 private static void processString(String str) { System.out.println(str); } 我的理解是这样的： 这里可以使用lambda表达式，即 (s) -> {System.out.println(s);} 也可以有替代的选择，那就是传入一个自己定义的方法，比如这里的IterateListLambdaAppMain::processString。 这个自己定义的方法可以有参数，可以有返回值，也可以是静态的以及非静态的，但不论什么样，这个方法要与接口Consumer接口中的抽象方法保持一致（参数，返回值，异常类型一致） 不知道我的理解对不对

老师您好！lambda在Java的表现形式一共分多少种？

老师，为什么WindowAdapter()无法使用lambda替换？是因为需要覆写多个方法吗

为了更好地理解lambda，我把ArrayList的泛型去掉了，单纯模仿Java的Iterable和Consumer抽象，来自己实现一个forEach()。 由于留言只允许2000字，我超了，就分成两部分，代码和解释： 这里是代码部分： public interface Consumer { void acceptStr(String s); // void acceptInt(int s); } *************************** public interface Iterable { default void forEach(Consumer action) { for (int i = 0; i < MyArrayList.LENGTH; i++) { action.acceptStr(get(i)); } } String get(int index); } ****************** public class MyArrayList implements Iterable { public static final int LENGTH = 10; private String[] elements = new String[LENGTH]; public MyArrayList() { for (int i = 0; i < LENGTH; i++) { elements[i] = "str" + i; } } @Override public String get(int index) { return elements[index]; } } ***************************** public class AppMain { public static void main(String[] args) { MyArrayList strs = new MyArrayList(); System.out.println("---------------最原始的for循环---------------"); for (int i = 0; i < MyArrayList.LENGTH; i++) { System.out.println(strs.get(i) + "_test"); } System.out.println("---------------匿名内部类实现---------------"); strs.forEach( new Consumer() { @Override public void acceptStr(String s) { System.out.println(s + "_test"); } }); System.out.println("---------------lambda实现---------------"); strs.forEach(s -> System.out.println(s + "_test")); } } ****************************************

这节课13分钟，我看了快3天了，有很多体会，麻烦老师帮忙看一下对不对。 体会1： 对象拥有什么？其拥有属性，也拥有方法。那么当我们把对象作为方法参数，我们就既传递了数据，也传递了方法。虽然这些属性和方法都是对象级别的。但是拥有了对象，方法也可以通过反射得到类的static属性和方法，甚至构造函数。所以只要传递了对象，就得到了类中的一切。无论是哪种属性哪种方法，只要是类里的，我们都可以得到。 而lambda就两个特征：1.函数可以单独存在 2.函数可以作为参数或返回值 在Java8之前，Java做不到1，但部分做得到2。所以我是不是可以这样认为，Java8之前，Java其实可以部分实现lambda功能（即2，通过将方法封装在类里，借助类对象传递方法），但用着不太方便。 那Java8引入lambda，实际上是为了让语法更为简单，让函数式编程在Java中更好用。 体会2： 从接口的设计分析： Iterable和Consumer： Iterable负责遍历Collection中的元素，Consumer则负责对遍历出的每个元素执行操作。从抽象的角度看，Iterable抽象了遍历的功能，Consumer抽象了操作的功能。这两个功能本质上来说，应该是ArrayList的功能。（一个容器类，当然要负责遍历自己呀，遍历自己时执行的操作当然也要负责呀）。那Java为什么要把这两个功能定义成接口呢？这么设计的目的是是为了什么呢？这样做不是让设计更为复杂吗？ 之前学到接口的时候，老师说接口其实是规范了一种行为，规范了一批实现类的行为。 就是说接口是多态的，一个接口可以指向不同的实现类，对应多种不同的实现。那调用者不用关注具体实现，只用关注接口中的规范即可。 那把类的行为抽离出来（抽象成接口）的好处就是： 1.将来好引入新的不同的实现，代码扩展性强 2.调用者只关注接口的规范，不用在考虑具体的实现细节，封装了细节。调用起来也舒服、优雅 那么基于上面的说法，我是不是可以这样理解，其实接口本质就是抽取。把一个类的某种行为抽取出来，形成一个接口，将来就可以让这个行为有不同的实现，提高代码可扩展性。 所以前面课程里说 “要面向接口开发，而不是面向实现开发” 本质就是说，我们要学会抽象，拿到一个现实对象，要去分析它有什么行为。然后分析多个现实对象的行为是不是有类似的地方，然后再抽象成更为抽象的行为？

老师有个问题： 例子1： public class AppMain { public static void main(String[] args) { List<String> strs = addElementsToList(new ArrayList<>()); strs.forEach(new Processer<String>()); strs.forEach(new Processor<String>()); } private static List<String> addElementsToList(List<String> list) { for (int i = 0; i < 5; i++) { list.add("str" + i); } return list; } } ******************* import java.util.function.Consumer; public class Processer<T> implements Consumer<T> { @Override public void accept(T t) { System.out.println(t + "_impl1"); } } ************************ import java.util.function.Consumer; public class Processor<T> implements Consumer<T> { @Override public void accept(T t) { System.out.println(t + "_impl2"); } } 这里在调用strs.forEach(new Processer<String>())时，我定义的Processer类其实实现了Consumer接口，因此才能作为forEach()函数的参数。但是IterateListLambdaWhereAppMain例子中，好像并没有人来实现Consumer接口 老师的例子： public class IterateListLambdaWhereAppMain { public static void main(String[] args) { List<String> myList = addElementsToList(new ArrayList<>()); // action.accept 就直接跳到了我们的方法，其实中间 Java 一顿后台操作 // 帮我们生成了一个匿名类来实现接口，并调用我们提供的方法 myList.forEach(IterateListLambdaWhereAppMain::processString); } public static List<String> addElementsToList(List<String> list) { for (int i = 0; i < 10; i++) { list.add("str" + (i % 5)); } return list; } private static void processString(String str) { throw new RuntimeException(); } } 那么按照上面的说法，如果我们想把自己定义的action作为forEach的参数，那我们定义的类需要实现接口Consumer。 那这里processString方法是定义在类IterateListLambdaWhereAppMain中的，我们并没有看到其实现了Consumer接口。那processString方法为什么能作为forEach()的参数呢？ 老师说是Java在后台帮我们生成了匿名类，这点我理解不了，一个匿名类实现了Consumer接口，那他一定是自己实现了自己的accept方法。那么调用的时候应该跳转到该匿名类的accept方法内部去执行，为什么在debug的时候我们发现它跳转到了我们的processString方法中呢？

老师，请教个问题;Supplier<String> supplier = String::new; 这条语句是属于静态方法调用，还是参数类型里的方法调用，还是其他的方式，分不清了。。。。。

滴滴滴～来分享一下我在这节课遇到的问题，以及我现在是怎样把这个问题解决来的 首先我遇到的问题是：老师讲解的那个静态内部类不太理解 那来附上代码： // TODO 匿名内部类版 myList.forEach( new Consumer<String>() { @Override public void accept(String s) { processString(outside + s); } } ); 这个问题我是对着下面的关于lambda方法的简化版去解决的 首先我在myList.forEach(IterateListLambdaAppMain::processString); 这段代码处设置了一个debug 然后去看这个代码是如何调用的，首先呢，我们是往这个forEach里传了一个这个类内部的一个processString方法进去，然后呢这个forEach去调用了Arraylist里的forEach这个方法，这个方法里面有一个accept方法，这个方法呢又去调用了processString方法里设置好的一个输出语句，最后输出，到这里整个调用就完成了。我们就可以把我们往myList里添加的元素，一个个的输出出来 那么对比分析老师讲的那个匿名内部类版的myList.forEach（。。。）的这个方法是不是可以一样的去对比者去想呢？ 还是一样首先往for里去传一个参数，这个参数里有一个内部类。我们的myList.forEach就会去调用这个内部类，这个内部类就会执行自己的输出语句操作，从而将我们一开始向我们往mylist里添加的元素，一个个的打印出来。 都是一个道理。但是我想了很久才明白🤣🤣🤣 属实有滴笨勒😅 希望大家如果出了一样滴问题，也都能想的开，哈哈哈哈哈哈哈哈～